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.
Proposes a transaction. Holds no funds.
Evaluates the request against policy before anything executes.
The request is within policy.The request violates policy.
Executes the call through the Safe module.Not reached. Nothing is sent.
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.
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.
Agent request
The agent submits a signed request: target contract, value and calldata.
Policy evaluation
The request is checked against the live policy: contracts, functions and amounts.
Allow or block
Every request gets an explicit decision and the rule that decided.
ALLOW continues to executionBLOCK stops hereExecution
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.
ImplementedSpend limits
ETH limits per transaction and over a key's lifetime. Per-token limits on transfer, approve and transferFrom amounts.
ImplementedAllow / Block
Every request receives an explicit decision, with the rule that decided.
ImplementedFail-closed
If enforcement cannot safely determine authorization, execution does not proceed. An unreachable service sends nothing.
ImplementedAuditability
Requests, decisions and execution results are recorded and viewable on an activity page. Records are append-only.
ImplementedKill switch
An operator can revoke an agent's session key in one transaction.
ImplementedOnchain decision anchoring
Anchoring decision records onchain through EAS, so records can be verified independently.
PlannedArchitecture
The execution path, layer by layer.
The service decides. The chain enforces. Neither takes the other's word for it.
Autonomous agent
Off-chainSigns 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-chainVerifies 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
Session key / authorization
OnchainThe 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
OnchainA 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
OnchainHolds the funds. Runs the call as a module transaction. Call only, never delegatecall.
HoldsThe funds. The agent has no key to the Safe
Base
OnchainBase 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/:sessionKeyCurrent onchain nonce for the agent's session key.
- POST
/v1/executeSubmit a signed request. Returns the decision and, if allowed, the onchain result.
- POST
/v1/proposalsGet a decision and signature without executing.
- GET
/v1/decisionsRequest 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.
await wallet.sendTransaction({
to, data
});
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 documentationSecurity
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
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
- 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