VANTARIX

Security infrastructure for autonomous agents.

Vantarix enforces policy before autonomous agents execute onchain transactions.

  • Base Sepolia
  • Pilot open
  • Unaudited

How it works

Control what autonomous agents can execute.

Vantarix evaluates every transaction an autonomous agent proposes against defined policy before execution.

Agent
Autonomous agent

Proposes a transaction. Holds no funds.

Vantarix
Policy enforcement

Evaluates the request against policy before anything executes.

Decision
ALLOWBLOCK

The request is within policy.The request violates policy.

Safe wallet
Safe

Executes the call through the Safe module.Not reached. Nothing is sent.

Onchain
Base Sepolia

The transaction is confirmed.No transaction is created.

In the product

Every request gets an explicit decision.

Each request is recorded with the agent, the action, the rule that decided, and the result.

The Vantarix activity page showing three real decisions on Base Sepolia: one allowed and confirmed onchain, two blocked.

Real activity from the Vantarix activity page, recorded on Base Sepolia with test funds only. The allowed transfer is a confirmed onchain transaction: view it on Basescan.

The problem

Autonomous execution changes the security model.

When an autonomous agent can initiate transactions, the security boundary can no longer stop at the wallet. The system needs to evaluate what the agent is attempting to do before that action reaches the chain.

Without enforcement

  • The agent holds signing authority.
  • The wallet signs what it is given.
  • Limits, if any, apply after the decision is made.

With Vantarix

  • The agent proposes a request.
  • Policy is evaluated before execution.
  • Only an allowed request reaches the Safe.
  1. Agent request

    The agent submits a signed request: target contract, value and calldata.

  2. Policy evaluation

    The request is checked against the live policy: contracts, functions and amounts.

  3. Allow or block

    Every request gets an explicit decision and the rule that decided.

    ALLOW continues to executionBLOCK stops here
  4. Execution

    Only an allowed request is signed and executed through the Safe module.

Capabilities

What the system does today.

Each capability is marked as implemented or planned.

Policy enforcement

Define which contracts and functions an agent is permitted to call. Policies are versioned and hashed, and verified before use.

Implemented

Spend limits

ETH limits per transaction and over a key's lifetime. Per-token limits on transfer, approve and transferFrom amounts.

Implemented

Allow / Block

Every request receives an explicit decision, with the rule that decided.

Implemented

Fail-closed

If enforcement cannot safely determine authorization, execution does not proceed. An unreachable service sends nothing.

Implemented

Auditability

Requests, decisions and execution results are recorded and viewable on an activity page. Records are append-only.

Implemented

Kill switch

An operator can revoke an agent's session key in one transaction.

Implemented

Onchain decision anchoring

Anchoring decision records onchain through EAS, so records can be verified independently.

Planned

Architecture

The execution path, layer by layer.

The service decides. The chain enforces. Neither takes the other's word for it.

Autonomous agent

Off-chain

Signs each request with an identity key. The key holds no funds and cannot move any.

ProducesSigned request: target, value, calldata, nonce, timestamp

Vantarix API / policy engine

Off-chain

Verifies the signed request, evaluates it against the live policy, signs an ALLOW decision, records the outcome, and relays allowed transactions.

ChecksAgent signature, registered session key, timestamp, onchain nonce, policy version hash

Onchain verification begins

Session key / authorization

Onchain

The SessionKeyManager contract holds hard bounds for each session key, independent of the service.

EnforcesAllowed contracts and functions, value caps, token caps, expiry, revocation

Policy enforcement module

Onchain

A Safe module. Verifies the decision signature, then consumes the bounds and executes through the Safe.

ChecksDecision signer, nonce, expiry, bounds. Calls to the Safe itself are refused

Safe

Onchain

Holds the funds. Runs the call as a module transaction. Call only, never delegatecall.

HoldsThe funds. The agent has no key to the Safe

Base

Onchain

Base Sepolia during the pilot.

ResultConfirmed transaction, recorded with the decision

If the off-chain service is compromised, the onchain bounds still apply. The worst case is limited by the caps set for the session key.

Developers

Integrated where the agent submits a transaction.

Vantarix sits in the agent's execution flow. Today the integration surface is one TypeScript SDK file and an HTTP API. Documentation is provided during the pilot.

  • GET/v1/nonce/:sessionKey

    Current onchain nonce for the agent's session key.

  • POST/v1/execute

    Submit a signed request. Returns the decision and, if allowed, the onchain result.

  • POST/v1/proposals

    Get a decision and signature without executing.

  • GET/v1/decisions

    Request log with decisions, reasons and execution results.

Identity key
Signs requests. Holds no funds.
Session key
The onchain identity that bounds are tracked against.
Outcomes
EXECUTED, BLOCKED, REVERTED or RELAY_FAILED.
Before: the agent holds a funded key
await wallet.sendTransaction({
  to, data
});
After: the agent asks Vantarix
const result = await
  vantarix.execute({ to, data });

result.outcome
  EXECUTED
  BLOCKED
  REVERTED
  RELAY_FAILED
result.reason    set when BLOCKED
result.txHash    set when EXECUTED

If the SDK cannot reach Vantarix it throws, and nothing is sent. There is no direct-send path.

Request documentation

Security

What is enforced, and what is not.

The limits of the system are part of the security model, so they are listed here.

Enforced

  • Calls only to the contracts and functions on the allowlist
  • ETH limits per transaction and over the key's lifetime
  • Per-token amount limits. A token with no cap is refused
  • Session key expiry and revocation
  • Single-use, short-lived decisions, checked onchain by nonce and expiry
  • Policy versions verified by hash before use

Not covered yet

  • Bad rules. A policy is only as strong as its limits
  • Amounts inside swap-style calls. Only ETH, transfer, approve and transferFrom amounts are decoded
  • Rolling-window limits. Limits are lifetime totals per key
  • Compromise of the Safe's owner keys
  • Onchain anchoring of decision records. Planned
  • An external audit. None yet

Engineering status

NetworkBase SepoliaDeployed on testnet.
Contract tests45 of 45 passingLocal Foundry suite, including adversarial cases.
Live adversarial tests2 of 2 on the previous deploymentRe-run on the current deployment is pending.
Failure modeFail-closedUnsafe or error conditions do not result in execution.
AuditUnauditedThe pilot starts on testnet.

Pilot

Put your agent under policy.

Vantarix is looking for its first pilots. The pilot wraps your agent's execution flow in policy enforcement, so you can see how your agent behaves under real limits before real funds are involved.

I run the setup with you directly.

Network
Base Sepolia
Duration
Two weeks of direct support
Fee
$2,500, flat
You receive
Configured policy, integration, activity page, kill switch, pilot report
Book a pilot
  • Deployed around your agent. Vantarix is placed in the agent's execution flow.
  • Policies configured. Contracts, functions and limits designed around what your agent actually does.
  • Requests evaluated. Every transaction request your agent proposes gets a decision.
  • Allowed requests execute. Blocked requests stop. Nothing is sent without an ALLOW.
  • Decisions are observable. Each request, reason and result appears on the activity page.
  • Runs on Base Sepolia. The contracts are unaudited, so the pilot starts with test funds.
  • After the pilot. We review the log together, adjust the policy, and decide what comes next.

FAQ

Questions from engineers.

What does Vantarix actually enforce?

Which contracts and functions an agent may call, ETH limits per transaction and over a key's lifetime, per-token amount limits on transfer, approve and transferFrom, and session key expiry and revocation. Decisions are signed by the service and re-verified onchain.

Where does Vantarix sit in the transaction flow?

Between the agent and the Safe. The agent submits a signed request to Vantarix instead of sending a transaction itself. Allowed requests execute through a Safe module.

What happens when a transaction violates policy?

The request receives a BLOCK decision with the rule that decided. Nothing is sent onchain, and the decision is recorded.

What happens if the policy engine fails?

Execution does not proceed. Without a signed decision the module refuses the call, and if the service is unreachable the SDK throws and sends nothing. A policy that fails its hash check is treated as a BLOCK.

Does Vantarix custody funds?

No. Funds stay in a Safe wallet. The agent holds an identity key that signs requests and cannot move funds.

What networks does the pilot support?

Base Sepolia, with Safe wallets.

Is Vantarix audited?

No. The contracts are not audited, which is why the pilot starts on testnet. Mainnet comes after an audit, and then only with caps you choose.

How does the pilot work?

A setup call, a policy designed for your agent, the integration done with you, controlled test transactions, the activity page and your kill switch, then a review of the log and a pilot report. Two weeks, $2,500.

Autonomous agents can act. Their permissions should be enforced.

Book a pilot

Book a pilot

Tell me what your agent does and I will reply with whether Vantarix fits.