10. Autonomous mode

By default every payment waits for your passkey. You can switch an agent to Autonomous: then a payment the policy allows (an eligible tool, within every USD limit) runs without you. Autonomy is bounded twice: by ZyroPay’s policy engine, and by a Turnkey policy envelope that your own passkey creates and that ZyroPay cannot widen.

How it is set up (Solana and EVM networks)

Setting up Autonomous (steps 1 to 6) and one autonomous payment (7 to 10).

1. You switch an agent to Autonomous in the policy editor.
2. The API generates a P-256 key pair, stores the private key encrypted (AES-256-GCM) and returns only the public key.
3. Your passkey creates a non-root user in your sub-org holding that public key. The API then checks the sub-org: exactly that key, no authenticators, not in the root quorum.
4. Your passkey creates the policy envelope (buildDelegatedPolicyEnvelope, version 1): an EVM rule allowing native transfers on the allowed chains to allowlisted recipients up to a native per-payment cap (derived from your USD limit plus a price margin), a Solana rule allowing only System and ComputeBudget program transfers to allowlisted recipients up to a cap, and a rule that denies any transaction using address lookup tables.
5. The app saves the policy together with that stamped request.
6. The API checks that every allow rule names only the delegated user, forwards the request to Turnkey unchanged and records the policy ids.
7. Later the agent asks to send to an allowlisted recipient.
8. The policy engine checks the USD per-payment, daily and monthly limits on spent plus reserved, and reserves the amount.
9. The API signs with the delegated key. Turnkey signs only inside your envelope, so even a fully compromised API cannot pay a recipient outside it or above its per-payment cap.
10. The signed bytes are checked against the built ones, broadcast and settled on confirmation.

One delegated user serves all your autonomous agents; the per-agent distinction lives in the API. Revoking the last autonomous agent destroys the encrypted key at once, and every other agent falls back to Always Ask. The Turnkey user and its policies stay in your sub-org (only your passkey can delete them), inert, and the next setup deletes them first.

Honest framing: in Autonomous mode you give ZyroPay’s server a revocable signing capability. Turnkey bounds it per payment; ZyroPay bounds it per agent, per window and in USD. In Always Ask, ZyroPay can sign nothing.

What is never autonomous

• Swaps. A router can move any token a transaction touches, and Turnkey cannot constrain what a program does downstream.
• Token transfers are refused by the v1 envelope, which covers native transfers only.
• x402 on EVM. The EIP-3009 authorization is a raw digest a Turnkey policy cannot bound.
• Cardano, entirely. Turnkey signs Cardano only as a raw 32-byte payload and cannot parse the transaction, so no Turnkey policy could bound what a delegated key would sign. The policy engine refuses autonomy for the Cardano family (AUTONOMY_NOT_SUPPORTED), the autonomous executor refuses it, and the Turnkey client refuses to sign Cardano with a delegated key.

An on-chain allowance for Cardano Not built

The way to give an agent bounded autonomy on Cardano is to move the bound on chain: a Plutus script holding a budget that you fund with your passkey, which a delegated key can spend only within rules the script itself enforces, and which you can reclaim at any time. This is not built. No contract, no transaction and no test exists in this repository; the evidence entry is Awaiting live run. An allowance worth building would have to enforce, on chain:

• payments only to recipients you listed, each at most a per-payment amount;
• a cap per time window, counted by the script, not by ZyroPay’s server;
• an expiry, after which only you can spend the remainder;
• withdrawal of the whole remainder by your key alone, at any time.

Until it exists, every Cardano payment in these docs was approved with a passkey.

Proven

Autonomous mode on Solana and EVM networks ran live on the previous staging deployment on 2026-10-20: a live Turnkey org accepted the envelope (Solana devnet, Sepolia, Base Sepolia, caps from live prices) and a 0.01 SOL autonomous payment confirmed on devnet. Its hash is not part of this evidence set. The engine, the envelope builder and the refusals above are tested offline

Tested offline.

Code: packages/shared/src/delegated-policy.ts, packages/shared/src/policy.ts (AUTONOMY_ELIGIBLE_TOOLS, AUTONOMY_ELIGIBLE_FAMILIES), apps/api/src/services/delegated.ts, apps/mobile/src/lib/autonomous.ts.