The passport stops at your perimeter

ServiceNow announced AI Passport on 15 October 2026: a cryptographically signed credential, issued from its control tower, that agents and MCP servers check at runtime to establish what they may do. The prevention claim holds exactly as far as the issuer's own enforcement points reach, and an agent's most consequential calls leave them. What the credential durably buys is different and underrated — a binding between an action and the approval that authorised it, recorded as the action happens rather than reconstructed afterwards.

By Agentic AI Wiki 13 min read

ServiceNow announced AI Passport on 15 October 2026 — a cryptographically signed credential, issued from its control tower, that agents and MCP servers check at runtime to establish what they are permitted to do at each step of a workflow. The prevention claim is real and it is bounded: a credential is a control only where something checks it, and the calls that make an agent dangerous are precisely the ones that leave the issuer's enforcement points. What the passport durably buys is the thing post-incident reviews never have — a binding between an action and the approval that authorised it, written at the moment of the act instead of reconstructed from logs afterwards. That is worth buying. It is not the same purchase.

At a glance

What the coverage establishes, and what it conspicuously does not.

PropertyAs describedConfidence
What it is A cryptographically signed credential naming an agent's authorised scope Consistent across outlets
Who it covers AI agents and MCP servers, at every point in a multi-agent workflow Consistent
Who issues it AI Control Tower, drawing on configuration data, risk policy and workflow approvals Single-outlet detail
On drift Redirect, restrict, or turn the agent off; a kill switch "at machine speed" Consistent, vendor-stated
Availability Described as launched; one outlet says expected in Q4 2026 Sources conflict
Direct passport revocation Not described in any coverage reachable for this piece Unestablished
What the AI Passport coverage establishes Three bands. Established across outlets: a cryptographically signed credential, coverage of both agents and MCP servers, graduated responses to drift, and NVIDIA as launch partner. Single-source or conflicting: issuance from the control tower, and whether the product is launched or expected in the fourth quarter of 2026. Unestablished: revoking an already-issued passport, and any verifier outside the issuer's own estate. Sort the launch claims by how well they are established. Established a signed credential · covers agents and MCP servers redirect, restrict, deactivate · NVIDIA as launch partner Single-source issued from the control tower, built from existing approvals availability: described as launched, or expected in Q4 2026 Unestablished revoking a passport already issued any verifier outside the issuer's own estate
The third band is the one that decides whether this is a boundary control or an internal one.

Everything here is from launch coverage and vendor statements, not from hands-on use; ServiceNow is also reported to have shipped this alongside NVIDIA, as a launch partner on an open-agent-safety effort, and to have built the credential on open specifications so third parties could issue their own.

A credential is a control only where something checks it

Where a signed passport is actually checked One agent holding a signed passport makes three calls. The call into a step of the issuer's own platform is intercepted and can be refused. The call into a third-party MCP server is checked only if that server was onboarded to the control tower. The call to an outside SaaS API or a partner system carries the passport as a header nothing on the far side reads. One credential, three calls, one enforcement point. Agent + signed passport Issuer's workflow a step in the platform Refusal possible the call is intercepted Registered MCP server onboarded to the tower Only if onboarded else no verifier exists Outside API, partner a system you do not run Nobody checks the passport is a header
Same credential, three calls, one enforcement point. The two that matter most are the ones furthest from it.

Signed credentials have an unglamorous property that decides what they can and cannot do: they are inert until something verifies them and refuses on failure. That verifier is the control. The credential is just the thing it reads.

Read the descriptions of AI Passport with that in mind and the architecture is clear enough. The verification happens at runtime, inside the estate the issuer can see — its own workflow steps, and MCP servers that were onboarded into the control tower. Within that envelope the claim to block an out-of-scope action before it happens is ordinary and correct; it is a reference monitor, which is a well-understood and genuinely good thing to have.

Now follow an agent to the three places enterprise agents actually go. Into the issuer's own platform: checked. Into a third-party MCP server somebody registered: checked, if it was registered. Into a SaaS API, a vendor's agent, a partner's system, a browser — a passport on that request is a header nobody reads, because the far side was never a verifier and has no incentive to become one. The enforcement is real and the perimeter is the enterprise's own software estate, which is exactly the region where the enterprise already had authorisation tools.

This is not a criticism of the product so much as a correction of the pitch. "Runtime control over what an agent may do" is true inside the control plane and unachievable outside it by any credential whatsoever, from any vendor. Nothing issued by a caller can bind a resource that declines to check it.

The underrated half: an authority record written while the action happens

Strip out the prevention claim and something better is left standing. The passport is reported to be derived from configuration data, risk policies and workflow approvals — which means that at the instant an agent acts, there exists a signed object naming the scope it was granted and the approval that granted it.

Anyone who has run an incident review on an agent knows why that is the valuable part. The usual reconstruction is archaeology: you have the model's trace, the tool calls, the resulting writes, and a separate ticketing system where somebody approved something three weeks earlier, and joining those two is a manual exercise in inference. The passport collapses that join. It is a decision receipt issued before the decision rather than assembled after it, and the difference is whether "who authorised this?" is a query or a research project.

Two cautions follow, both of which teams reliably get wrong:

  • An authority record is not a safety property. It tells you the action was in scope, which is a statement about your policy, not about the world. A perfectly in-scope action can still be the wrong one, and an agent whose scope was set too wide is now wrong with a signature on it. The point of audit trails is to make consequences attributable, never to make them acceptable.
  • "We can always turn it off" quietly widens grants. The graduated-response story — redirect, restrict, deactivate, kill switch — is the most persuasive part of the launch, and the most dangerous thing to believe before you have tested it. A stop path that runs through the same control plane as the agent is not out of band; see kill switches for why that matters, and note that none of the coverage describes revoking an already-issued passport as distinct from deactivating the agent that holds it.

Caller-side and resource-side policy are duals, and they fail in opposite places

Caller-side and resource-side policy compared Two columns. Policy held at the caller covers many resources from one place, and stops at any resource that declines to verify the credential. Policy held at the resource binds every caller including an unapproved one, and must be built once per resource. Each one covers the other's blind spot. Covers Blind spot Policy at the caller many resources governed from a single place Policy at the resource every caller, including the one you never approved stops at any resource that declines to verify must be built once per system of record
Each one covers the other's blind spot. Only one of them survives leaving your estate.

Put a credential on the agent and you have one place to set policy and a reach limited to willing verifiers. Put a scope on the resource and you have policy that binds every caller — including the agent you never approved, the compromised one, and the one from another company — at the cost of building it once per resource.

The same fortnight supplied the resource-side answer to the identical question, from an unexpected direction. Schwab is reported to have told analysts on 14 October that it blocks outside agents logging in with clients' credentials while keeping balance and research reads open through its own MCP servers and barring money movement. No credential the agent carries is consulted in that design, which is the point: a read-only surface refuses the write regardless of who is asking, how well-attested they are, or whose control tower vouched for them. We took that story apart separately in The front door closed; the MCP server did not.

Enterprises will need both halves, and the asymmetry worth noticing is commercial rather than technical: the caller-side half is a product you can buy this quarter, and the resource-side half is work your platform teams have to do on each system of record. That is a good predictor of which one gets done, and a good predictor of where the first incident will be. The agent will be perfectly attested and the resource will have had no opinion.

Why this is being bolted on at both ends

There is a structural reason the authority layer is appearing as a product rather than as a protocol feature. MCP's current revision, 2026-07-28, deliberately went stateless: the per-connection session identifier is gone from the Streamable HTTP transport, the initialize handshake is gone, and each request carries its own protocol version and capabilities so servers can sit behind ordinary load balancers. That was the right call for scaling, and it also means there is no session for an identity to attach to and no handshake in which to assert one.

So the protocol that connects agents to tools has no place to put "who is asking, on whose authority." Both ends are now filling that in privately and incompatibly: the caller end with issued credentials checked by the issuer's own runtime, the resource end with scopes the resource owner defines on surfaces it operates. Neither is wrong. Neither interoperates. An agent that is fully governed in one company's estate arrives at another company's MCP server as an anonymous HTTP request, exactly as before.

That is the test to watch, and it is not the next issuer announcement. The thing that would turn a passport into a boundary control is a population of verifiers — resource owners who refuse unattested agents — and the open-specification framing in the launch coverage is an invitation to exactly that. Count the first resource owner that requires someone else's passport. Until then, every such credential is an internal access-control list with a signature on it, which is useful, and is not the same as attestation that crosses a boundary.

What to ask before you buy any of these

  • Name the enforcement points. Not "runtime" — the actual list of places a call is intercepted and can be refused. Anything not on that list is unenforced, however well-credentialed.
  • Ask what happens to an in-flight passport you want to cancel. Deactivating an agent and invalidating a credential it already holds are different operations with different latencies. Get the second one in writing, with its propagation time.
  • Test the stop path out of band. If the kill switch is a workflow in the platform the agent runs on, you have a kill switch for the failure modes that leave the platform healthy. Those are not the ones you are worried about.
  • Check whether the scope is derived or asserted. A passport built from existing approvals inherits whatever those approvals got wrong. Reviewing them is now a security task, which is the inventory problem wearing a new hat.
  • Price the grant, not the credential. The question that decides your exposure is still how much an in-scope action can cost you — blast radius is unaffected by how beautifully the action was authorised.

And one framing worth keeping: this is policy-as-code for agents with the issuance half productised. The hard part of policy-as-code was never signing the policy. It was knowing what the policy should say, and having something on the far side that cared.

FAQ

What is ServiceNow AI Passport?

A cryptographically signed credential, announced 15 October 2026 and issued from ServiceNow's control tower, that names what an AI agent or MCP server is permitted to do at each step of a workflow and is checked at runtime rather than audited afterwards.

Does it stop an agent from taking an unauthorised action?

Where the call passes an enforcement point that verifies the passport, yes. Where it does not — an outside SaaS API, a partner's system, a browser — the credential travels as data nobody checks. The enforceable region is the issuer's own estate.

Is this the same as giving an agent an identity in an identity provider?

No, and the distinction is the selling point: an identity establishes which agent is calling, while the passport additionally names the scope, the policy and the approval behind a specific step. Both still depend on a verifier that refuses on failure.

Can a passport be revoked?

The coverage describes redirecting, restricting or deactivating an agent, and a kill switch. It does not describe invalidating an already-issued credential as a separate operation. Treat that as an open question to put to the vendor rather than an assumed capability.

Does MCP not already handle agent authorisation?

Not at this layer. The 2026-07-28 revision removed the session identifier and the initialize handshake in favour of self-contained requests, so there is no session for an identity to live in. OAuth scopes bind the token a server issues; nothing in the protocol carries "on whose authority" between organisations.

What would make this a real boundary control?

Resource owners that refuse unattested agents. The launch coverage says the credential is built on open specifications so third parties can issue their own — but issuers are not the constraint. Watch for the first resource owner that requires someone else's passport.

Further reading

On this wiki:

Sources: