Skip to content

What Agentic Infrastructure Actually Requires

Joan Alavedra, Co-Founder at Openfort•15 min read
An AI agent process calling a separate TEE server that holds its signing key

TL;DR

Agentic infrastructure is the set of systems an autonomous agent needs before it can move value: identity and key custody, permissions and spend policy, transaction execution and gas, and settlement over a payment protocol. Most teams buy the first piece, ship, and then discover they own the other three. The permission layer is the hard part, because bounding what a process with no human watching may spend, and revoking that authority mid-flight, is where agent deployments fail. Settlement is still unsettled: x402, MPP, ACP, and AP2 are all live and solve different layers. This guide defines each subsystem, lists what breaks without it, and gives a vendor-neutral checklist for evaluating providers.

Last updated: November 10, 2026.

Agentic infrastructure is the money layer an autonomous AI agent needs before it can transact. It decides where the agent's signing key lives, what the agent is allowed to spend, how its transactions get paid for and confirmed, and which payment protocol it uses to settle with a counterparty. It sits below the agent framework and the model. If you swap GPT for Claude or LangChain for your own loop, this layer stays the same.

That's four subsystems, and most teams budget for one. They pick a wallet SDK, give the agent a key, ship a demo, and then find out they also own spend policy, gas, and settlement. This guide covers all four, says what breaks when each one is missing, and ends with a checklist you can use to evaluate any provider, including Openfort.

If you already know you need a wallet for an agent and want the product view, see Openfort for AI agents. This page is about the whole stack.

What agentic infrastructure means

Agentic infrastructure is the set of systems that lets a process with no human in the loop hold value, move it within limits someone set in advance, and pay a counterparty that never met it. The definition has three parts, and each one rules something out:

  • No human in the loop. Card checkout and browser wallets assume a person approves each payment. Agentic infrastructure assumes nobody is watching.
  • Within limits set in advance. The constraint is enforced by the infrastructure, not by the prompt. A model that's been told "never spend more than 50 USD" has not been limited.
  • A counterparty that never met it. The agent pays services it has no account with, so it needs a payment protocol both sides speak.

Agentic infrastructure isn't an agent framework, which decides what the agent does next. It isn't an LLM orchestration layer, which routes prompts and tools. And it isn't a wallet SDK on its own, which answers only the first of the four questions below.

A useful dividing line: infrastructure is whatever stays true when you replace the model. Spend limits, key custody, and settlement have to survive a model upgrade, a prompt injection, and a bug in your agent loop.

The four subsystems

Every agent that moves value needs all four of these, whether you build them, buy them, or leave them as a gap. The table is vendor-neutral on purpose.

SubsystemWhat it has to doWhat breaks without it
Identity and key custodyDecide where the agent's key lives and who can reach itThe agent's key ends up in an environment variable the agent process can read
Permissions and spend policyBound amount, counterparty, contract, chain, and duration; revoke mid-flightAn agent with an unbounded key drains a treasury on one bad prompt
Execution and gasSponsor or fund each transaction, handle nonces, retries, and confirmationThe agent halts on an empty gas balance with no human watching
SettlementAgree a payment protocol with the counterpartyThe agent can move value but can't pay anything it didn't write itself

The sections below take each row in turn.

Identity and key custody

The first question is where the agent's signing key lives, and one test decides it. Can a compromised agent process read the raw key? If it can, every other control on this page is advisory.

The common options, from weakest to strongest isolation:

  • Environment variable or config file. The key sits in the agent's own memory. A prompt injection that gets the agent to print its environment, or a dependency with a supply-chain bug, leaks it.
  • Cloud KMS. The key never leaves the key management service, but anyone holding the agent's cloud credentials can ask KMS to sign anything.
  • Trusted execution environment, or TEE. The key is generated and used inside hardware-isolated memory. The agent sends a signing request; it never holds the key.
  • MPC. The key is split into shares held by different parties, and no single share can sign.
  • Delegated session key. The agent holds no key of its own on the user's wallet. Instead, the user authorizes the agent's signer to act within a scope, and the user can withdraw that authority.

Openfort uses two of these. Backend wallets are developer-controlled wallets whose keys Openfort generates and uses inside a TEE hosted on GCP Confidential Space with AMD SEV-SNP memory encryption, and per the backend wallet security docs, "private keys never leave TEE memory in plaintext." Your backend authorizes each signature with its own credentials. For agents that act on a user's funds, the user and server signers pattern lets the user's embedded wallet grant your server's signer a scoped session key with EIP-7715 wallet_grantPermissions, so the user keeps custody.

For a provider-by-provider comparison of where keys live and how fast they sign, see best AI agent wallets for developers.

Permissions and spend policy are the hard part

Creating a key for an agent is a solved problem. Bounding what an autonomous process may do with it is not, and this is where agent deployments actually fail.

An unbounded key is the default. Unless you add a policy, an agent that can sign can sign anything: a transfer of the whole balance, an approval to a malicious contract, a payment to an address a prompt injection supplied. A useful policy bounds five things:

  1. Amount. A cap on the value of each transaction.
  2. Counterparty. An allowlist of recipient addresses.
  3. Contract. An allowlist of contracts, and ideally functions, the agent may call.
  4. Duration. An expiry after which the authority lapses on its own.
  5. Revocation. A way to withdraw all of it now, while the agent is still running.

Revocation mid-flight is the requirement teams discover late. When an agent misbehaves at 3 a.m., you need one call that stops it, not a redeploy.

Two design properties matter more than the feature list. First, the policy has to be enforced outside the agent, by the system that holds the key. Second, it should fail closed, which means it rejects any operation that matches no rule.

What this looks like on Openfort

Openfort's policy engine is fail-closed: once a project has a signing policy, operations that match no rule are rejected. Policies can be scoped to the whole project or to one wallet, and EVM rules can match on ethValue for a value cap in wei, evmAddress for an allowlist or denylist, evmNetwork for allowed chain IDs, and evmData for decoded calldata.

This guardrail, from the agentic wallets workflow, restricts one agent's wallet to approved contracts on one chain:


_24
const txOps = ['signEvmTransaction', 'sendEvmTransaction', 'sponsorEvmTransaction']
_24
_24
const guardrail = await openfort.policies.create({
_24
scope: 'account',
_24
accountId: agentWallet.id,
_24
rules: [
_24
// Allow transactions only to the contracts you approve. Reject everything else.
_24
...txOps.flatMap((operation) => [
_24
{
_24
action: 'accept',
_24
operation,
_24
criteria: [
_24
{ type: 'evmNetwork', operator: 'in', chainIds: [84532] },
_24
{ type: 'evmAddress', operator: 'in', addresses: ['{{CONTRACT_ADDRESS}}'] },
_24
],
_24
},
_24
{ action: 'reject', operation },
_24
]),
_24
// A 7702 send is signed as a hash; this rule is what lets it through.
_24
{ action: 'accept', operation: 'signEvmHash' },
_24
{ action: 'accept', operation: 'signEvmTypedData' },
_24
{ action: 'accept', operation: 'signEvmMessage' },
_24
],
_24
})

One detail the docs call out, and which you should design around: a backend sendTransaction() reaches the policy engine only as the signEvmHash of its user operation, so transaction criteria don't block a send by themselves. The agentic wallets workflow has the agent pre-flight every action with policies.evaluate() and skip the send when it returns not allowed. Treat that pre-flight as a required step in the agent loop, not an optimization.

Revocation is a policy update. Per the policies reference, you can disable a policy without deleting it:


_10
const disabled = await openfort.policies.update('ply_...', {
_10
enabled: false,
_10
})

For delegated session keys, the user ends the session from the client with useRevokePermissions, passing the signer address they granted. A session key's scope is set by contract address, an expiry in seconds, and an optional call limit.

The docs also recommend one wallet per agent, so you can audit, rate-limit, and revoke each agent on its own. For a longer treatment of scoped access, see agent permissions.

Execution and gas

An agent that can sign still has to get the transaction onchain. Three problems show up here, all of them worse when no human is around to notice.

  • Gas. If the agent pays fees in the chain's native token, it needs a native balance, and it stops when that balance hits zero.
  • Ordering and retries. Two concurrent tasks from the same agent can collide on nonces, and a failed transaction needs a retry policy that doesn't double-pay.
  • Confirmation. The agent needs to know when a transaction is final before it acts on the result.

Gas sponsorship removes the first problem. The operator pays fees on the agent's behalf, so the agent holds only the asset it spends. On Openfort, per the gas sponsorship docs, an ERC-4337 paymaster pays gas on EVM chains and a fee-payer relayer called Kora signs as fee payer on Solana. There are two models: the app pays, or the user pays in a token you choose, an ERC-20 on EVM or a stablecoin such as USDC on Solana.

One failure mode is worth knowing in advance. The agentic wallets workflow notes that backend wallets hold no ETH, so a transaction sent without a fee sponsorship is "created but never broadcast and stays pending indefinitely, with no error." Keep the gas sponsorship and the guardrail in separate policies: the same page warns that linking a signing policy to a sponsorship turns it into a sponsorship policy, and it stops acting as a guardrail.

For a working build of this layer, see how to build an agent wallet.

Settlement and payment protocols

The last subsystem is how the agent pays someone else. This is the least settled part of the stack. Four protocols are live, they work at different layers, and they're backed by different groups. A guide that names a winner is guessing.

Status as of November 10, 2026, from each protocol's own site:

  • x402 puts a payment inside an HTTP request: the server answers 402 Payment Required with a price, the client signs a payment and retries. Coinbase contributed it to the x402 Foundation, which the Linux Foundation launched operationally on July 14, 2026.
  • MPP, the Machine Payments Protocol, is co-authored by Tempo and Stripe. It also uses HTTP 402, settles stablecoins on Tempo by default, and can accept Stripe cards and Bitcoin over Lightning on the same endpoint.
  • ACP, the Agentic Commerce Protocol, is an open standard from Stripe and OpenAI for checkout between agents and merchants, where the business stays merchant of record.
  • AP2, the Agent Payments Protocol, started at Google and standardizes signed mandates that prove a user authorized an agent's purchase. Its site says the spec has been donated to the FIDO Alliance.

A short decision framework:

  • Paying for APIs, data, or compute per call: x402 or MPP. Choose by what the services you call already accept.
  • Buying from merchants: ACP for checkout, with AP2 if you need proof of user authorization.
  • Needing cards and stablecoins on one endpoint: MPP.

Whatever you pick, none of these protocols decides how much your agent may spend. That limit lives in the policy layer above. On Openfort, backend wallets pay over x402 using the x402 recipe and over MPP on Tempo using the MPP recipe.

For the full comparison, see agentic payment protocols compared, and for the request flow in detail, how x402 works.

How to evaluate an agentic infrastructure provider

Use this checklist on any provider, including us. Each line is a question you can answer from the provider's docs before a sales call.

Identity and key custody

  • Where is the key generated, and where is it used to sign: TEE, MPC, HSM, or plain server memory?
  • Can the agent process, or your own backend, read the raw key? Can you export it if you leave?
  • Can a user delegate scoped authority to an agent without handing over custody?

Permissions and spend policy

  • Is the policy enforced by the system that holds the key, outside the agent?
  • Does it fail closed when no rule matches?
  • Can it cap value per transaction and allowlist recipients, contracts, functions, and chains?
  • Is every signing path covered by the policy, or do some calls need a separate pre-flight check?
  • Can you revoke or disable an agent's authority with one call while it's running?
  • Can you run one wallet and one policy per agent?

Execution and gas

  • Can you sponsor gas so the agent holds no native token, on every chain you need?
  • Can the agent pay fees in a stablecoin instead?
  • What happens to a transaction that can't be paid for: does it fail loudly or sit pending?
  • Are there webhooks or another way to watch every transaction an agent submits?

Settlement

  • Which of x402, MPP, ACP, and AP2 does it support today, with working examples?
  • Is the wallet tied to one protocol, or does the policy layer sit underneath all of them?

The providers you're likely comparing

These notes come from each vendor's own pages, checked November 10, 2026. None of them lists comparable pricing on the pages cited, so check each vendor's pricing page directly.

  • Openfort: TEE-backed backend wallets, a fail-closed policy engine, EVM and Solana gas sponsorship, EIP-7715 session keys for delegated access, and recipes for x402 and MPP. See the docs and Openfort vs Crossmint and Openfort vs Turnkey.
  • Crossmint describes its agentic finance offering as agent wallets, agent cards that use a person's existing card with limits and approvals, and agent checkout with retailers, plus machine payments over x402 and MPP. It's the option to look at if your agent needs card rails.
  • Fireblocks defines agentic infrastructure as an extension of its institutional platform, covering per-agent wallets, a policy and governance layer, and payment protocol support including x402 and MPP. It targets institutions; see Fireblocks alternatives for how it compares on cost and custody.
  • Turnkey offers agentic wallets with keys and policy evaluation inside its secure enclaves, a default-deny policy engine, and consensus rules that require a human or another agent to co-approve high-value actions.

Frequently asked questions

What is agentic infrastructure?

Agentic infrastructure is the money layer an AI agent needs before it can transact on its own. It has four parts: identity and key custody, permissions and spend policy, execution and gas, and settlement over a payment protocol. It sits under the agent framework and the model, so it stays the same when you swap either.

How is agentic infrastructure different from an agent wallet?

A wallet is one of the four parts: it answers where the key lives and who can sign with it. Agentic infrastructure also covers the policy that bounds what the agent may sign, the execution layer that gets a transaction onchain without a human funding it, and the protocol the agent uses to settle with a service.

What permissions does an autonomous agent actually need?

Only the ones its task requires: allowed contracts or recipients, allowed chains, a cap on each transaction's value, an expiry, and a way to revoke all of it at once. Anything not explicitly allowed should be rejected.

Who pays the gas when an AI agent transacts?

Usually the operator, through gas sponsorship: a paymaster on EVM chains or a fee-payer relayer on Solana. The alternative is letting the agent pay fees in a token it already holds. Either way the agent needs no native gas balance.

Which payment protocol should an agent use to settle: x402, AP2, ACP, or MPP?

It depends on the counterparty, and the field hasn't converged. x402 and MPP fit pay-per-call services, ACP fits merchant checkout, and AP2 proves user authorization. Pick what your counterparties accept and keep spend limits in the wallet layer.

Can an agent transact without holding its own private key?

Yes. The agent can drive a backend wallet whose key stays inside a TEE, or a user can grant the agent's signer a scoped, revocable session key on the user's own wallet. In both cases a compromised agent process can't read a raw key.

Build an agent that can pay

Start with agent wallets on Openfort, then follow the agentic wallets workflow to create a wallet, bound it with a policy, sponsor its gas, and send its first transaction.

Share this article

Related Articles

  1. Agent wallet identity, permissions, and compliance

    Three questions decide whether an agent can be trusted with money: who it acts as, what it may do, and what you can prove afterwards.

  2. What Is Agentic Commerce? How AI Agents Buy and Pay

    Agentic commerce is shopping and paying done by AI agents on a person's behalf. How it works, the protocols behind it (ACP, AP2, x402), and how agents pay.

  3. AI Agent Wallet Compliance: Custody and Control Requirements

    The controls an enterprise AI agent wallet needs: custody, policy, identity, audit, screening. Openfort, Circle, Coinbase, Fireblocks, and Ledger scored.

  4. Agentic Payments: MPP, x402, ACP and AP2 Compared

    What agentic payments are, and how the four protocols behind them compare: MPP (Tempo/Stripe), x402, ACP (OpenAI/Stripe), and AP2 (Google).

  5. The Rise of AI Agents: Reshaping Crypto Apps

    Autonomous agents — from algorithmic trading to launching memecoins — are redefining how users interact with decentralized networks.

  6. Machine Payments: When Software Pays Software

    Machine-to-machine payments go past agentic commerce. What changes in the payment stack when IoT devices and servers transact with no human in the loop.

  7. x402 and Agent-to-Agent Payments: Guide and Comparison

    What x402 is, how the v2 spec works, and how it compares to AP2, MPP, and plain MCP tool-calling, plus which wallet providers have shipped support.

  8. What Is MPC? Wallet Key Management: TEE vs MPC vs Shamir vs HSM

    MPC (multi-party computation) signs with a key that never exists whole. Compare MPC, TEE wallets, Shamir secret sharing, device enclaves, and HSM, vendor by vendor.

Ship your first wallet in minutes

No credit card required • 2,000 operations free