og.rsts.dev
← writing

Beyond the Wallet: The State of Enterprise Agent Infrastructure, November 2026

Agent payments got the headlines. Identity, tool gateways, sandboxes and audit got the launches. A dated reference on what shipped this fall, how it maps onto a bank's identity and change controls, why a gateway that holds every key concentrates trust, and why the next hard problem is permissions for the fleet, not the agent.

Beyond the Wallet: The State of Enterprise Agent Infrastructure, November 2026
Contents

Everyone wanted to talk about the agent with a wallet. The launches went somewhere else.

This fall the industry spent its announcements on the layers underneath the money: who the agent is, which keys it holds, what it is allowed to call, where it runs, how many of its siblings can act at once, and what record it leaves behind. Payments turned out to be the top layer of a much thicker stack.

This post is a snapshot of that stack as of November 21, 2026. I wrote it to be read now and reused later, so it is dated on purpose, it names products with their status, and it separates what shipped from what was announced. Expect parts of it to be stale within a quarter. That is the nature of the subject.

Two goods pulling in opposite directions

Start with the people who want this to work. A customer whose dispute gets resolved by an agent in minutes, instead of being bounced across three teams, is getting a real improvement. So is the banker who asks one question and gets an answer assembled from five systems without hunting through screens. Agents that can act, not just answer, are the first version of enterprise AI that changes the shape of a workday. Treating that as hype misses why so many teams are pushing for it.

Now the people who have to keep the institution standing. Identity is the first place it shows. In a reel from segura.security (opens in new tab), a speaker recounts a CIO friend who used to manage about 9,000 human identities and now manages close to 40,000, because roughly 30,000 agents arrived. Every one of those is a principal that can authenticate, hold a credential and call an API. The month’s busiest on-topic thread on r/devops (opens in new tab) asked how to warn colleagues about giving an LLM agent root access to production. The top reply, with the bitterness of experience: “let them find out as a life lesson?” The next one: “Let leadership find out too, they’re the ones pushing for it.”

Both sides are right. The resolution is the same one I keep coming back to: the control plane is what lets you say yes. An institution that can name every agent, scope its keys, gate its riskiest calls and replay its actions can afford to let agents do real work. One that can’t will either block them or regret allowing them.

The stack, as of today

Here is the shape I use. Six layers sit under payments, and a control plane runs through all of them.

Diagram: the agent stack beyond the wallet. Full description below.

Image description

Diagram: the agent stack beyond the wallet. A thin payments layer on top, then six layers: identity and registry, credentials and tool gateway, policy and approval, runtime sandbox, fleet limits, audit and evidence, with a control plane spanning layers one to six

  • 1. Identity and registry. Every agent is a named principal with an owner, a type and a lifecycle. You can list them, find who is accountable for each, and retire them.
  • 2. Credentials and tool gateway. The agent never holds raw secrets. A broker or gateway attaches short-lived credentials to approved calls, either as the agent or on behalf of a specific user.
  • 3. Policy and approval. Rules decide what each agent may call, with which arguments, and when a human must confirm first. Policy lives outside the agent’s code so the agent cannot rewrite it.
  • 4. Runtime sandbox. The agent runs in an isolated environment where file, process and network access are enforced by the platform, not requested politely in a prompt.
  • 5. Fleet limits. Constraints on what agents can do together: how many can spawn, how deep delegation can go, and whether a chain of agents can add up to permissions none of them was given alone.
  • 6. Audit and evidence. A record of who acted, as whom, under which instruction, with what result, kept somewhere the agent cannot edit.

Payments sit on top because spending money is just another privileged tool call. Card networks have been building their own version of layers 1 and 2 for a while: Mastercard Agent Pay (opens in new tab) ties agentic tokens to a registered agent, Visa Intelligent Commerce (opens in new tab) replaces card details with tokenized credentials and spending controls, and Google’s AP2 (opens in new tab) describes payment intent as signed mandates. Even Circle, which has every reason to put money first, argues in its July piece on the operating layer (opens in new tab) that “The operating layer is the institutional unlock for the agentic economy”: identity, delegation, policy, audit and recourse, with payments as the first use rather than the whole story.

I made the case for where payment authorization should live in When the Agent Reaches for the Card. This post is about everything else.

What shipped this fall, layer by layer

Dates and status matter here, because half of this is beta and a third of it is a press release. I mark each one.

Identity and registry

Microsoft Agent 365 (generally available since May 2026, major update at Ignite, November 17 to 20). Agent 365 is not new; Microsoft introduced it at Ignite 2025. What changed this month is its reach. The Ignite 2026 update (opens in new tab) covers management, governance, security and observability, uses Entra Agent ID for identity, Defender for discovery and runtime protection, and Purview for data loss prevention, and lets third-party platforms sync their agents into the registry. On the keynote stage, Microsoft described it as “the control plane that extends your existing governance, identity, security, and management systems to the agents across your enterprise.” The tools registry, local agent discovery and Defender runtime protection on Windows are generally available. Entra Agent ID for third-party platforms is still in preview. That last detail matters more than the keynote line, because cross-vendor identity is the hard part.

Agents as named employees (Foundry, November 19, preview). A Foundry update (opens in new tab) lets an organization add an agent as a named Microsoft 365 member with its own Entra identity, mailbox, calendar, OneDrive and an accountable manager. In Microsoft’s words, “Each one works under its own identity as a named member of your organization.” It requires enrollment in a preview program. The pattern is the important part: the agent gets a lifecycle that HR-style processes already understand.

LangSmith’s agent record (November 16). LangChain rebuilt LangSmith around the agent (opens in new tab): every registered agent gets a named owner, a permanent ID that cannot be edited, and a type. That is a registry by another name, coming from the observability side rather than the identity side.

Agent Name Service (Linux Foundation, November 10, specs in draft). The Agent Name Service (opens in new tab) became a Linux Foundation project, offering DNS-based verifiable identity and discovery for agents. It is the open counterweight to vendor registries, and it is early.

Credentials and the tool gateway

LangSmith Tool Gateway (public beta, November 19). The Tool Gateway (opens in new tab) centralizes credentials, caller identity, access policy and approvals for every tool an agent calls, exposed as a single MCP endpoint. It has two identity modes: acting as the user, with Okta or Entra ID identifying the person, or acting as the agent with its own credentials. Approval policies can require a human to confirm sensitive calls. Traces record the tool, server, user, outcome and duration, and by design “data sent to the tool or by the tool is not stored.” Deny policies and the organization-wide audit log are Enterprise-plan features. It is on the Plus and Enterprise plans while in beta.

HashiCorp Vault Agent Identity (generally available, October 27). IBM’s TechXchange announcement (opens in new tab) “brings together agent discovery, verified identities, access controls and performance evaluation.” The generally available piece is Vault 2.2 with Agent Identity, which gives each agent its own identity and short-lived credentials and integrates with NVIDIA OpenShell. The watsonx Orchestrate discovery and containment features are tech previews. If you already run Vault, this is the shortest path to layer 2 without adopting a new vendor.

AWS Bedrock AgentCore (generally available since October 2025, Policy since March 2026). AgentCore (opens in new tab) was the first hyperscaler to ship most of this stack as one product: runtime, memory, gateway, identity and observability. Policy (opens in new tab) became generally available in March, using Cedar policies attached to the gateway and enforced outside the agent’s code. It is a year ahead of most of this list in maturity, and it only governs what runs on AWS.

Open source. Zalando’s agentic-identity-broker (opens in new tab) handles OAuth on-behalf-of delegation chains, a token vault and tool approval with an audit trail. Coral (opens in new tab) is a self-hosted, Apache-licensed gateway that checks each call against policy, attaches credentials and can require approval. Neither is a product you buy, and both show the pattern is converging fast enough that you can build it yourself.

Cloudflare (August, beta). During its Agents Week, Cloudflare launched an identity-aware AI Gateway (opens in new tab) in open beta, attaching the verified user to each AI request, alongside agent wallets (opens in new tab) built on x402. Much of the wallet functionality is still described in future tense.

Runtime sandbox

NVIDIA OpenShell (introduced March 2026, version 0.1, now a CNCF project). OpenShell (opens in new tab) calls itself “the safe, private runtime for fleets of autonomous AI agents.” Every network connection passes a policy check before it leaves the sandbox, real credentials are injected only into requests bound for approved endpoints, and risky policy changes are flagged for human review. The policy is declared per agent and enforced outside the agent process. Its Hacker News thread (opens in new tab) was the biggest discussion in this area this month. I covered the earlier NemoClaw version of this idea, and why organizational governance is the part sandboxes don’t solve, in the NemoClaw post.

Anthropic self-hosted Managed Agents (private beta, November 12). Anthropic opened a private beta (opens in new tab) in which the agent harness, sandboxes, credentials and session history run inside the customer’s perimeter. The model calls still go out, routed where the customer chooses. For a regulated institution, that split is the interesting design choice: keep the keys and the record inside, rent the reasoning.

Standards underneath

Three standards are doing the quiet work. SPIFFE (opens in new tab), a CNCF project, gives workloads cryptographic identities, and the IETF WIMSE working group (opens in new tab) is extending workload identity across multi-system environments in collaboration with it. The MCP authorization spec (opens in new tab) builds on OAuth 2.1 and requires protected resource metadata, PKCE and resource indicators. And the Identity Assertion JWT Authorization Grant (opens in new tab), informally Cross-App Access, is still a working-group draft that lets an enterprise identity provider broker one app’s access to another. If you are buying anything in layers 1 and 2, ask how it maps to these three.

The market around it

Identity vendors consolidated fast. ServiceNow announced its acquisition of Veza in December 2025, CrowdStrike announced SGNL (opens in new tab) in January, and Cisco reportedly closed its purchase of Astrix in June. The pure-play agent identity vendor is becoming a feature of a larger security platform. Readiness lags: IBM’s release cites Gartner’s finding that “only 13% of organizations believe that they have the right AI agent governance in place,” and a CSA and Oasis survey summarized by Iden (opens in new tab) found 78% have no documented policy for creating or removing AI identities.

Mapping it onto a bank’s controls

This is the part I wanted for myself. A large bank does not need a new control framework for agents. It needs to know which existing control each product satisfies and where the gaps are. Here is the mapping for a typical institution’s control families, with the bank as a composite of the industry, not any one firm.

  • Identity lifecycle (joiner, mover, leaver). Agent 365’s registry and Entra agent identities, the Foundry “named member with an accountable manager” pattern, and LangSmith’s owned, permanent agent IDs all make agents enumerable with an owner. The gap: a mover event. When the accountable manager changes teams or leaves, nothing I have seen reassigns or suspends the agent automatically across vendors.
  • Privileged access management. Vault Agent Identity and gateway-held credentials (LangSmith, Coral, AgentCore Gateway) give you short-lived, brokered secrets, which is what a privileged access program wants. The gap: “acting as the user” inherits the user’s entitlements, so an over-entitled human becomes an over-entitled agent at machine speed. Review user entitlements before you allow delegation.
  • Segregation of duties. Approval policies (LangSmith’s confirm-before-call, Coral’s approvals) let you keep the rule that no one ships a sensitive change alone. The gap: an agent acting as a user who then approves its own request in a different channel. The approver must be a different principal, and the gateway must know it.
  • Change management. Gateway policies, Cedar policies in AgentCore and OpenShell sandbox policies are configuration that changes behavior in production. Treat a policy change like a code change: versioned, reviewed, deployed through a pipeline. OpenShell’s flagging of risky policy changes for review is the right instinct. Most products leave this to you.
  • Data egress and loss prevention. Purview in Agent 365, OpenShell’s network policy and per-endpoint credential injection, and Anthropic’s self-hosted split all address what can leave. The gap: trace designs that deliberately don’t store payloads (LangSmith’s choice, sensible for privacy) mean your DLP evidence must come from somewhere else.
  • Logging and evidence. Every product emits traces. Few emit evidence: a tamper-evident record that ties an action to an identity, an instruction and an approval, kept outside the agent’s reach. That remains a build-it-yourself layer for most institutions.
  • Third-party risk. A gateway or registry vendor now holds keys to your systems. It belongs in your critical vendor tier, with the same scrutiny you give a core processor or an identity provider.

The pattern across the list: products are good at enumerating agents and brokering their keys. They are weaker at the transitions (mover events, policy changes, approvals by distinct principals) and at evidence. Those are exactly the parts an examiner asks about.

The gateway concentrates trust

The sharpest critique of the month came the day the Tool Gateway launched. Sagar Hugar (opens in new tab) put it plainly: “The gateway holds the credentials.” And: “One URL for every tool call is convenient right up until it is a single point of failure.”

Both halves deserve attention. A gateway that holds every credential is the most valuable target in the estate, so compromise of the gateway is compromise of everything behind it. And a gateway on the path of every tool call is an availability dependency, so if it goes down, every agent stops.

None of this argues against gateways. Centralizing keys is still far better than scattering them across agent prompts and environment variables. It argues for treating the gateway as critical infrastructure, which is the same move I argued for with delivery pipelines in Certify the Pipeline, Not the Change. Certify the gateway once, and hold it to that standard:

  • Provenance and change control on its policies. Every policy change goes through review and a pipeline, with the history kept. The gateway’s configuration is production code.
  • No standing human access. Operators reach the credential store through break-glass access that is logged and reviewed, never by default.
  • An availability tier. Decide what happens when it is down: fail closed for writes and money movement, maybe degrade for reads. Write it down before the outage.
  • Blast radius by design. Separate gateways or credential scopes for high-risk systems, so one compromised path does not unlock the core ledger.
  • Self-hostable where it matters. For the highest-risk systems, prefer a gateway you run (Coral, a Vault-backed broker, or a self-hosted harness) over one you rent, or at least one whose credential store you control.

The gateway is where the control plane becomes real. That is also why it has to be the most carefully governed thing you operate.

Fleet permissions: when agents delegate around the sandbox

The newest problem is not one agent with too much access. It is many agents that each have a little, and add up to a lot.

On the OpenShell thread, Hacker News user prennert (opens in new tab) summarized NVIDIA’s conference pitch this way: “the idea is not just to limit what each individual agent can do, but to also to ensure that the collective permissions do not exceed what you want agents to do.” The concern behind it is concrete. An agent that can’t reach a system can ask another agent that can. Each step is allowed. The chain is not something anyone approved. OpenShell’s README, to be clear, describes per-agent policy, not a fleet-wide model. The fleet problem is named, not solved.

There is a cost version of the same problem. An X post from @PatchOnChain (opens in new tab) titled “The Subagent Fork Bomb: How Recursive Agent Fanout Destroys Git Worktrees and Burns $4K” drew a long thread of people with their own versions. Unbounded fanout is a security failure and a budget failure at once.

What fleet controls look like, from the patterns that exist today:

  • Delegation carries the original principal. When agent A asks agent B to act, B’s call should still say “on behalf of A, on behalf of user U,” and policy should evaluate the whole chain, not just the last hop. OAuth on-behalf-of chains, as in Zalando’s broker, are the closest working example.
  • Permissions can only narrow down a chain. A delegated task never gets more than the delegator had. This sounds obvious and is rarely enforced across vendors.
  • Depth and fanout limits. Cap how deep delegation can go and how many agents one task can spawn, the way you cap process forks on a server.
  • Collective budgets. Limits that apply to the fleet or the task, in calls, spend and data volume, not just per agent.
  • Cross-agent audit. The evidence record links the chain, so you can answer “who asked for this” across five hops.

This is the layer I expect to change most by spring.

What is still unsolved

Cross-vendor identity federation. Entra Agent ID for third-party platforms is still in preview, and most institutions run agents from several vendors. I wrote about this gap in May in The Agent Identity Federation Gap, and it has narrowed but not closed.

Traces versus receipts. Observability products record what happened. Evidence needs a signed, tamper-evident record tied to identity, instruction and approval. Very little ships that way by default.

Payments building their own identity. The card networks register and token-bind agents for payments. That is useful, and it is a second agent identity system next to the one your security team runs. Expect a reconciliation problem.

Mover events and orphaned agents. Agents outlive their owners’ roles. Nobody has made “the accountable manager changed” a first-class trigger yet.

Fleet semantics. As above, named but not solved.

Where to start

If I were standing this up at a large regulated institution tomorrow, I would start here:

  • Build an inventory of every agent, with an owner, a type and a creation and retirement process, before anything else.
  • Route all agent tool calls through a gateway or broker; no raw secrets in agent configuration.
  • Use short-lived, per-agent credentials; review user entitlements before allowing “acting as the user.”
  • Put gateway and sandbox policies under change control, deployed through a pipeline.
  • Require approval by a distinct principal for writes to systems of record and anything that moves money.
  • Tier the gateway as critical infrastructure, with break-glass access and a written fail-closed rule.
  • Run agents in sandboxes where network and credential policy are enforced by the platform.
  • Set fanout and delegation-depth limits, and propagate the original principal down every chain.
  • Keep an evidence store outside the agents’ reach that links action, identity, instruction and approval.
  • Map every product you buy to SPIFFE or WIMSE, MCP authorization and Cross-App Access, and to the control families above.

The honest part

This is a snapshot, and some of it will be wrong in a few months. Several of the products above are in beta or preview, and a beta’s architecture can change before it is generally available. Vendor claims about scale and safety are untested in institutions this size. My mapping to control families reflects how these controls typically work across the industry; your control framework and your examiners will have their own vocabulary, and the mapping has to be agreed with them. And the fleet section describes a problem more clearly than it describes a solution, because that is where the field is.

What to watch next

Three things will tell you whether this stack matures or fragments: whether third-party agent identity leaves preview at the big identity providers, whether any gateway ships signed receipts instead of traces, and whether fleet-level policy shows up as a real feature anywhere. Until then, the institutions that move fastest will be the ones that already treat identity, change control and evidence as engineering, not paperwork.

Prefer to watch? The video version is on YouTube (opens in new tab).

If you want the pipeline half of this argument, read Certify the Pipeline, Not the Change, on turning the delivery path itself into the control that lets you say yes to speed.

Which layer is your team stuck on? I’d like to hear where the gaps are. Find me on X at @orestesgarcia (opens in new tab) or on LinkedIn (opens in new tab).