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.
| Property | As described | Confidence |
|---|---|---|
| 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 |
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
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
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:
- Reference monitor — the thing that actually does the refusing, and why the credential is not it.
- Agent identity & attestation — what an attested identity buys, and where it stops.
- Policy-as-code for agents — the pattern this productises half of.
- MCP revision 2026-07-28 — the stateless turn that left no room for a session identity.
- Kill switches — why a stop path inside the platform is not out of band.
- Blast radius — the exposure a well-authorised action still carries.
Sources:
- ServiceNow Newsroom — ServiceNow advances its operational harness for enterprise AI with AI Passport and expanded governance capabilities, 15 October 2026.
- SiliconANGLE — ServiceNow adds AI agent controls and employee automation tools; the runtime-check framing and the graduated drift responses.
- BigDATAwire — ServiceNow unveils AI Passport to control AI agent permissions; coverage of agents and MCP servers.
- Constellation Research — ServiceNow launches AI Passport to ride along with Nvidia's Open Agent Safety Platform; the launch-partner relationship.
- ITdaily — ServiceNow announces AI Passport and lets employees build their own AI agents; issuance from the control tower and the Q4 2026 availability note.
- Model Context Protocol — Key changes, revision 2026-07-28; removal of the session identifier and the initialize handshake.