<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Speakeasy</title>
    <description>The latest articles on DEV Community by Speakeasy (speakeasy).</description>
    <link>https://dev.to/speakeasy</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Forganization%2Fprofile_image%2F6376%2Fa58b6b7c-7165-41aa-85d0-0ce01867de7b.png</url>
      <title>DEV Community: Speakeasy</title>
      <link>https://dev.to/speakeasy</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/speakeasy"/>
    <language>en</language>
    <item>
      <title>What are task-scoped credentials?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Fri, 20 Nov 2026 17:20:41 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-are-task-scoped-credentials-2gi0</link>
      <guid>https://dev.to/speakeasy/what-are-task-scoped-credentials-2gi0</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Task-scoped credentials
&lt;/h2&gt;

&lt;p&gt;Task-scoped credentials are short-lived, identity-bound secrets issued for one agent session, one person, one agent, one task, and revoked when the task ends. The agent never sees the raw long-lived secret for the upstream system, and if the session dies or the person is deprovisioned, the credential dies with it.&lt;/p&gt;

&lt;p&gt;Task-scoped credentials exist because the common way to connect an AI agent to an upstream system is a long-lived secret, such as an API key pasted into a config file, or a shared service account every agent signs in with. That secret can keep working long after the task, the session, and the employee are gone. A task-scoped credential is a short-lived, just-in-time credential minted for the task in front of it, bound to the person who delegated the task, and expired when the task completes, so the durable secret never enters the agent at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why do long-lived agent secrets show up in security incident reports?
&lt;/h2&gt;

&lt;p&gt;The shared service account is the default because it works on the first try, with one key for every agent and no further ceremony. The properties that make it convenient are the ones that make it a liability:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;It is over-scoped.&lt;/strong&gt; A single credential has to cover everything any agent might ever do.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It is held by every agent at once.&lt;/strong&gt; A leak from any one of them is a leak of the whole grant.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;It leaves no trail.&lt;/strong&gt; Every action arrives under the same name, which turns the incident-response question of who did this into a dead end.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Agents typically make each of those properties worse than they were for ordinary service integrations. An agent often holds its secret in places that weren't designed to keep one, such as a dotfile, an environment variable, or a context window that can be coaxed into repeating what it has read. And a key in an agent config is usually tied to nothing in the directory, so when the engineer who set it up leaves, the key can keep working.&lt;/p&gt;

&lt;p&gt;What kind of non-human identity an agent should hold instead is the subject of &lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;what is agent identity&lt;/a&gt; and &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;what is non-human identity&lt;/a&gt;. The credential pattern on this page is how that identity reaches the upstream system without a durable secret riding along.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does identity-bound mean for a task-scoped credential?
&lt;/h2&gt;

&lt;p&gt;An identity-bound credential carries who is acting, not just what is allowed. It supports delegated-user authority for attended or unattended individual agents in the &lt;a href="https://www.speakeasy.com/resources/agent-types" rel="noopener noreferrer"&gt;four-type working-arrangement model&lt;/a&gt;. The session behind it names the person from the directory as the subject and the agent workload as the actor, the pairing described in &lt;a href="https://www.speakeasy.com/resources/agent-composite-identity" rel="noopener noreferrer"&gt;what is agent composite identity&lt;/a&gt;. When the agent requests a tool, the full tuple of tenant, subject, actor, and tool resolves to exactly one upstream credential, or an error. The resolution fails closed, never into a fallback, so a request that matches no grant gets a refusal instead of a shared key.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials#what-does-identity-bound-mean-for-a-task-scoped-credential" rel="noopener noreferrer"&gt;View the credential resolution diagram on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Binding the credential to a person is also what makes directory events reach agent access. Deprovision the person in the identity provider and the credentials bound to them stop being issued, which is the practical meaning of &lt;a href="https://www.speakeasy.com/resources/extend-iam-to-agents" rel="noopener noreferrer"&gt;extending IAM to agents&lt;/a&gt;. The controls the organization already runs for people, including joiner and leaver events, govern the agents acting on their behalf with no parallel system to keep in sync.&lt;/p&gt;

&lt;h2&gt;
  
  
  Are task-scoped credentials the same as agent-scoped credentials?
&lt;/h2&gt;

&lt;p&gt;No, and the difference is which boundary the credential dies at. A credential scoped to the agent alone is a standing secret that belongs to the agent workload. Every person who triggers the agent rides on the same credential, it lives as long as the agent does, and offboarding any one person never touches it. That is a service account by another name, with the over-scoping, the shared trail, and the offboarding gap described above.&lt;/p&gt;

&lt;p&gt;A task-scoped credential narrows two further dimensions. It is bound to the person who delegated the run as well as the agent, and it lives for the task rather than for the agent's lifetime. The agent still has a durable identity, its name, owner, and grants in the control plane, but no durable secret comes with it. That split is what keeps directory events meaningful. Deprovisioning a person stops issuance based on their authority, and retiring an agent retires its identity without leaving a key to find and rotate.&lt;/p&gt;

&lt;h2&gt;
  
  
  How long do task-scoped credentials last before they expire?
&lt;/h2&gt;

&lt;p&gt;Every credential expires when the task completes, the credential itself is never stored, and nothing has to remember to clean it up, so its whole life is measured in minutes. The &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity product page&lt;/a&gt; shows this concretely. A live session in the gateway console carries a credential with a TTL of 23 minutes, counting down alongside the identity and policy checks for the same call.&lt;/p&gt;

&lt;p&gt;Expiry handles the normal case, and revocation handles the urgent one, taking one call and applying immediately. Between the two, the failure modes of the long-lived key disappear. A credential captured mid-session is worthless minutes later, a session that dies takes its credential with it, and a person who is deprovisioned stops being a valid subject for issuance, so their agents lose access on the same directory event that disables their account.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do task-scoped credentials compare to an API key in the agent config?
&lt;/h2&gt;

&lt;p&gt;The API key in the config and the task-scoped credential answer the same integration need, so the difference is easiest to see property by property.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Property&lt;/th&gt;
&lt;th&gt;API key in the agent config&lt;/th&gt;
&lt;th&gt;Task-scoped credential&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Lifetime&lt;/td&gt;
&lt;td&gt;Until someone remembers to rotate it&lt;/td&gt;
&lt;td&gt;The task, measured in minutes&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Who holds the secret&lt;/td&gt;
&lt;td&gt;The agent, its config file, and anything that can read either&lt;/td&gt;
&lt;td&gt;The agent holds only the session credential, and the raw secret never enters it&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Scope&lt;/td&gt;
&lt;td&gt;Everything the key can reach&lt;/td&gt;
&lt;td&gt;The person, the agent, and the task&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;When the person leaves&lt;/td&gt;
&lt;td&gt;The key can keep working&lt;/td&gt;
&lt;td&gt;Issuance stops with the deprovisioned identity&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;The trail&lt;/td&gt;
&lt;td&gt;No action tied to a person&lt;/td&gt;
&lt;td&gt;Every action attributed to the person and agent&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The mechanism behind the right-hand column is just-in-time issuance, a short-lived credential minted at the moment of use, from a system that can bind it to the session requesting it. Where that system sits matters. Agents reach tools through an &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;, which puts a single point on the path of every call, and that point is where a scoped credential can be issued per session instead of a standing secret being distributed to every agent config in the organization.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does the Speakeasy AI Control Plane issue just-in-time task-scoped credentials?
&lt;/h2&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt; ships the pattern as part of &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt;, and the issuance is the third step of a fixed sequence rather than a feature to wire up separately:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Identity resolves first.&lt;/strong&gt; The person signs in through the identity provider the organization already runs, and the session binds them as the subject with the agent workload as the actor.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Policy evaluates before anything is minted.&lt;/strong&gt; Every tool call is checked against rules scoped to the person, the system, and the action, and a matching deny always wins.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The credential is minted for the task.&lt;/strong&gt; The platform issues a short-lived credential bound to the person and the task. Agents never see raw secrets. Credentials are identity-bound and expire with the task, with no shared service accounts and no long-lived tokens.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every decision is recorded.&lt;/strong&gt; Allow and deny both land in the audit stream under the directory identity that drove the call.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The model behind it is that identity lives in the control plane and credentials never do. The platform holds the agent's name, its owner, its grants, and a rule saying that an assertion from a trusted issuer is that agent. It holds no secret for the agent and cannot reissue one, so there is no agent key for an attacker to steal or replay, and the tuple resolution described above fails closed rather than falling back to one. To see what your agents would hold under this model, and what they would stop holding, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What are task-scoped credentials?
&lt;/h3&gt;

&lt;p&gt;Task-scoped credentials are short-lived, identity-bound secrets issued for one agent session, meaning one person, one agent, one task, and revoked when the task ends. The agent never sees the raw long-lived secret for the upstream system. If the session dies or the person behind it is deprovisioned, the credential dies with it, so nothing durable is left behind for an attacker or a departed employee to reuse.&lt;/p&gt;

&lt;h3&gt;
  
  
  How long does a task-scoped credential live?
&lt;/h3&gt;

&lt;p&gt;As long as the task, measured in minutes rather than months. The Speakeasy agent identity product page shows a live session where the issued credential carries a TTL of 23 minutes. Every credential expires when the task completes, the credential itself is never stored, and revocation takes one call and is effective immediately.&lt;/p&gt;

&lt;h3&gt;
  
  
  What does identity-bound mean for a credential?
&lt;/h3&gt;

&lt;p&gt;The credential is tied to a session that names the person as the subject and the agent as the actor, so it carries who is acting, not just what is allowed. When the agent requests a tool, the full tuple of tenant, subject, actor, and tool resolves to exactly one upstream credential, or an error. The resolution fails closed, never into a fallback, so there is no shared key for a misrouted request to land on.&lt;/p&gt;

&lt;h3&gt;
  
  
  Do agents ever see the raw secret for the upstream system?
&lt;/h3&gt;

&lt;p&gt;No. The agent works with the short-lived credential minted for its session, and the long-lived secret for the upstream system stays out of the agent, its config, and its context window entirely. That removes the failure mode where a key pasted into an agent config leaks through a log, a prompt, or a compromised dependency.&lt;/p&gt;

&lt;h3&gt;
  
  
  How are task-scoped credentials different from a shared service account?
&lt;/h3&gt;

&lt;p&gt;A shared service account is one key used by every agent, scoped wide enough to cover anything any of them might do, and it leaves no trail because every action arrives under the same name. A task-scoped credential is minted per session, bound to the person and agent that requested it, scoped to the task, and expired when the work is done, with every action attributed to a named identity.&lt;/p&gt;

&lt;h3&gt;
  
  
  Are task-scoped credentials the same as agent-scoped credentials?
&lt;/h3&gt;

&lt;p&gt;No. A credential scoped to the agent alone is a standing secret that belongs to the agent workload. Every person who triggers the agent rides on the same credential, it lives as long as the agent does, and offboarding any one person never touches it, which makes it a service account by another name. A task-scoped credential is bound to the person who delegated the run as well as the agent, and it lives for the task rather than for the agent's lifetime, so the agent keeps a durable identity while no durable secret exists for it.&lt;/p&gt;

&lt;h3&gt;
  
  
  What happens to an agent's access when the person behind it leaves?
&lt;/h3&gt;

&lt;p&gt;Because each credential is bound to the person who delegated the task, deprovisioning that person in the identity provider stops issuance for their agents rather than leaving a key that can keep working after they are gone. This is the offboarding gap that long-lived agent secrets create and task-scoped credentials close.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>How do you extend IAM to agents?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Fri, 20 Nov 2026 17:05:27 +0000</pubDate>
      <link>https://dev.to/speakeasy/how-do-you-extend-iam-to-agents-471h</link>
      <guid>https://dev.to/speakeasy/how-do-you-extend-iam-to-agents-471h</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/extend-iam-to-agents" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Extending IAM to agents
&lt;/h2&gt;

&lt;p&gt;Extending IAM to agents means the same identity provider, groups, and grants that already govern people also govern AI agents, at the tool call, without a second access model. IAM is extended to an agent when its session authenticates as a directory principal, either the driving person or a dedicated identity with a named owner, and every tool call is allowed or denied against that principal's existing roles.&lt;/p&gt;

&lt;p&gt;Most organizations already run a serious IAM program. Employees typically sign in through Okta or Entra, groups map to roles, roles map to grants, and offboarding is a single directory event. None of that reaches agents by default, because agents act after the login. An agent connected to a &lt;a href="https://modelcontextprotocol.io" rel="noopener noreferrer"&gt;Model Context Protocol (MCP)&lt;/a&gt; server calls tools directly, and the server calls the downstream system with its own separate credential, not one tied to the identity of whoever is driving.&lt;/p&gt;

&lt;p&gt;The default workaround shows what unextended IAM looks like, with one shared service account for every agent and a server-level allowlist that is the same for everyone. Extending IAM to agents replaces that with the access model the organization already trusts.&lt;/p&gt;

&lt;p&gt;How cleanly the extension maps depends on the kind of agent. One that an employee drives directly in a client like Claude Desktop inherits the employee's grants in an obvious way, while a custom agent built by one person and triggered by another raises the question of whose permissions apply at all. The broader identity problem behind both cases is mapped in &lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why do existing IAM controls miss agent tool calls?
&lt;/h2&gt;

&lt;p&gt;IAM as deployed governs the login. A person authenticates through SSO, the identity provider asserts who they are, and the application decides what they can see. That gate sits at the session boundary of applications built for people.&lt;/p&gt;

&lt;p&gt;Agent traffic typically bypasses that gate. An agent calls tools over MCP, and the MCP server authenticates to the downstream system with a credential of its own, usually a service account or a long-lived API key provisioned when the server was set up. The person's roles are generally not consulted, the call is attributed to the service account rather than to anyone in particular, and disabling the person in the IdP typically changes nothing about what the agent path can reach.&lt;/p&gt;

&lt;p&gt;This is the same gap that makes &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;non-human identity&lt;/a&gt; a discipline of its own, made up of credentials that act with real reach but belong to no one the directory knows about.&lt;/p&gt;

&lt;p&gt;It also compounds, since each new MCP server adds another standing credential outside the directory, which is why an &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; that records what each agent runs as is the companion control to extending IAM at all.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does it mean for an agent to inherit a person's grants?
&lt;/h2&gt;

&lt;p&gt;Inheritance means the agent session authenticates as a directory principal and carries that principal's existing roles into every tool call. For delegated-user authority, the principal is the person. The session starts with their SSO login, and the agent can call &lt;code&gt;create_refund&lt;/code&gt; only if their roles already allow it. This can support an attended or unattended individual agent. For service or workload authority, the principal is a dedicated directory identity with a named human owner. The &lt;a href="https://www.speakeasy.com/resources/agent-types" rel="noopener noreferrer"&gt;four agent working arrangements&lt;/a&gt; classify accountability and engagement, not which authority an action uses.&lt;/p&gt;

&lt;p&gt;The consequence is that existing permissions can apply to agents without new access-control machinery. Teams generally do not need to write an agent-specific policy language or rebuild the role model, since the grants already reviewed, audited, and scoped for people are the grants available to the agent. Inheritance sets the ceiling rather than copying the whole grant, and most organizations restrict the agent to a subset of the driver's roles, so a person whose role allows a destructive call can still drive an agent that is denied it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/extend-iam-to-agents#what-does-it-mean-for-an-agent-to-inherit-a-persons-grants" rel="noopener noreferrer"&gt;View the diagram showing how a person's grants narrow for an agent tool call on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Two supporting pieces make inheritance precise rather than approximate:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Composite identity.&lt;/strong&gt; A session records more than the person. It binds the agent workload, the client it runs in, and the task at hand together as one principal. What that tuple contains and why each element matters is covered in &lt;a href="https://www.speakeasy.com/resources/agent-composite-identity" rel="noopener noreferrer"&gt;agent composite identity&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Task-scoped credentials.&lt;/strong&gt; Instead of the person's password or a long-lived key, the agent authenticates with a short-lived credential minted for the task and bound to the identity, which expires when the task completes. The mechanics are covered in &lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials" rel="noopener noreferrer"&gt;task-scoped credentials&lt;/a&gt;.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;How this identity model governs what agents actually do in production is walked through end to end in &lt;a href="https://www.speakeasy.com/blog/governing-agent-actions-with-enterprise-identity" rel="noopener noreferrer"&gt;governing agent actions with enterprise identity&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Whose permissions does a custom agent run with?
&lt;/h2&gt;

&lt;p&gt;Inheritance is clean when the person driving the agent is the person whose grants apply. An employee working an agent directly in Claude Desktop or an IDE is that case. The session starts with their login, every action is attributable to them, and the agent carries their roles, usually narrowed rather than widened.&lt;/p&gt;

&lt;p&gt;A custom agent breaks that symmetry, since the person who builds a workflow and the person who triggers it are often different people. Three identities could plausibly govern the run, and each maps to IAM differently:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The builder's.&lt;/strong&gt; The agent runs as the engineer who wrote it, so everyone who triggers it borrows that engineer's reach. This is the confused deputy problem, where authorization reflects who built the tool rather than who is using it, and the audit trail attributes every run to one person who performed none of them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The triggering user's.&lt;/strong&gt; Attribution improves, but the fit is wrong in both directions. The workflow may need a call the user's role does not include, which blocks legitimate runs, and the user's role includes far more than the workflow needs, which the agent inherits for no reason.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The workflow's own.&lt;/strong&gt; The agent gets grants scoped to what the workflow does. But that creates a principal that is neither a person nor a traditional service account, and the directory needs somewhere to put it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Sometimes the directory can absorb this. The workflow is registered as a dedicated principal with a named owner, the service or workload authority pattern, and its grants are reviewed like any other role. Other times the workflow needs a concept the identity system does not have, and that concept is &lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials" rel="noopener noreferrer"&gt;task-scoped credentials&lt;/a&gt;, a short-lived credential minted per run, naming the triggering person as subject and the agent as actor, and scoped to what this workflow needs for this task. The credential asserts which agent is acting and for whom, without granting either party's full standing permissions, and it expires when the run completes.&lt;/p&gt;

&lt;h2&gt;
  
  
  How is tool-call RBAC different from an MCP server allowlist?
&lt;/h2&gt;

&lt;p&gt;A server allowlist and tool-call RBAC both answer "is this call allowed?", but they answer it at different places with different information.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Property&lt;/th&gt;
&lt;th&gt;Server allowlist&lt;/th&gt;
&lt;th&gt;Tool-call RBAC&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;When the decision is made&lt;/td&gt;
&lt;td&gt;Once, when the server is configured&lt;/td&gt;
&lt;td&gt;On every tool call&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Who it varies by&lt;/td&gt;
&lt;td&gt;Nobody; the same for every caller&lt;/td&gt;
&lt;td&gt;The directory principal behind the session&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What it knows&lt;/td&gt;
&lt;td&gt;The server and its tool list&lt;/td&gt;
&lt;td&gt;The person, the system, and the action&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What revocation takes&lt;/td&gt;
&lt;td&gt;Redeploying or reconfiguring the server&lt;/td&gt;
&lt;td&gt;A directory change, effective on the next call&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A server allowlist is a property of infrastructure. If the GitHub MCP server exposes twelve tools and the allowlist admits eight, every engineer, contractor, and intern who connects gets the same eight. The decision was made before any of them showed up, and a flat allowlist has no way to differentiate one caller from another without a separate server or an equivalent extra layer in front of it.&lt;/p&gt;

&lt;p&gt;Tool-call RBAC scopes policy to the person, the system, and the action, rather than a server-level list that treats every caller the same. A support engineer's session can call &lt;code&gt;create_refund&lt;/code&gt; because their role allows it, while a contractor connected to the identical server is read-only. Enforcing that requires a decision point on the path of every call, which is the job of an &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;. It terminates the agent session, resolves the principal, and evaluates each tool call against that principal's grants before anything reaches the downstream system.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happens to agent access when you deprovision a user?
&lt;/h2&gt;

&lt;p&gt;The answer shows whether IAM actually extends to agents or just looks like it does on paper. When IAM is extended to agents, agent access is derived from the directory rather than copied out of it. Disabling the account in the IdP means sessions can no longer authenticate as that person and their grants no longer resolve, so agent access ends at the same point their other access ends. Directory Sync keeps users, groups, and attributes current in between, so a role change can narrow an agent's reach without anyone editing agent configuration.&lt;/p&gt;

&lt;p&gt;When IAM is not extended, offboarding can miss the agent path. A shared service account exists independently of any one employee, so one person leaving does not affect it. An API key embedded in an MCP server config was never tied to that person's identity in the first place. And the leaver's security review has no register that would surface either credential.&lt;/p&gt;

&lt;p&gt;Agents using service or workload authority need one more control here. Because their principal is a dedicated identity rather than the leaver's own account, the named owner field lets the &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; flag agents whose owner has left and needs replacing.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does the Speakeasy AI Control Plane extend the directory to agents?
&lt;/h2&gt;

&lt;p&gt;Everything above is an architecture, and the &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt; ships it as a product. The platform puts a gateway on the path between agents and tools and wires its decisions to the directory the organization already runs:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Sessions authenticate through the existing IdP.&lt;/strong&gt; Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or most SAML or OIDC providers. Directory Sync keeps users, groups, and attributes current.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The gateway evaluates each tool call.&lt;/strong&gt; Every call is allowed or denied against the principal's existing roles, with policy scoped to the person, the system, and the action rather than a server-level allowlist that is the same for everyone.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Existing permissions apply to agents with no new machinery.&lt;/strong&gt; The role model stays where it is, and agents are one more thing it governs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Deprovisioning in the IdP revokes agent access.&lt;/strong&gt; The directory event that disables the person's login is the event that ends their agents' reach.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The details of the identity model, the credential lifecycle, and the audit trail behind each decision are on the &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity product page&lt;/a&gt;. To see your own directory governing agent tool calls, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What does it mean to extend IAM to agents?
&lt;/h3&gt;

&lt;p&gt;Extending IAM to agents means the same identity provider, groups, and grants that already govern people also govern AI agents, at the tool call, without a second access model. IAM is extended to an agent when its session authenticates as a directory principal, either the driving person or a dedicated identity with a named owner, and every tool call is allowed or denied against that principal's existing roles.&lt;/p&gt;

&lt;h3&gt;
  
  
  Do agents need a separate access model from people?
&lt;/h3&gt;

&lt;p&gt;No. When IAM is extended to agents, every existing permission applies to them with no new machinery, and the groups, roles, and grants already in the directory decide what each agent can call. A separate access model, usually a shared service account behind a static allowlist, creates a parallel permission system that drifts from the directory and that offboarding typically does not touch.&lt;/p&gt;

&lt;h3&gt;
  
  
  What identity does an AI agent authenticate as?
&lt;/h3&gt;

&lt;p&gt;An agent authenticates as a directory principal. An agent using delegated-user authority authenticates as that person, whether the run is attended or unattended. An agent using service or workload authority authenticates as a dedicated identity with a named human owner. Hybrid runs record the principal used for each action. None should use an undifferentiated shared service account.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does an agent inherit all of a person's permissions?
&lt;/h3&gt;

&lt;p&gt;Inheritance sets the ceiling rather than copying the grant outright. An agent a person drives can never exceed their grants, and most organizations narrow it further, denying the agent destructive calls that the person's own role allows. The directory still makes the access decisions, and the agent operates under a restricted subset of the driver's roles.&lt;/p&gt;

&lt;h3&gt;
  
  
  Whose permissions does a custom agent built by someone else run with?
&lt;/h3&gt;

&lt;p&gt;Not the builder's permissions. Running the agent as the person who built it lets everyone who triggers it borrow the builder's reach, which is the confused deputy problem. Running it as the triggering user fits badly in both directions, blocking calls the workflow needs and inheriting grants it never uses. The workable answers are a dedicated directory principal for the workflow with a named owner, or a task-scoped credential minted per run that names the triggering person as subject, the agent as actor, and only what the workflow needs as scope.&lt;/p&gt;

&lt;h3&gt;
  
  
  Which identity providers can govern agent access?
&lt;/h3&gt;

&lt;p&gt;Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, and most SAML or OIDC providers. With Directory Sync connected, users, groups, and attributes stay current, so agent authorization follows the directory as it changes, and deprovisioning a user in the IdP revokes their agent access with it.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is tool-call authorization different from an MCP server allowlist?
&lt;/h3&gt;

&lt;p&gt;A server allowlist is one decision, made when the server is deployed, and it is the same for every caller. Tool-call authorization is a decision per call, where a gateway evaluates each tool call against the person behind the session, the system being called, and the action being taken. Two people connected to the same server get different answers because their directory roles differ.&lt;/p&gt;

&lt;h3&gt;
  
  
  What happens to an agent's access when a user is deprovisioned?
&lt;/h3&gt;

&lt;p&gt;When IAM is extended to agents, agent access is derived from the directory, so disabling the account in the IdP revokes it. Sessions authenticating as that person stop authenticating, and their grants stop resolving. When IAM is not extended, the agent path can run on a shared credential the directory has no record of, and offboarding typically leaves it running.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is agent access management?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Thu, 19 Nov 2026 12:12:47 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-agent-access-management-120h</link>
      <guid>https://dev.to/speakeasy/what-is-agent-access-management-120h</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/agent-access-management" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Agent access management
&lt;/h2&gt;

&lt;p&gt;Agent access management is the set of controls that decide and enforce what each AI agent may call: which tools, on which systems, under which directory principal. It replaces a shared bot credential and a flat MCP server allowlist with an authorization decision on every tool call, evaluated against the grants of the person driving the agent or of a dedicated agent identity with a named owner.&lt;/p&gt;

&lt;p&gt;The category exists because agents act after the login. An employee's access is decided when they sign in, by an application that checks their directory roles. An agent connected to a &lt;a href="https://modelcontextprotocol.io" rel="noopener noreferrer"&gt;Model Context Protocol (MCP)&lt;/a&gt; server calls tools directly, and the server usually reaches the downstream system with a credential of its own, so nothing on that path consults the person's grants. In practice that credential is a token in a config file. The GitGuardian 2026 State of Secrets Sprawl report found &lt;a href="https://blog.gitguardian.com/the-state-of-secrets-sprawl-2026/" rel="noopener noreferrer"&gt;24,008 unique secrets in MCP configuration files on public GitHub&lt;/a&gt;, 2,117 of them still valid.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;Agent identity&lt;/a&gt; covers binding each agent session to a directory principal in the first place. This page covers the category built on that binding: how the decision is made, where it is enforced, how agent grants are sourced from the identity provider, groups, and roles the organization already runs, and which method attaches grants to a session. Where access management sits among the other agent controls, and what order to deploy them in, is the subject of &lt;a href="https://www.speakeasy.com/resources/agent-governance" rel="noopener noreferrer"&gt;agent governance&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Agent access management has five parts:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;A principal behind every session.&lt;/strong&gt; Each agent session resolves to a directory identity, either the person driving it or a dedicated agent identity with a named human owner. Without one there is nothing to authorize against. This is the subject of &lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Grants that stay in the directory.&lt;/strong&gt; The identity provider remains the system of record for who may do what, and agent access is derived from it on each call rather than copied into agent configuration. This is what extending IAM to agents describes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;An enforcement point on the tool-call path.&lt;/strong&gt; A gateway between the agent and every tool it reaches resolves the principal and allows or denies each call. The login gate never sees this traffic, so something else has to. That is the job of an &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A method for attaching grants to a session.&lt;/strong&gt; Inherited from the driving person, persistent on a dedicated identity, or task-scoped and minted per run. Each fits a different kind of agent.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A record of every decision under a name.&lt;/strong&gt; The audit answers who called what, through which agent, with the grant that allowed it. That takes the &lt;a href="https://www.speakeasy.com/resources/agent-composite-identity" rel="noopener noreferrer"&gt;composite identity&lt;/a&gt; of person, agent, client, and task.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  How do organizations manage agent access today?
&lt;/h2&gt;

&lt;p&gt;Most organizations have no written policy for agent access, and the arrangements they run grew out of how agents arrived. A developer connects an MCP server to Claude or Cursor, pastes a personal access token into the client config, and gets to work. Usage spreads through the team, the team consolidates onto one shared credential, and someone in security adds a list of approved servers. Three arrangements account for most deployments:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Personal tokens in agent configs.&lt;/strong&gt; The token sits in &lt;code&gt;claude_desktop_config.json&lt;/code&gt; or &lt;code&gt;~/.cursor/mcp.json&lt;/code&gt; with whatever scope the person accepted when they created it. The GitGuardian report notes that popular MCP setup guides recommend putting keys directly in configuration files, so the pattern spreads with the documentation.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One shared service account per integration.&lt;/strong&gt; Once a team needs the same server, individual tokens give way to one bot credential granted the union of everyone's needs. Every agent on the team presents it, and every downstream system records it as the actor.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A server allowlist in the client or a proxy.&lt;/strong&gt; The MCP client, or a proxy in front of it, decides which servers may be connected. The decision is made once, applies to everyone, and knows the server and its tool list. It knows nothing about who is calling or what the call does.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For a solo developer, the first arrangement is the right amount of process. The problems start when the same arrangement carries a team, because three controls that work for people stop working at that point.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Attribution.&lt;/strong&gt; Every call arrives as the service account, so when security asks which agent did something, and who was driving it, the audit answers with one name that covers everyone. Adding agents does not add distinguishable actors.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Least privilege.&lt;/strong&gt; The credential carries the union of every team member's needs. The Supabase MCP demonstration in July 2025 worked because the agent held the &lt;code&gt;service_role&lt;/code&gt; key, which &lt;a href="https://simonwillison.net/2025/Jul/6/supabase-mcp-lethal-trifecta/" rel="noopener noreferrer"&gt;bypasses row-level security&lt;/a&gt;, so a prompt injection planted in a support ticket could read integration tokens out of an unrelated table. A read-only, project-scoped configuration was available and documented. The shared credential made it optional.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Lifecycle.&lt;/strong&gt; Nothing ends the credential when the people behind it leave, and nothing short of rotation ends it when it leaks. The Salesloft Drift OAuth tokens stolen in August 2025 were used from August 8 to at least August 18 to &lt;a href="https://cloud.google.com/blog/topics/threat-intelligence/data-theft-salesforce-instances-via-salesloft-drift" rel="noopener noreferrer"&gt;export data from Salesforce instances&lt;/a&gt; at &lt;a href="https://thehackernews.com/2025/09/salesloft-takes-drift-offline-after.html" rel="noopener noreferrer"&gt;more than 700 organizations&lt;/a&gt; before they were revoked. A Silverfort analysis of authentications across hundreds of organizations found that &lt;a href="https://www.silverfort.com/blog/insecurity-in-the-shadows-the-data-that-proves-why-non-human-identities-are-a-cybersecurity-priority/" rel="noopener noreferrer"&gt;40% of cloud non-human identities have no owner&lt;/a&gt;, which is the condition that lets a credential outlive its purpose.&lt;/p&gt;

&lt;p&gt;Replacing the shared account with a per-session principal is the subject of &lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt;. The wider catalog of unowned-credential failures is in &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;non-human identity&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why isn't employee access control enough for agents?
&lt;/h2&gt;

&lt;p&gt;The reasonable objection to all of this is that the organization already has an access model. Groups map to roles, roles map to grants, and quarterly reviews keep them honest, so agents should use it. That objection is half right. The grants should be the same ones, and a second permission model for agents recreates the shared-account problem in a new place. What cannot be the same is the point of enforcement.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;Employee access&lt;/th&gt;
&lt;th&gt;Agent access&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;When the decision is made&lt;/td&gt;
&lt;td&gt;Once, at login&lt;/td&gt;
&lt;td&gt;On every tool call&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What it can assume about intent&lt;/td&gt;
&lt;td&gt;The person means what they click&lt;/td&gt;
&lt;td&gt;Nothing; the agent may be following instructions planted in content it read&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;How fast the population changes&lt;/td&gt;
&lt;td&gt;On HR events&lt;/td&gt;
&lt;td&gt;Sessions created and destroyed many times a day, with no HR event&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Who the actor is&lt;/td&gt;
&lt;td&gt;The person who logged in&lt;/td&gt;
&lt;td&gt;The person, the agent workload, the client, and the task, together&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Timing.&lt;/strong&gt; A person clicking through an application can only do what the application offers, so a decision at login holds for the session. An agent's session says nothing about what it will do next. The same session can read a wiki page and then reach for a destructive operation, and because the MCP server usually authenticates downstream with its own credential, login-time controls never see the traffic at all. The decision has to be made per call: this tool, on this system, under this principal.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Intent.&lt;/strong&gt; An employee's access model trusts that the person means the action they take. An agent's cannot, because the model will follow any instruction that reaches it, whether or not the person driving wrote it. Simon Willison's &lt;a href="https://simonwillison.net/2025/Jun/16/the-lethal-trifecta/" rel="noopener noreferrer"&gt;lethal trifecta&lt;/a&gt; names the conditions: private data, untrusted content, and a way to send data out. The July 2026 flaw in the Microsoft Azure DevOps MCP server showed it in production. An HTML comment hidden in a pull request description &lt;a href="https://thehackernews.com/2026/07/microsoft-azure-devops-mcp-flaw-lets.html" rel="noopener noreferrer"&gt;steered a review agent running with the reviewer's own credentials&lt;/a&gt; into triggering a pipeline in another project, reading a confidential wiki page, and posting it back as a comment. Every call in that chain was one the reviewer was allowed to make. When intent cannot be trusted, a deterministic check on each action is the control that still works, which is why the &lt;a href="https://genai.owasp.org/resource/owasp-top-10-for-agentic-applications-for-2026/" rel="noopener noreferrer"&gt;OWASP Top 10 for Agentic Applications&lt;/a&gt; ranks identity and privilege abuse third.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Churn.&lt;/strong&gt; Employee access changes on HR events, and a quarterly review keeps up with that pace. The Entra Agent ID documentation describes agents that &lt;a href="https://learn.microsoft.com/en-us/entra/agent-id/what-are-agent-identities" rel="noopener noreferrer"&gt;exist for minutes during a task, or are created and destroyed thousands of times per day&lt;/a&gt;. A quarterly review of an identity that lived for four minutes is not a control. That is why a dedicated agent identity needs an owner of record, and why an &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; is what turns "did offboarding reach the agents" into a question with an answer.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Composite actor.&lt;/strong&gt; A person acts as one principal. An agent acts as a combination: the person behind the session, the agent workload, the client it runs in, and the task. One assistant serving a whole team produces calls from dozens of people under one workload, so the record has to carry the whole tuple, which is the subject of &lt;a href="https://www.speakeasy.com/resources/agent-composite-identity" rel="noopener noreferrer"&gt;agent composite identity&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The grants can stay where they are. The decision moves to the call.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which system should grant, and which should gate?
&lt;/h2&gt;

&lt;p&gt;Two systems share the job, and they should stay separate. The identity provider grants, and a gateway on the tool-call path gates. NIST SP 800-162, the attribute-based access control reference, names the roles: the policy administration and information points hold the rules and the attributes, and the &lt;a href="https://nvlpubs.nist.gov/nistpubs/specialpublications/NIST.SP.800-162.pdf" rel="noopener noreferrer"&gt;policy decision and enforcement points&lt;/a&gt; compute and apply each decision, and may live somewhere else entirely. For employees, the application is the enforcement point. For agents, nothing is, until something is placed on the path of the call.&lt;/p&gt;

&lt;h3&gt;
  
  
  The identity provider grants
&lt;/h3&gt;

&lt;p&gt;The identity provider already holds who exists, which groups and roles they have, and who owns what, and it is where access reviews and offboarding run. The vendors are extending it to agents on those terms. Okta for AI Agents &lt;a href="https://www.okta.com/blog/ai/okta-ai-agents-early-access-announcement/" rel="noopener noreferrer"&gt;registers agents in Universal Directory with a named human owner and brings them into standard certification workflows&lt;/a&gt;. Microsoft Entra Agent ID gives agents &lt;a href="https://learn.microsoft.com/en-us/entra/agent-id/what-are-agent-identities" rel="noopener noreferrer"&gt;their own identity type, with delegated access on a user's behalf and autonomous access under rights granted directly to the agent&lt;/a&gt;. Both are the right place for the grant to live, because both already answer to the reviews and offboarding the organization runs.&lt;/p&gt;

&lt;p&gt;The identity provider is the wrong place to gate, because it never sees the tool call. It issues a token when the session starts and learns nothing about what the agent does with it. Arcade.dev put the gap plainly in its analysis of the MCP enterprise authorization extension: "provisioned" was never the same as "authorized," and the gap between them is where real attacks live.&lt;/p&gt;

&lt;h3&gt;
  
  
  A gateway on the tool-call path gates
&lt;/h3&gt;

&lt;p&gt;The gating system sits between the agent and every tool it reaches. It terminates the agent session, resolves the directory principal behind it, evaluates each call against that principal's grants, and brokers the downstream credential so the MCP server's own key stops being the recorded actor. That is the job of an &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;, and the products in the market split along the granting and gating line. Cloudflare MCP Server Portals authenticate the person against the corporate identity provider and then enforce which servers the person may reach regardless of the server's own policy. MCP gateways such as Mintive (formerly MintMCP) and Runlayer sit on the tool-call path. Okta and Entra stay on the granting side.&lt;/p&gt;

&lt;p&gt;The gateway is the wrong place to own grants. A gateway that keeps its own allowlists becomes the config file the category set out to replace, with the same drift from the directory and the same invisibility to offboarding. The protocol now connects the two sides. The MCP authorization specification &lt;a href="https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization" rel="noopener noreferrer"&gt;requires OAuth 2.1&lt;/a&gt;, and its Enterprise-Managed Authorization extension, which Okta ships as Cross App Access, lets the &lt;a href="https://www.okta.com/newsroom/press-releases/okta-announces-cross-app-access-partners/" rel="noopener noreferrer"&gt;identity provider issue the grant that the gateway or server enforces&lt;/a&gt;. The person signs in once, the directory decides what the agent may connect to, and the gateway decides what each call may do. How that sign-on flows across many servers is covered in &lt;a href="https://www.speakeasy.com/resources/mcp-sso" rel="noopener noreferrer"&gt;MCP SSO&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you extend IAM to agents?
&lt;/h2&gt;

&lt;p&gt;Extending IAM to agents means the same identity provider, groups, and grants that already govern people also govern AI agents, at the tool call, without a second access model. IAM is extended to an agent when its session authenticates as a directory principal, either the driving person or a dedicated identity with a named owner, and every tool call is allowed or denied against that principal's existing roles.&lt;/p&gt;

&lt;p&gt;Most organizations already run a serious IAM program. Employees typically sign in through Okta or Entra, groups map to roles, roles map to grants, and offboarding is a single directory event. None of that reaches agents by default, because agents act after the login. The default workaround, one shared service account for every agent and a server-level allowlist that is the same for everyone, is a second access model the directory knows nothing about. Extending IAM replaces it with the access model the organization already trusts.&lt;/p&gt;

&lt;h3&gt;
  
  
  What does it mean for an agent to inherit a person's grants?
&lt;/h3&gt;

&lt;p&gt;Inheritance means the agent session authenticates as a directory principal and carries that principal's existing roles into every tool call. For delegated-user authority, the principal is the person. The session starts with their SSO login, and the agent can call &lt;code&gt;create_refund&lt;/code&gt; only if their roles already allow it. This can support an attended or unattended individual agent. For service or workload authority, the principal is a dedicated directory identity with a named human owner.&lt;/p&gt;

&lt;p&gt;The consequence is that existing permissions can apply to agents without new access-control machinery. Teams generally do not need to write an agent-specific policy language or rebuild the role model, since the grants already reviewed, audited, and scoped for people are the grants available to the agent. Inheritance sets the ceiling rather than copying the whole grant, and most organizations restrict the agent to a subset of the driver's roles, so a person whose role allows a destructive call can still drive an agent that is denied it.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/extend-iam-to-agents#what-does-it-mean-for-an-agent-to-inherit-a-persons-grants" rel="noopener noreferrer"&gt;View the diagram showing how a person's grants narrow for an agent tool call on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;How this identity model governs what agents actually do in production is walked through end to end in &lt;a href="https://www.speakeasy.com/blog/governing-agent-actions-with-enterprise-identity" rel="noopener noreferrer"&gt;governing agent actions with enterprise identity&lt;/a&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  Whose permissions does a custom agent run with?
&lt;/h3&gt;

&lt;p&gt;Inheritance is clean when the person driving the agent is the person whose grants apply. An employee working an agent directly in Claude Desktop or an IDE is that case. The session starts with their login, every action is attributable to them, and the agent carries their roles, usually narrowed rather than widened.&lt;/p&gt;

&lt;p&gt;A custom agent breaks that symmetry, since the person who builds a workflow and the person who triggers it are often different people. Three identities could plausibly govern the run, and each maps to IAM differently:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The builder's.&lt;/strong&gt; The agent runs as the engineer who wrote it, so everyone who triggers it borrows that engineer's reach. This is the confused deputy problem, where authorization reflects who built the tool rather than who is using it, and the audit trail attributes every run to one person who performed none of them.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The triggering user's.&lt;/strong&gt; Attribution improves, but the fit is wrong in both directions. The workflow may need a call the user's role does not include, which blocks legitimate runs, and the user's role includes far more than the workflow needs, which the agent inherits for no reason.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The workflow's own.&lt;/strong&gt; The agent gets grants scoped to what the workflow does. But that creates a principal that is neither a person nor a traditional service account, and the directory needs somewhere to put it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Sometimes the directory can absorb this. The workflow is registered as a dedicated principal with a named owner, the service or workload authority pattern, and its grants are reviewed like any other role. Other times the workflow needs a concept the identity system does not have, and that concept is a task-scoped credential: minted per run, naming the triggering person as subject and the agent as actor, and scoped to what this workflow needs for this task. Both answers map onto the persistent and task-scoped methods described below.&lt;/p&gt;

&lt;h3&gt;
  
  
  What happens to agent access when you deprovision a user?
&lt;/h3&gt;

&lt;p&gt;The answer shows whether IAM actually extends to agents or just looks like it does on paper. When IAM is extended to agents, agent access is derived from the directory rather than copied out of it. Disabling the account in the IdP means sessions can no longer authenticate as that person and their grants no longer resolve, so agent access ends at the same point their other access ends. Directory Sync keeps users, groups, and attributes current in between, so a role change can narrow an agent's reach without anyone editing agent configuration.&lt;/p&gt;

&lt;p&gt;When IAM is not extended, offboarding can miss the agent path. A shared service account exists independently of any one employee, so one person leaving does not affect it. An API key embedded in an MCP server config was never tied to that person's identity in the first place. And the leaver's security review has no register that would surface either credential.&lt;/p&gt;

&lt;p&gt;Agents using service or workload authority need one more control here. Because their principal is a dedicated identity rather than the leaver's own account, the named owner field lets the &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; flag agents whose owner has left and needs replacing.&lt;/p&gt;

&lt;h2&gt;
  
  
  How is agent access management different from an MCP server allowlist?
&lt;/h2&gt;

&lt;p&gt;A server allowlist and tool-call RBAC both answer "is this call allowed?", but they answer it at different places with different information.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Property&lt;/th&gt;
&lt;th&gt;Server allowlist&lt;/th&gt;
&lt;th&gt;Tool-call RBAC&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;When the decision is made&lt;/td&gt;
&lt;td&gt;Once, when the server is configured&lt;/td&gt;
&lt;td&gt;On every tool call&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Who it varies by&lt;/td&gt;
&lt;td&gt;Nobody; the same for every caller&lt;/td&gt;
&lt;td&gt;The directory principal behind the session&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What it knows&lt;/td&gt;
&lt;td&gt;The server and its tool list&lt;/td&gt;
&lt;td&gt;The person, the system, and the action&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;What revocation takes&lt;/td&gt;
&lt;td&gt;Redeploying or reconfiguring the server&lt;/td&gt;
&lt;td&gt;A directory change, effective on the next call&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;A server allowlist is a property of the infrastructure. Agent access management is a property of the principal. If the GitHub MCP server exposes 12 tools and the allowlist admits eight, every engineer, contractor, and intern who connects gets the same eight, and the decision was made before any of them showed up. Revoking one person's access means reconfiguring the server for everyone.&lt;/p&gt;

&lt;p&gt;Agent access management makes the decision per tool call and per principal, so a support engineer and a contractor connected to the identical server get different answers because their directory roles differ, and disabling the contractor in the directory ends their access on the next call. The allowlist is worth keeping as the coarse outer boundary, and per-call authorization does the work the allowlist cannot. Enforcing it requires a decision point on the path of every call, which is the gateway described above. The comparison in full, including where each approach fails, is in &lt;a href="https://www.speakeasy.com/resources/mcp-tool-allowlists-vs-per-call-authorization" rel="noopener noreferrer"&gt;MCP tool allowlists vs per-call authorization&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What are the methods of agent access control?
&lt;/h2&gt;

&lt;p&gt;Three methods attach grants to an agent session, and per-call authorization applies on top of all three. Which method fits depends on whether a person is steering, the split mapped in &lt;a href="https://www.speakeasy.com/resources/agent-types" rel="noopener noreferrer"&gt;types of AI agents&lt;/a&gt;.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Method&lt;/th&gt;
&lt;th&gt;Principal&lt;/th&gt;
&lt;th&gt;Grant lifetime&lt;/th&gt;
&lt;th&gt;Fits&lt;/th&gt;
&lt;th&gt;Standard&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Inherited&lt;/td&gt;
&lt;td&gt;The driving person, with the agent named as actor&lt;/td&gt;
&lt;td&gt;The session; ends when the person is disabled&lt;/td&gt;
&lt;td&gt;User-steered agents in Claude, Cursor, or a terminal&lt;/td&gt;
&lt;td&gt;OAuth token exchange with an actor token&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Persistent&lt;/td&gt;
&lt;td&gt;A dedicated agent identity with a named owner&lt;/td&gt;
&lt;td&gt;Standing, until reviewed or revoked&lt;/td&gt;
&lt;td&gt;Workflow and product agents that run unattended&lt;/td&gt;
&lt;td&gt;Workload identity, such as Entra Agent ID or SPIFFE&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Task-scoped&lt;/td&gt;
&lt;td&gt;The triggering person as subject, the agent as actor&lt;/td&gt;
&lt;td&gt;The task; expires on completion&lt;/td&gt;
&lt;td&gt;Delegated runs and assistant-style agents serving many people&lt;/td&gt;
&lt;td&gt;Rich authorization requests and short-lived tokens&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;strong&gt;Inherited access&lt;/strong&gt; runs the agent under the driving person's directory roles. RFC 8693 draws the line that matters: in delegation, the acting party &lt;a href="https://www.rfc-editor.org/rfc/rfc8693.html" rel="noopener noreferrer"&gt;keeps its own identity and acts on behalf of the subject&lt;/a&gt;, so the record shows both the person and the agent, where impersonation would show only the person. The person's grants are the ceiling, and most organizations narrow rather than copy them, so a person whose role allows a destructive call can still drive an agent that is denied it. This is the model for &lt;a href="https://www.speakeasy.com/resources/user-steered-agents" rel="noopener noreferrer"&gt;user-steered agents&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Persistent access&lt;/strong&gt; gives a dedicated agent identity standing grants of its own, scoped to what the workload does rather than to any person. It fits &lt;a href="https://www.speakeasy.com/resources/background-agents" rel="noopener noreferrer"&gt;background agents&lt;/a&gt; that run on a schedule or serve a product, and it carries the cost of any standing privilege: the grants exist whether or not a task is running, so they need an owner of record and a place in the access review cycle. The autonomous access mode in Entra Agent ID, where &lt;a href="https://learn.microsoft.com/en-us/entra/agent-id/what-are-agent-identities" rel="noopener noreferrer"&gt;rights are granted directly to the agent identity&lt;/a&gt;, is the directory-side reference.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Task-scoped access&lt;/strong&gt; mints a credential per run. It names the triggering person as subject and the agent as actor, carries only what this run needs, and expires when the run completes, so nothing stands between tasks. RFC 9396 exists because a scope string &lt;a href="https://www.rfc-editor.org/rfc/rfc9396.html" rel="noopener noreferrer"&gt;cannot express "please let me transfer an amount of 45 Euros to Merchant A"&lt;/a&gt;, and a per-task grant needs that precision. The mechanics, and the case of a workflow built by one person and triggered by another, are in &lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials" rel="noopener noreferrer"&gt;task-scoped credentials&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Per-call authorization&lt;/strong&gt; is the check that runs whichever method attached the grants. On each call, the gateway evaluates the tool, the system, and the principal, and it can require a step up for the calls that warrant one. The MCP specification supports this directly: a server can reject a call with &lt;code&gt;insufficient_scope&lt;/code&gt;, and a client acting for a user &lt;a href="https://modelcontextprotocol.io/specification/2026-07-28/basic/authorization" rel="noopener noreferrer"&gt;should attempt a step-up authorization flow&lt;/a&gt; for the additional scope. Tool annotations such as &lt;code&gt;destructiveHint&lt;/code&gt; help a client decide which calls to confirm with a person, though the specification is explicit that &lt;a href="https://blog.modelcontextprotocol.io/posts/2026-03-16-tool-annotations/" rel="noopener noreferrer"&gt;annotations are hints and must be treated as untrusted&lt;/a&gt; unless they come from a trusted server, so the deterministic rule at the gateway is what holds.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does agent access management cost?
&lt;/h2&gt;

&lt;p&gt;The category has four costs that show up in every deployment.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;A hop on every tool call.&lt;/strong&gt; Per-call authorization means a network hop and a policy evaluation between the agent and the tool, every time. An agent that makes 40 tool calls to finish a task pays it 40 times, and teams that have tuned model latency will notice.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A chokepoint.&lt;/strong&gt; The gateway that gates everything is also the component that, when it is down, stops everything. It also governs only what routes through it. A local stdio MCP server on a laptop, or a server an agent reaches directly, is outside the decision, which is why &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; and &lt;a href="https://www.speakeasy.com/resources/agent-discovery" rel="noopener noreferrer"&gt;agent discovery&lt;/a&gt; are companion controls rather than optional ones.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Policy that someone has to write.&lt;/strong&gt; Directory roles do not arrive with a mapping to &lt;code&gt;create_refund&lt;/code&gt;. Somebody decides which roles may call which tools on which systems, and that work grows with the number of tools, which is why most organizations start with deny rules on destructive calls and widen from there.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Standards and vendors that are still settling.&lt;/strong&gt; Okta for AI Agents went to early access in March 2026, and Cross App Access integrations reach the Okta Integration Network from August 2026. As of June 2026, the MCP Enterprise-Managed Authorization extension had SDK support in TypeScript and Java, with Python in progress. Most organizations will run a mix of OAuth-native servers, brokered legacy servers, and unmanaged local ones for a while, and the gateway has to carry all three.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For a five-person startup, none of this is worth it yet. A personal token per developer and a short allowlist are proportionate. The calculation changes when one credential serves a team, when agents run unattended, or when an auditor asks who issued a refund and the answer has to be a name.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does the Speakeasy AI Control Plane enforce agent access management?
&lt;/h2&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt; is one implementation of the category above. The grants stay in the directory, and the decision moves to the call:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Grants stay in the identity provider.&lt;/strong&gt; Sessions authenticate through Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or most SAML or OIDC providers, over OAuth 2.1 with PKCE and dynamic client registration. The directory stays the system of record, and the platform reads grants from it on each call. Revocation is a directory change, effective on the next call.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The gateway evaluates each tool call.&lt;/strong&gt; Agents reach tools through the platform's &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;, which resolves the principal behind the session and allows or denies each call against that principal's grants, whether the principal is the driving person or a dedicated agent identity with a named owner. The gateway brokers downstream tokens, so nobody re-authenticates per MCP server and the server's own key stops being the recorded actor.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;All three methods run on one path.&lt;/strong&gt; User-steered sessions inherit the person. Workflow and product agents get a dedicated identity whose name, owner, and grants the platform holds without holding a long-lived secret. Delegated runs get a task-scoped credential minted per request and expired when the task completes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every decision is recorded under a name.&lt;/strong&gt; The audit answers who called what, through which agent, in which client, with the grant that allowed it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The identity model and the credential lifecycle behind those decisions are on the &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity product page&lt;/a&gt;. If you are replacing a shared bot account and want to see the gateway evaluate your own directory's grants per call, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is agent access management?
&lt;/h3&gt;

&lt;p&gt;Agent access management is the set of controls that decide and enforce what each AI agent may call: which tools, on which systems, under which directory principal. It replaces a shared bot credential and a flat MCP server allowlist with an authorization decision on every tool call, evaluated against the grants of the person driving the agent or of a dedicated agent identity with a named owner. The decision is made per call rather than once at login, because the login gate never sees agent tool calls.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do most organizations manage AI agent access today?
&lt;/h3&gt;

&lt;p&gt;Most organizations manage agent access with credentials copied into agent configuration files, a shared service account behind each integration a team uses, and a server allowlist that is the same for every caller. A developer pastes a personal access token into an MCP client config, the team consolidates onto one bot credential that carries everyone's permissions, and the client or a proxy decides once which servers may be connected. None of those arrangements consults the person's directory grants at the moment a tool is called.&lt;/p&gt;

&lt;h3&gt;
  
  
  What fails when every agent shares one service account?
&lt;/h3&gt;

&lt;p&gt;Three controls fail at once. Attribution fails because every call arrives under the service account's name, so the audit cannot say which agent acted or who was driving it. Least privilege fails because the credential carries the union of every team member's needs, so any agent that holds it can reach everything any agent might need. Lifecycle fails because no directory event ends the credential when the people behind it leave, so it keeps working after offboarding and, if it leaks, until someone rotates it.&lt;/p&gt;

&lt;h3&gt;
  
  
  How are agent access controls different from employee access controls?
&lt;/h3&gt;

&lt;p&gt;Agent access controls use the same grants as employee access controls and enforce them at a different point. Employee access is decided once at login, because a person clicking through an application can only do what the application offers. Agent access has to be decided at each tool call, because an agent's session says nothing about what it will do next, its instructions can be planted by content it reads, its sessions are created and destroyed faster than any access review runs, and one agent often acts for many people.&lt;/p&gt;

&lt;h3&gt;
  
  
  Which system should manage agent access controls, the identity provider or a gateway?
&lt;/h3&gt;

&lt;p&gt;Both, with separate jobs. The identity provider is the granting system: it holds who exists, which groups and roles they have, and who owns each agent identity, and it is where access reviews and offboarding already run. A gateway on the path of every tool call is the gating system: it resolves the principal behind the session, checks each call against the directory's grants, and brokers downstream credentials. The identity provider cannot gate because it never sees the tool call, and the gateway should not own grants because a second permission system drifts from the directory.&lt;/p&gt;

&lt;h3&gt;
  
  
  What does it mean to extend IAM to agents?
&lt;/h3&gt;

&lt;p&gt;Extending IAM to agents means the same identity provider, groups, and grants that already govern people also govern AI agents, at the tool call, without a second access model. IAM is extended to an agent when its session authenticates as a directory principal, either the driving person or a dedicated identity with a named owner, and every tool call is allowed or denied against that principal's existing roles.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does an agent inherit all of a person's permissions?
&lt;/h3&gt;

&lt;p&gt;Inheritance sets the ceiling rather than copying the grant outright. An agent a person drives can never exceed their grants, and most organizations narrow it further, denying the agent destructive calls that the person's own role allows. The directory still makes the access decisions, and the agent operates under a restricted subset of the driver's roles.&lt;/p&gt;

&lt;h3&gt;
  
  
  Whose permissions does a custom agent built by someone else run with?
&lt;/h3&gt;

&lt;p&gt;Not the builder's permissions. Running the agent as the person who built it lets everyone who triggers it borrow the builder's reach, which is the confused deputy problem. Running it as the triggering user fits badly in both directions, blocking calls the workflow needs and inheriting grants it never uses. The workable answers are a dedicated directory principal for the workflow with a named owner, or a task-scoped credential minted per run that names the triggering person as subject, the agent as actor, and only what the workflow needs as scope.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is agent access management different from an MCP server allowlist?
&lt;/h3&gt;

&lt;p&gt;An MCP server allowlist is one decision, made when the server is configured, and it is the same for every caller. Agent access management makes the decision per tool call and per principal, so a support engineer and a contractor connected to the identical server get different answers because their directory roles differ. The allowlist is worth keeping as the coarse outer boundary, and per-call authorization does the work the allowlist cannot.&lt;/p&gt;

&lt;h3&gt;
  
  
  What are the methods of agent access control?
&lt;/h3&gt;

&lt;p&gt;Three methods attach grants to an agent session. Inherited access runs the agent under the driving person's directory roles, usually narrowed, so the person's grants are the ceiling. Persistent access gives a dedicated agent identity standing grants of its own with a named human owner, which fits workflow and product agents that run unattended. Task-scoped access mints a short-lived credential per run that names the triggering person as subject and the agent as actor and expires when the task completes. Per-call authorization applies on top of all three.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is per-call authorization for AI agents?
&lt;/h3&gt;

&lt;p&gt;Per-call authorization is the check a gateway runs on every tool call an agent makes, evaluating the tool, the system, and the principal behind the session against the directory's grants before the call reaches the downstream system. It is what makes agent access management enforceable, because the login-time decision cannot see individual tool calls. The MCP authorization specification supports it directly: a server can reject a call with insufficient_scope, and a client acting for a user should attempt a step-up authorization flow for the additional scope.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do you enforce RBAC for AI agents?
&lt;/h3&gt;

&lt;p&gt;To enforce RBAC for AI agents, bind each agent session to a directory principal, keep the roles and grants in the identity provider, and place a gateway on the tool-call path that evaluates every call against that principal's roles. Roles do not arrive with a mapping to individual tools, so the gateway's policy has to say which roles may call which tools on which systems, and most organizations start by denying destructive calls and widen from there. Revocation is then a directory change, effective on the next call.&lt;/p&gt;

&lt;h3&gt;
  
  
  What happens to agent access when a user is deprovisioned?
&lt;/h3&gt;

&lt;p&gt;Access derived from the person ends with the person. Sessions that inherit an employee's grants stop authorizing when the identity provider disables the account, because the grants are resolved from the directory on each call rather than copied into agent configuration. Access held by a dedicated agent identity survives the departure by design, so each dedicated identity needs an owner of record, and an agent whose owner has left is flagged in the agent inventory for reassignment or revocation.&lt;/p&gt;

&lt;h3&gt;
  
  
  What does agent access management cost?
&lt;/h3&gt;

&lt;p&gt;Agent access management adds a policy evaluation to every tool call, puts a gateway in the path that becomes a chokepoint and governs only the traffic routed through it, and requires someone to write tool-level policy that directory roles do not come with. The vendor and standards side is still settling, so most organizations run a mix of OAuth-native servers, brokered legacy servers, and unmanaged local ones for a while. For a solo developer or a five-person team, a personal token and a short allowlist are proportionate.&lt;/p&gt;

&lt;h3&gt;
  
  
  Do I need agent access management?
&lt;/h3&gt;

&lt;p&gt;You need agent access management when one credential serves more than one person, when agents run unattended, or when an auditor asks who issued a refund and the answer has to be a name. Below that threshold, a personal token per developer and a short server allowlist are the right amount of process. Above it, the shared bot account fails attribution, least privilege, and lifecycle at the same time, and no allowlist restores them.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does the Speakeasy AI Control Plane enforce agent access management?
&lt;/h3&gt;

&lt;p&gt;The Speakeasy AI Control Plane puts a gateway on the path between agents and tools and leaves the grants in the identity provider the organization already runs. Sessions authenticate once through Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or most SAML or OIDC providers, the gateway brokers downstream tokens so nobody re-authenticates per MCP server, and every tool call is allowed or denied against the principal's directory grants, whether that principal is the driving person or a dedicated agent identity with a named owner. Every decision is recorded under a name, and revocation is a directory change, effective on the next call.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is agent auth?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Thu, 19 Nov 2026 11:33:06 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-agent-auth-le3</link>
      <guid>https://dev.to/speakeasy/what-is-agent-auth-le3</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/agent-auth" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Agent auth
&lt;/h2&gt;

&lt;p&gt;Agent auth is how an AI agent proves who it is and is granted access to a resource, on a person's behalf or under a dedicated identity. Today that commonly uses OAuth 2.1 with an enterprise identity provider. AAuth is an IETF draft that replaces bearer tokens with signed requests and a cryptographic agent identity.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;Agent identity&lt;/a&gt; and agent auth split one question in two. Identity names the principal a session binds to: a person for delegated-user authority, or a dedicated identity with a named human owner for service or workload authority. This dimension is separate from the &lt;a href="https://www.speakeasy.com/resources/agent-types" rel="noopener noreferrer"&gt;agent's working arrangement&lt;/a&gt;. Agent auth is the protocol by which the agent proves that binding to a resource and receives its grant. When an agent selects a tool at runtime, the resource still needs a verified principal and an authorization decision before it handles the call. OAuth 2.1 is the current path, while AAuth proposes signed requests for the same layer.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is agent auth?
&lt;/h2&gt;

&lt;p&gt;Agent authentication and authorization arrive together on every agent request. Authentication proves which principal the agent acts for, and authorization determines what that principal may do. When an employee connects an agent to a &lt;a href="https://modelcontextprotocol.io" rel="noopener noreferrer"&gt;Model Context Protocol (MCP)&lt;/a&gt; server, both operations commonly run over OAuth 2.1 against the enterprise identity provider in production deployments today.&lt;/p&gt;

&lt;p&gt;Three protocols occupy the layer at different stages of maturity.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;OAuth 2.1&lt;/strong&gt; is the shipping baseline. The MCP core specification defines an optional authorization model built on it, with PKCE, dynamic client registration, and resource indicators.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Enterprise-Managed Authorization (EMA)&lt;/strong&gt;, with Cross App Access (XAA) on the identity provider side, keeps OAuth but moves the grant decision from per-server consent screens to the IdP. Both are covered in depth in &lt;a href="https://www.speakeasy.com/resources/mcp-sso" rel="noopener noreferrer"&gt;MCP SSO&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;AAuth&lt;/strong&gt; is an IETF Internet-Draft that changes the token model itself, replacing bearer tokens with signed requests from a per-agent keypair.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/agent-auth#what-is-agent-auth" rel="noopener noreferrer"&gt;View the agent authentication and authorization diagram on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The principal being proven is the subject of its own pages: what qualifies as an agent identity is in &lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt;, why a shared service account is the wrong shape for it is in &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;what is NHI&lt;/a&gt;, and how existing directory groups and permissions govern agent access is in &lt;a href="https://www.speakeasy.com/resources/agent-access-management#how-do-you-extend-iam-to-agents" rel="noopener noreferrer"&gt;extending IAM to agents&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is AAuth for agent authentication?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.aauth.dev/" rel="noopener noreferrer"&gt;AAuth&lt;/a&gt; is a proposed HTTP authorization protocol for agent-to-resource access, published as the IETF Internet-Draft &lt;a href="https://datatracker.ietf.org/doc/html/draft-hardt-oauth-aauth-protocol" rel="noopener noreferrer"&gt;draft-hardt-oauth-aauth-protocol&lt;/a&gt; by Dick Hardt, an author of OAuth 2.0. The current revision, draft-hardt-oauth-aauth-protocol-10, was published on 6 August 2026. The premise is that every HTTP client gets its own cryptographic identity. An agent identifier of the form &lt;code&gt;aauth:local@domain&lt;/code&gt; is bound to a signing key published at a well-known URL, verifiable by any party with no pre-registration and no shared secret. Every request the agent makes is signed with HTTP Message Signatures, identity claims and authorization claims travel in the same token, and the protocol coexists with OAuth 2.0 and OpenID Connect rather than replacing them.&lt;/p&gt;

&lt;p&gt;The draft defines four resource access modes. Each one adds a party to the exchange, and which mode applies depends on how much the resource trusts the agent's own signature versus wanting a third party to vouch for it.&lt;/p&gt;

&lt;p&gt;At the simplest end, &lt;strong&gt;identity-based&lt;/strong&gt; access needs only the resource and the agent: the resource verifies the agent's signature against its published key and applies its own policy, with no other party involved. &lt;strong&gt;Resource-managed (two-party)&lt;/strong&gt; access adds an authorization flow the resource runs itself, similar to an OAuth consent screen but keyed to the agent's identity instead of a bearer token. &lt;strong&gt;PS-asserted (three-party)&lt;/strong&gt; access brings in a person server, chosen by the user, that asserts identity and consent on the user's behalf, so the resource trusts the person server's assertion rather than verifying the user directly. &lt;strong&gt;Federated (four-party)&lt;/strong&gt; access goes one step further: the person server itself federates with a separate access server that guards the resource, so neither the agent nor the person server needs a direct relationship with the resource. A deployment picks the simplest mode that satisfies the resource's trust requirements, adding a person server only once consent needs to travel through a chain of parties the agent has no direct relationship with.&lt;/p&gt;

&lt;p&gt;Sitting on top of resource access, AAuth's governance layer adds objects that OAuth scopes don't express: a mission that scopes a multi-resource task, a justification for why access is needed, per-action permission, audit, and an interaction relay through the person server that lets a person ask for clarification before consenting or question the agent mid-task. Any agent with a person server can add this layer regardless of which resource access mode it uses, because governance describes what the agent is allowed to do once it holds a grant, not how it obtained that grant.&lt;/p&gt;

&lt;p&gt;Three token types carry the protocol: &lt;code&gt;agent_token&lt;/code&gt; proves the agent's own identity, &lt;code&gt;resource_token&lt;/code&gt; carries the grant a specific resource issued, and &lt;code&gt;auth_token&lt;/code&gt; carries the outcome of a governance decision such as a mission approval. All three are JWTs, verified against a &lt;code&gt;jwks_uri&lt;/code&gt; discovered through well-known metadata, the same discovery mechanism that lets a resource find an agent's public key with no pre-registration.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does AAuth differ from OAuth for agent authorization?
&lt;/h2&gt;

&lt;p&gt;The draft names three main differences from OAuth.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Signed requests instead of bearer tokens.&lt;/strong&gt; An OAuth bearer token grants access to any caller that presents it. AAuth binds every request to the agent's signing key with HTTP Message Signatures, so possession of a token without the private key proves nothing.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A per-agent keypair instead of a registered client secret.&lt;/strong&gt; An OAuth &lt;code&gt;client_id&lt;/code&gt; is issued by each authorization server, so an identifier registered at one service means nothing at another, and confidential clients carry a shared secret. An AAuth agent identifier travels with the agent, and its public key is published at a well-known URL, so a resource the agent has never contacted can verify it on the first call.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Agent-originated calls instead of browser-originated grants.&lt;/strong&gt; OAuth grants begin with a browser redirect before the client may call. An AAuth exchange begins with the agent's signed request, and when consent is required the server answers 202 Accepted with an interaction requirement, treating a pending decision as a normal protocol state while a person approves mid-task.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How does AAuth relate to MCP, EMA, and XAA?
&lt;/h2&gt;

&lt;p&gt;AAuth is not part of MCP. The MCP core specification (2026-07-28) defines an optional authorization model on OAuth 2.1, and &lt;a href="https://modelcontextprotocol.io/extensions/auth/enterprise-managed-authorization" rel="noopener noreferrer"&gt;EMA&lt;/a&gt; is the stable extension that moves the grant decision to the enterprise IdP through the ID-JAG exchange, with &lt;a href="https://auth0.com/docs/ai-agents-mcp/cross-app-access" rel="noopener noreferrer"&gt;XAA&lt;/a&gt; as the Okta and Auth0 implementation of the IdP side. EMA and XAA extend OAuth and keep its token model. AAuth replaces the token model, so conflating it with XAA misreads both. XAA is OAuth with an IdP-issued grant, and AAuth is signed requests with no bearer token at all.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Protocol&lt;/th&gt;
&lt;th&gt;What it does&lt;/th&gt;
&lt;th&gt;Status&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;OAuth 2.1 (MCP core)&lt;/td&gt;
&lt;td&gt;Interactive per-server grants with PKCE, dynamic client registration, and resource indicators&lt;/td&gt;
&lt;td&gt;Shipping in the MCP 2026-07-28 specification&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;EMA / XAA&lt;/td&gt;
&lt;td&gt;The enterprise IdP grants server access through the ID-JAG exchange, with no per-server consent screens&lt;/td&gt;
&lt;td&gt;Stable MCP extension; shipping at Okta, Early Access at Auth0&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AAuth&lt;/td&gt;
&lt;td&gt;Signed requests from a per-agent keypair replace bearer tokens&lt;/td&gt;
&lt;td&gt;Internet-Draft, not adopted by an IETF working group&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Hardt's stated motivation runs through MCP. After implementing authorization for an MCP server, he concluded that &lt;a href="https://www.aauth.dev/" rel="noopener noreferrer"&gt;OAuth is not a good fit for MCP&lt;/a&gt; and started the work that became AAuth. That is his framing, not a position the MCP project has adopted, and the specification's authorization model remains OAuth 2.1. The EMA and XAA mechanics are walked through in &lt;a href="https://www.speakeasy.com/resources/mcp-sso" rel="noopener noreferrer"&gt;MCP SSO&lt;/a&gt;, and what the MCP specification does and does not cover on the security side is mapped in &lt;a href="https://www.speakeasy.com/resources/mcp-security" rel="noopener noreferrer"&gt;MCP security&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is AAuth a standard?
&lt;/h2&gt;

&lt;p&gt;No. AAuth is an active Internet-Draft, an individual submission with an intended status of Standards Track, and it has not been adopted by an IETF working group. The current revision expires on 7 February 2027 unless a newer one replaces it. Every Internet-Draft is a proposal under discussion, so the document is not a ratified specification.&lt;/p&gt;

&lt;p&gt;The work is further along than a paper design. Reference SDKs exist for Node.js, Go, and .NET, a Python demo covers the multi-agent flow, and the &lt;a href="https://github.com/dickhardt/aauth" rel="noopener noreferrer"&gt;GitHub repository&lt;/a&gt; hosts the specification family, including companion drafts for bootstrapping and rich resource requests. It is exploratory, and the sensible posture for a security team is to evaluate it, follow working group adoption, and keep production agent traffic on the OAuth path the ecosystem actually ships.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does Speakeasy do agent auth?
&lt;/h2&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt; runs the shipping path. Sessions authenticate through the identity provider the organization already operates, whether Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or any SAML or OIDC provider, using OAuth 2.1 with PKCE and dynamic client registration. The platform's &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt; presents that one OAuth surface to every client, including for upstream servers that have no OAuth of their own, binds each session to a directory principal, and authorizes every tool call against that principal's grants. Credentials follow the shape &lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials" rel="noopener noreferrer"&gt;task-scoped credentials&lt;/a&gt; describes short-lived, identity-bound credentials that expire when the task completes.&lt;/p&gt;

&lt;p&gt;Speakeasy does not implement AAuth signed-request auth, and it does not implement the EMA ID-JAG exchange. The platform binds every agent session to a principal from the directory and puts an authorization decision on every tool call. This control applies regardless of the protocol the layer settles on. The identity model behind that binding is the commercial page at &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt;. To see a session authenticate against your own IdP, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is agent auth?
&lt;/h3&gt;

&lt;p&gt;Agent auth is how an AI agent proves who it is and is granted access to a resource, on a person's behalf or under a dedicated identity. Today that commonly uses OAuth 2.1 with an enterprise identity provider. AAuth is an IETF draft that replaces bearer tokens with signed requests and a cryptographic agent identity. It is the mechanism layer under agent identity. Identity names the principal a session binds to, and agent auth is the protocol that proves that binding to a resource and carries the grant.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is AAuth?
&lt;/h3&gt;

&lt;p&gt;AAuth is a proposed HTTP authorization protocol for agent-to-resource access, published as the IETF Internet-Draft draft-hardt-oauth-aauth-protocol by Dick Hardt, an author of OAuth 2.0. It gives every HTTP client its own cryptographic identity, signs every request with HTTP Message Signatures instead of presenting a bearer token, and carries identity claims and authorization claims in the same token. It is designed to coexist with OAuth 2.0 and OpenID Connect rather than replace them, and it remains a draft, not a ratified standard.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is AAuth different from OAuth?
&lt;/h3&gt;

&lt;p&gt;An OAuth client presents a bearer token any holder can replay, registers for a client_id with each authorization server in advance, and obtains grants through a browser redirect. An AAuth agent holds its own keypair, publishes the public key at a well-known URL with no pre-registration, and signs each request with HTTP Message Signatures, so a stolen token is useless without the private key. Consent can also arrive after the request starts. A server answers a pending authorization with 202 Accepted and an interaction requirement instead of treating it as an error.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does AAuth relate to MCP, EMA, and XAA?
&lt;/h3&gt;

&lt;p&gt;They are three separate approaches to agent auth at different stages of maturity. The Model Context Protocol (MCP) core specification uses OAuth 2.1 with PKCE and dynamic client registration. Enterprise-Managed Authorization (EMA) is the stable MCP extension that grants server access from the enterprise IdP through the ID-JAG exchange, and Cross App Access (XAA) is the Okta and Auth0 implementation of the IdP side of that exchange. AAuth is a third, separate Internet-Draft that replaces bearer tokens with signed requests. EMA and XAA extend OAuth and keep its token model.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is AAuth a standard?
&lt;/h3&gt;

&lt;p&gt;No. AAuth is an active Internet-Draft, individual submission draft-hardt-oauth-aauth-protocol-10, published 6 August 2026 with an intended status of Standards Track, and it expires on 7 February 2027 unless a newer revision replaces it. Reference SDKs exist for Node.js, Go, and .NET, but the draft has not been adopted by an IETF working group and is not part of the MCP specification. It is worth evaluating and not yet something to take a production dependency on.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does Speakeasy do agent auth?
&lt;/h3&gt;

&lt;p&gt;Sessions authenticate through the identity provider the organization already runs, whether Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or any SAML or OIDC provider, using OAuth 2.1 with PKCE and dynamic client registration. The MCP gateway presents that one OAuth surface to every client even when the servers behind it have no OAuth of their own, binds each session to a directory principal, and authorizes every tool call against that principal's grants. Speakeasy does not implement AAuth signed-request auth or the EMA ID-JAG exchange. The production path is IdP-bound OAuth on the tool-call path.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is composite identity for agents?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Wed, 18 Nov 2026 13:05:23 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-composite-identity-for-agents-2mjj</link>
      <guid>https://dev.to/speakeasy/what-is-composite-identity-for-agents-2mjj</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/agent-composite-identity" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Composite identity
&lt;/h2&gt;

&lt;p&gt;A composite identity for agents is the tuple bound at the start of a session,&lt;br&gt;
the person from the directory, the agent workload, the client, and the task.&lt;br&gt;
Every later authorization, credential, and audit record is scoped to that&lt;br&gt;
resolution. If any part is missing, the session is anonymous and you are back&lt;br&gt;
to a shared service account.&lt;/p&gt;

&lt;p&gt;The term exists because an agent request collapses several parties into one API call. A person delegated the work, an agent is performing it, a client is hosting the agent, and a task frames what the session is for. Most infrastructure records only the credential the call carried, which for agent traffic has usually meant a shared service account, so those parties are typically invisible to authorization and to audit. Composite identity for AI agents names the alternative, resolving all four at the start of the session, then scoping everything the session does to that resolution.&lt;/p&gt;

&lt;p&gt;The concept sits inside the broader discipline of &lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt;, and it is what separates an agent with a real identity from the generic machine credentials described in &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;what is NHI&lt;/a&gt;. This page covers the tuple itself, what the four parts are, why each one has to be there, and where the resolution surfaces afterward.&lt;/p&gt;

&lt;h2&gt;
  
  
  What are the four parts of a composite identity for AI agents?
&lt;/h2&gt;

&lt;p&gt;A session that reaches a tool carries four answers, resolved before the first call goes through. A concrete example of a fully resolved tuple:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Part&lt;/th&gt;
&lt;th&gt;Example&lt;/th&gt;
&lt;th&gt;What it establishes&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;WHO&lt;/td&gt;
&lt;td&gt;
&lt;a href="mailto:sarah@acme.org"&gt;sarah@acme.org&lt;/a&gt;, via Okta SSO&lt;/td&gt;
&lt;td&gt;The person from the directory whose authority the session runs on, or a dedicated identity with a named human owner when no person is driving&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;AGENT&lt;/td&gt;
&lt;td&gt;forge.bot, owner: sarah&lt;/td&gt;
&lt;td&gt;The attested workload doing the work, with an owner of record&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;CLIENT&lt;/td&gt;
&lt;td&gt;Claude Code, OAuth 2.1 + PKCE&lt;/td&gt;
&lt;td&gt;The harness the agent runs in and how it authenticated&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;TASK&lt;/td&gt;
&lt;td&gt;fix-rate-limit&lt;/td&gt;
&lt;td&gt;The unit of work the session exists to complete&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Each part earns its place by scoping something downstream. The person is the delegator, so authorization evaluates against their roles and groups, the same ones that already govern their direct access, which is the subject of &lt;a href="https://www.speakeasy.com/resources/extend-iam-to-agents" rel="noopener noreferrer"&gt;extending IAM to agents&lt;/a&gt;. The agent is a principal with an owner of record, which is the field that connects the session to the &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; and makes someone answerable for the workload. The client establishes how the session authenticated. And the task is what credentials get scoped to, so access expires with the work instead of outliving it, the mechanism covered in &lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials" rel="noopener noreferrer"&gt;task-scoped credentials&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The binding happens once, at session start. Individual tool calls do not renegotiate who is acting, and instead inherit the resolution and are evaluated against it.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why isn't SSO enough for AI agent identity?
&lt;/h2&gt;

&lt;p&gt;SSO proves exactly one of the four parts. A valid IdP assertion says a person authenticated, but it says nothing about which workload is now acting, in which client, on what work. That gap is why SSO for AI agents on its own cannot carry the same weight it does for human sign-in. Handing that assertion to an agent makes the agent's actions indistinguishable from the person's own, which is the wrong answer for authorization, since an agent should not automatically hold everything its operator holds, and the wrong answer for audit, since the record cannot distinguish what Sarah did from what her agent did.&lt;/p&gt;

&lt;p&gt;So the two halves are proven separately. The person signs in through the identity provider, and the agent workload is attested through workload attestation, meaning it presents evidence that it is the workload it claims to be. Together the signed-in person and the attested workload form the composite identity.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/agent-composite-identity#why-isnt-sso-enough-for-ai-agent-identity" rel="noopener noreferrer"&gt;View the two proofs diagram on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The attestation itself is a proof layer beneath the tuple. Speakeasy accepts four attestation classes: platform identity, a registered key, your IdP, and SPIFFE. All four terminate in the same token exchange, so nothing downstream branches on which proof was used. Which class fits which deployment is a runtime question, and the &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity product page&lt;/a&gt; covers it. The tuple is the same regardless.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happens to AI agent audit trails without composite identity?
&lt;/h2&gt;

&lt;p&gt;When any part of the tuple fails to resolve, the session is anonymous, and anonymous agent traffic in practice means a shared service account. That failure mode has a consistent shape:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Authorization loses its subject.&lt;/strong&gt; With no person in the tuple, policy cannot evaluate against roles or group memberships, so enforcement degrades to a server-level allowlist that is the same for every caller.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Credentials lose their scope.&lt;/strong&gt; With no task and no person to bind to, the credential is a long-lived secret shared by everything that uses the account, and revoking it breaks all of them at once.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Audit loses its answer.&lt;/strong&gt; The record says the service account acted. Who drove it, on whose authority, and for what work typically cannot be recovered after the fact.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Offboarding loses its hook.&lt;/strong&gt; Nothing connects the account to a directory identity, so a person leaving the organization does not change what their agents can reach.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This is the general weakness of unowned machine credentials, described in &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;what is NHI&lt;/a&gt;, showing up in agent traffic specifically. The composite identity is what each of those failures is missing.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does composite identity appear in the AI agent audit trail?
&lt;/h2&gt;

&lt;p&gt;The resolution is only worth performing if it survives into the record. Each audit event carries five dimensions from the tuple as first-class fields rather than strings inside a log line:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Actor.&lt;/strong&gt; The agent that made the call.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Delegator.&lt;/strong&gt; The person on whose authority it acted.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Grant.&lt;/strong&gt; The rule that allowed or denied the action.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Attestation class.&lt;/strong&gt; Which form of proof the workload presented.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Credential provenance.&lt;/strong&gt; Where the credential the call used came from.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That set is enough to answer who did what, on whose authority, under which rule, and with what proof. Because the fields are structured dimensions, those are query filters rather than a reconstruction project across raw logs.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does the Speakeasy AI Control Plane resolve composite identity for AI agents?
&lt;/h2&gt;

&lt;p&gt;On the &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt;, identity resolves first, before policy, credentials, or anything else the session will do. The person signs in through the identity provider the organization already runs, whether Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or most SAML or OIDC providers, over OAuth 2.1 with PKCE. The agent workload is attested through one of the four classes above, and both proofs terminate in the same token exchange.&lt;/p&gt;

&lt;p&gt;That exchange is the standard RFC 8693 flow. It mints a session whose subject is the person and whose actor is the agent, and the full tuple resolves to exactly one upstream credential or to an error, failing closed rather than falling back to anything shared. How those credentials are minted and expired is covered in &lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials" rel="noopener noreferrer"&gt;task-scoped credentials&lt;/a&gt;, and the full runtime model lives on the &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity product page&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;From there the platform holds the resolution steady for the life of the session. Every tool call is authorized against the person's grants, every credential is bound to the person and the task, and every allow and deny lands in the AI agent audit trail with the actor, delegator, grant, attestation class, and provenance attached. Where the binding holds, deprovisioning the person in the directory ends the agent access that ran on their delegated authority. To see composite identity for AI agents resolved against your own directory, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is a composite identity for agents?
&lt;/h3&gt;

&lt;p&gt;A composite identity for agents is the tuple bound at the start of a session, the person from the directory, the agent workload, the client, and the task. Every later authorization, credential, and audit record is scoped to that resolution. If any part is missing, the session is anonymous and you are back to a shared service account.&lt;/p&gt;

&lt;h3&gt;
  
  
  What are the four parts of a composite identity?
&lt;/h3&gt;

&lt;p&gt;The person, the agent, the client, and the task. A concrete example: the person is &lt;a href="mailto:sarah@acme.org"&gt;sarah@acme.org&lt;/a&gt;, signed in through Okta SSO, the agent is forge.bot, a workload whose owner of record is Sarah, the client is Claude Code, connected over OAuth 2.1 with PKCE, and the task is fix-rate-limit, the unit of work the session exists to complete. All four are resolved once, at session start, and everything the session does is scoped to them.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is composite identity for AI agents different from the person's SSO session?
&lt;/h3&gt;

&lt;p&gt;SSO proves one of the four parts, the person. It says nothing about which workload is acting, which client it is running in, or what it is trying to do. In a composite identity, the person signs in through the IdP and the agent workload is attested separately, so the session carries proof of both the human authority and the software exercising it. An SSO token alone, handed to an agent, makes every action the agent takes indistinguishable from the person's own.&lt;/p&gt;

&lt;h3&gt;
  
  
  What happens when part of the composite identity is missing?
&lt;/h3&gt;

&lt;p&gt;The session is anonymous, and in practice that means the traffic runs as a shared service account. Authorization falls back to a server-level allowlist that is the same for everyone, credentials are long-lived because nothing scopes them to a person or a task, and the audit trail records that the service account acted without saying on whose behalf. An incident review asking who drove this, on whose authority, or for what work typically has no answer.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does an agent workload prove it is part of a composite identity?
&lt;/h3&gt;

&lt;p&gt;The workload proves it through attestation. The person signs in through the identity provider, and the agent workload presents proof that it is the workload it claims to be. Speakeasy accepts four attestation classes: platform identity, a registered key, your IdP, and SPIFFE. All four terminate in the same token exchange, so the rest of the system never branches on which proof was used.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does composite identity appear in the AI agent audit trail?
&lt;/h3&gt;

&lt;p&gt;Each audit record carries the actor, the delegator, the grant, the attestation class, and the credential provenance as first-class dimensions rather than strings inside a log line. That is enough to answer who did what, on whose authority, under which rule, and with what proof, without reconstructing the session from raw logs.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is a non-human identity (NHI)?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Wed, 18 Nov 2026 09:00:05 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-a-non-human-identity-nhi-5e97</link>
      <guid>https://dev.to/speakeasy/what-is-a-non-human-identity-nhi-5e97</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;A non-human identity (NHI) is a digital identity that lets software authenticate and access resources: a service, workload, pipeline, bot, or AI agent. The identity represents the software actor. An API key, OAuth token, or certificate is a credential it presents, while a cloud IAM role defines the permissions it can assume.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://cloudsecurityalliance.org/artifacts/defining-non-human-identity" rel="noopener noreferrer"&gt;Cloud Security Alliance&lt;/a&gt; distinguishes the software actor from the credentials it presents. The distinction between the actor, its credentials, and its permissions matters when you need to know who owns access, what can be rotated, and what must be revoked. Vendors use the term "NHI" for this problem space, but do not always apply it to the same object.&lt;/p&gt;

&lt;p&gt;Human and non-human identities represent different actors and follow different lifecycle and access patterns.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/non-human-identity#:~:text=Human%20and%20non%2Dhuman%20identities" rel="noopener noreferrer"&gt;View the human and non-human identities comparison on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  What do IAM vendors mean by NHI?
&lt;/h2&gt;

&lt;p&gt;Vendors agree that NHIs let software access systems, but they draw the line between the identity and its credential differently.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Okta:&lt;/strong&gt; &lt;a href="https://www.okta.com/identity-101/what-are-non-human-identities/" rel="noopener noreferrer"&gt;NHI includes&lt;/a&gt; software actors such as service accounts, bots, and AI agents, as well as credentials such as API keys and tokens. Okta reserves machine identity for infrastructure such as virtual machines, containers, and devices.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Microsoft:&lt;/strong&gt; An &lt;a href="https://www.microsoft.com/en-us/security/business/security-101/what-are-non-human-identities" rel="noopener noreferrer"&gt;NHI is a digital identity used by software&lt;/a&gt;. Microsoft Entra groups application identities under the term &lt;a href="https://learn.microsoft.com/en-us/entra/workload-id/workload-identities-overview" rel="noopener noreferrer"&gt;&lt;strong&gt;workload identity&lt;/strong&gt;&lt;/a&gt;. &lt;a href="https://learn.microsoft.com/en-us/entra/agent-id/what-is-microsoft-entra-agent-id" rel="noopener noreferrer"&gt;Entra Agent ID&lt;/a&gt; gives AI agents a separate model because they make dynamic decisions and adapt their behavior.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;CyberArk:&lt;/strong&gt; NHI and machine identity are often used interchangeably for software actors across infrastructure and applications.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Palo Alto Networks:&lt;/strong&gt; Machine identity is used more narrowly for cryptographic identities such as TLS certificates and SSH keys.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Oasis:&lt;/strong&gt; &lt;a href="https://www.oasis.security/blog/what-are-non-human-identities" rel="noopener noreferrer"&gt;NHI covers&lt;/a&gt; digital constructs used for machine-to-machine access and authentication.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Astrix:&lt;/strong&gt; &lt;a href="https://astrix.security/glossary/what-are-non-human-identities/" rel="noopener noreferrer"&gt;NHI covers programmable access credentials&lt;/a&gt;. MCP servers connect AI agents to external tools and APIs.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These definitions overlap, but they do not always describe the same object. Keeping the credential separate from the identity preserves ownership and attribution when credentials rotate.&lt;/p&gt;

&lt;p&gt;The distinction also changes lifecycle management. Human identities usually follow an HR-driven joiner-mover-leaver process for onboarding, role changes, and offboarding. NHIs authenticate programmatically and follow the lifecycle of the software and infrastructure they support.&lt;/p&gt;

&lt;p&gt;This scale makes the lifecycle harder to manage. GitGuardian's &lt;a href="https://blog.gitguardian.com/the-state-of-secrets-sprawl-2025/" rel="noopener noreferrer"&gt;State of Secrets Sprawl 2025&lt;/a&gt; found 23.8 million secrets across 1.4 billion public GitHub commits from 2024. Some environments have up to 50 NHIs for every human identity, while machine-identity inventories have reached 82 per employee. These figures count different objects, so they are not directly comparable. They still show that machine access can outnumber workforce access by a wide margin.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/resources/iso-27001-agentic-ai" rel="noopener noreferrer"&gt;ISO 27001&lt;/a&gt; standard includes Annex A control A.5.16 for identity management. Applying that control to an agent means giving it an identity that is issued, attributable, and revocable.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do AI agents differ from service accounts and API keys?
&lt;/h2&gt;

&lt;p&gt;A &lt;strong&gt;service account&lt;/strong&gt; is a directory object an application uses to run a job. A &lt;strong&gt;workload identity&lt;/strong&gt; in Entra can be the application, service principal, or managed identity assigned to that workload. An &lt;strong&gt;API key&lt;/strong&gt; or OAuth token is a credential; a &lt;strong&gt;machine identity&lt;/strong&gt; is often a certificate or SSH key bound to infrastructure.&lt;/p&gt;

&lt;p&gt;An &lt;strong&gt;AI agent&lt;/strong&gt; can use several of these identity and credential types. It may be created on demand, switch roles, and act as a system or on behalf of a person. That combination calls for an identity model that records an owner, scoped access, and a lifecycle.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/resources/agent-types" rel="noopener noreferrer"&gt;four agent working arrangements&lt;/a&gt; classify accountability and engagement. Identity uses a separate security dimension with two common authority patterns:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Delegated-user authority.&lt;/strong&gt; Cursor, Claude Code, Copilot, or an internal assistant calls tools on a person's behalf. The agent should use that person's delegated permissions. This authority can continue into an unattended individual task.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Service or workload authority.&lt;/strong&gt; An agent performs a shared organizational role through a dedicated identity, a human sponsor, and short-lived credentials. This authority can support attended or unattended organization agents.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;A hybrid run can use both across different steps. The audit trail must record the principal used for each consequential action.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;Model Context Protocol (MCP)&lt;/a&gt; provides the interface. Agents reach internal APIs, SaaS apps, and data stores through MCP servers that expose tools such as &lt;code&gt;get_invoice&lt;/code&gt; and &lt;code&gt;create_refund&lt;/code&gt;. The identity question is which principal may invoke a given tool, on a given server, in a given session.&lt;/p&gt;

&lt;p&gt;A Kubernetes workload and an agent acting through a Cursor session can both authenticate through NHIs. The agent differs because it chooses its next call at runtime and can chain tools that were not fixed in a manifest.&lt;/p&gt;

&lt;h2&gt;
  
  
  What breaks when an agent uses a shared API key?
&lt;/h2&gt;

&lt;p&gt;Teams often start by placing a shared bot token in the MCP configuration. That weakens four controls that already work for people.&lt;/p&gt;

&lt;h3&gt;
  
  
  How shared keys obscure attribution
&lt;/h3&gt;

&lt;p&gt;The audit identifies the service account, which hides the person or agent behind an action. A legacy OAuth application played a role in Microsoft's 2024 Midnight Blizzard incident, and a service-account password saved to a personal Google account exposed files associated with 134 Okta customers in 2023. The same attribution gap leaves no clear answer to who authorized an agent's refund.&lt;/p&gt;

&lt;h3&gt;
  
  
  How shared keys expand permissions
&lt;/h3&gt;

&lt;p&gt;The shared key is granted the union of every task on the team. &lt;code&gt;get_invoice&lt;/code&gt; and &lt;code&gt;create_refund&lt;/code&gt; travel on the same secret. NHI5 covers overprivileged identities, and NHI9 covers NHI reuse. Per-tool policy cannot distinguish callers when every agent presents the same credential and principal.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why shared keys complicate offboarding
&lt;/h3&gt;

&lt;p&gt;Keys can outlive the people responsible for them. An HR system may deprovision a person without removing a key stored in a configuration file. Secrets management covers where the key lives. NHI lifecycle management covers why the identity exists, who owns it, and when to delete it. Vaulting the key does not name the actor or end the session when the owner is deprovisioned.&lt;/p&gt;

&lt;h3&gt;
  
  
  How long-lived keys extend session risk
&lt;/h3&gt;

&lt;p&gt;NHI7:2025 covers long-lived secrets. Workload identity federation, Azure managed identities, AWS IAM roles, and SPIFFE Verifiable Identity Documents (SVIDs) exist because standing secrets are already the wrong default for workloads. A year-old organization API key applies that default to an agent that prompt injection could induce to use it.&lt;/p&gt;

&lt;p&gt;Privileged access management (PAM) can vault secrets, broker sessions, and provide just-in-time access for human and machine identities. It improves secret handling, but a shared bot token still hides the individual caller at the MCP tool boundary. PAM or another enforcement layer must link each action to the responsible person or agent. For agents, applying &lt;a href="https://www.speakeasy.com/resources/iso-27001-agentic-ai" rel="noopener noreferrer"&gt;ISO 27001 A.8.3&lt;/a&gt; means enforcing that link when the tool is called.&lt;/p&gt;

&lt;h2&gt;
  
  
  How should IAM extend to AI agents?
&lt;/h2&gt;

&lt;p&gt;The identity and access management (IAM) concepts are familiar, but enforcement has to extend into the agent session.&lt;/p&gt;

&lt;h3&gt;
  
  
  Use SSO for delegated sessions
&lt;/h3&gt;

&lt;p&gt;The person behind delegated-user authority signs in through Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or another SAML or OIDC provider. Directory groups inform their role. With session revocation configured, deprovisioning that person in the identity provider (IdP) ends access based on their delegation. Agents using service or workload authority get a dedicated identity with a named human sponsor.&lt;/p&gt;

&lt;h3&gt;
  
  
  Issue short-lived credentials for tool calls
&lt;/h3&gt;

&lt;p&gt;Replace the standing API key with a short-lived token scoped to the agent session and target server. Federation and managed identities already use this pattern for continuous integration (CI) and cloud compute. Evaluate authorization separately on every tool call.&lt;/p&gt;

&lt;h3&gt;
  
  
  Enforce least privilege for each tool
&lt;/h3&gt;

&lt;p&gt;Connecting to an MCP server requires one authorization, and calling a destructive tool on that server requires another. Reads and writes use different grants, with a matching deny taking precedence. This is role-based access control (RBAC) applied to the tool name and its disposition, such as &lt;code&gt;read_only&lt;/code&gt; or &lt;code&gt;destructive&lt;/code&gt;.&lt;/p&gt;

&lt;h3&gt;
  
  
  Record each authorization decision
&lt;/h3&gt;

&lt;p&gt;Each authorization record should capture:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The directory identity.&lt;/li&gt;
&lt;li&gt;The server, tool, and arguments.&lt;/li&gt;
&lt;li&gt;Whether the call was allowed or denied.&lt;/li&gt;
&lt;li&gt;The rule used to reach that decision.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;This record supports ISO 27001 A.8.15 for logging and A.5.16 for identity management. A service-account row in a security information and event management (SIEM) system cannot show which person or agent made the call.&lt;/p&gt;

&lt;p&gt;The IdP remains the source of identity after the person signs in. An enforcement point in the tool path then uses directory attributes, such as groups and roles, to evaluate every call the agent makes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where does the AI Control Plane sit?
&lt;/h2&gt;

&lt;p&gt;Once identity has to be evaluated on the tool call, the organization needs a point in the path that sees the caller, server, and tool before execution. The &lt;a href="https://www.speakeasy.com/resources/ai-control-plane" rel="noopener noreferrer"&gt;AI Control Plane&lt;/a&gt; provides that point.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/non-human-identity#where-does-the-ai-control-plane-sit" rel="noopener noreferrer"&gt;View the AI Control Plane diagram on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt; puts an organization's existing identity system on that path. Agents reach tools through managed or self-hosted MCP endpoints. For delegated-user authority, the person signs in through the organization's IdP. For service or workload authority, an agent can prove its identity with a platform identity, registered key, IdP assertion, or SPIFFE.&lt;/p&gt;

&lt;p&gt;Speakeasy represents policy as a grant with a scope and selector for the server, tool, and disposition. Its telemetry includes the caller's directory identity. When authorization-challenge logging is enabled, it also records allow-or-deny decisions.&lt;/p&gt;

&lt;p&gt;For the product view, see our &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt; guide. Our &lt;a href="https://www.speakeasy.com/blog/governing-agent-actions-with-enterprise-identity" rel="noopener noreferrer"&gt;agent authorization&lt;/a&gt; guide and the &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/guides/govern-agent-actions-with-enterprise-identity" rel="noopener noreferrer"&gt;agent governance guide&lt;/a&gt; follow the authorization path to a single MCP tool call.&lt;/p&gt;

&lt;p&gt;An NHI is an identity for software. An agent identity can represent software acting for a user or as a machine. Its access still needs authorization for each tool.&lt;/p&gt;

&lt;p&gt;To see SSO, per-tool grants, and identity-linked audit records on the path an agent takes, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is NHI?
&lt;/h3&gt;

&lt;p&gt;A non-human identity (NHI) is a digital identity that lets software authenticate and be authorized to access resources. The software might be a service, workload, pipeline, bot, or AI agent. The identity is the actor. An API key, OAuth token, or certificate is a credential it presents, while a cloud IAM role defines the permissions it can assume. An NHI combines authentication with authorization. A secret is credential material, while the NHI represents the software actor that receives access.&lt;/p&gt;

&lt;h3&gt;
  
  
  Are non-human identities the same as machine identities?
&lt;/h3&gt;

&lt;p&gt;The terms overlap, and vendors disagree on the boundary. Machine identity often covers infrastructure, including virtual machines, containers, devices, certificates, and SSH keys, while NHI can also include tokens, scripts, and service accounts. Some IAM products use the terms interchangeably. Track both the software actor and its credentials, regardless of the classification a product uses.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is an API key a non-human identity?
&lt;/h3&gt;

&lt;p&gt;An API key is the authentication credential an NHI presents. The NHI is the application, workload, device, or agent that presents it. Some IAM products use NHI more broadly to include credentials themselves. That collapse hides the separate actor that needs ownership, scope, and revocation.&lt;/p&gt;

&lt;h3&gt;
  
  
  Are AI agents a type of NHI?
&lt;/h3&gt;

&lt;p&gt;Yes. An agent identity is a type of NHI. Agents can make dynamic decisions and act as a system or on behalf of a person, so Entra Agent ID treats them differently from conventional workload identities. An agent needs per-tool authorization and, when a person drives it, a delegation chain that records both the agent and the person behind the session.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why is a shared service account a problem for agents?
&lt;/h3&gt;

&lt;p&gt;A shared account weakens attribution, least privilege, offboarding, and session control. The audit attributes every action to the service account, so it cannot show who issued a refund. The key is granted the union of every task on the team, so &lt;code&gt;get_invoice&lt;/code&gt; and &lt;code&gt;create_refund&lt;/code&gt; share a principal. There is no HR offboarding event for a config file, which is why NHI1:2025 covers improper offboarding. Privileged access management can vault the secret and broker access, but a shared token still collapses identity at the MCP tool boundary unless it links each action to its upstream caller.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can non-human identities use MFA or SSO?
&lt;/h3&gt;

&lt;p&gt;Non-human identities authenticate noninteractively with passwords, certificates, mutual TLS (mTLS), workload identity federation, or short-lived tokens. Prefer short-lived mechanisms to standing secrets. For delegated-user authority, the person signs in through the identity provider and the session records their identity. For service or workload authority, the agent uses a dedicated identity with a human sponsor. Attendance does not decide the authority model.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the OWASP NHI Top 10?
&lt;/h3&gt;

&lt;p&gt;The OWASP Non-Human Identities Top 10 for 2025 is a ranked list of risks involving service accounts, keys, tokens, and the software that holds them. It covers improper offboarding, secret leakage, vulnerable third-party NHIs, insecure authentication, overprivileged NHIs, insecure cloud deployments, long-lived secrets, environment isolation, NHI reuse, and human use of NHIs. It is the counterpart to the OWASP Top 10 for application security.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does Speakeasy handle NHI for agents?
&lt;/h3&gt;

&lt;p&gt;The Speakeasy AI Control Plane uses the organization's existing identity provider as the source of identity, then evaluates policy in the path of every MCP tool call. Agents using delegated-user authority authenticate as the person through Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or another SAML or OIDC provider. Policy is evaluated per server, tool, and disposition. Telemetry records the directory identity, and authorization-challenge logging can record allow-or-deny decisions when the organization enables it.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is agent identity?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 11:00:56 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-agent-identity-50pf</link>
      <guid>https://dev.to/speakeasy/what-is-agent-identity-50pf</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/agent-identity" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Agent identity
&lt;/h2&gt;

&lt;p&gt;Agent identity is the binding of every AI agent session to a real principal in&lt;br&gt;
the organization's directory, the person driving it, or a dedicated identity&lt;br&gt;
with a named human owner. The session authenticates through the identity&lt;br&gt;
provider, every tool call is authorized against that principal's grants, and&lt;br&gt;
every allow or deny is recorded under a name.&lt;/p&gt;

&lt;p&gt;Three parts of the definition are load-bearing:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The binding runs to the directory.&lt;/strong&gt; The principal behind an agent is typically one the organization already manages, audits, and offboards.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Authorization happens per tool call.&lt;/strong&gt; An agent connected to a &lt;a href="https://modelcontextprotocol.io" rel="noopener noreferrer"&gt;Model Context Protocol (MCP)&lt;/a&gt; server is checked again each time it reaches for &lt;code&gt;create_refund&lt;/code&gt;, rather than once at connection.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The record carries a name.&lt;/strong&gt; When security asks who did something, the answer is a person, or an agent whose owner is a person, rather than a token id.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/agent-auth" rel="noopener noreferrer"&gt;Agent auth&lt;/a&gt; is the mechanism beneath this model. Identity says which principal the session binds to; agent auth says how the agent proves that binding and receives a grant on each resource request. The correct binding depends on whether the agent is &lt;a href="https://www.speakeasy.com/resources/user-steered-agents" rel="noopener noreferrer"&gt;user-steered&lt;/a&gt; or runs as a &lt;a href="https://www.speakeasy.com/resources/background-agents" rel="noopener noreferrer"&gt;background agent&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why does a shared service account fail for AI agent identity?
&lt;/h2&gt;

&lt;p&gt;The common first rollout is a bot token in the MCP config, shared by every agent on the team. Three controls that already work for people stop working at that moment:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Attribution.&lt;/strong&gt; The audit reads as the service account. After an agent issues a refund, "the billing bot did it" is usually the only available answer, and it names no one.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Least privilege.&lt;/strong&gt; The key is granted the union of every task on the team, so &lt;code&gt;get_invoice&lt;/code&gt; and &lt;code&gt;create_refund&lt;/code&gt; travel on one credential and per-tool policy has no principal to attach to.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Lifecycle.&lt;/strong&gt; People leave and keys do not. No directory event ends a config file's access, because the key was never bound to a person.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;These are the standard non-human identity failure modes applied to a caller that decides its next action at runtime. The catalog of what breaks, including the OWASP ranking of each failure, is in &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;what is NHI&lt;/a&gt;. The full authorization path from an identity provider to a single tool call, with the policy grammar and the audit record, is in &lt;a href="https://www.speakeasy.com/blog/governing-agent-actions-with-enterprise-identity" rel="noopener noreferrer"&gt;From your IdP to a tool call&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What does agent identity bind together in a composite identity?
&lt;/h2&gt;

&lt;p&gt;A session under agent identity resolves to a composite identity with four parts:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The principal&lt;/strong&gt;, as a person's directory identity for delegated-user authority, or a dedicated agent identity with a named human owner for service or workload authority.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The agent workload&lt;/strong&gt;, so the same person driving two different agents produces two distinguishable actors.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The client&lt;/strong&gt;, whether Claude, Cursor, or a custom harness.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The task&lt;/strong&gt;, so the session's authority is scoped to the work at hand rather than to everything the person could ever do.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The composite is what makes the audit record complete, this person, through this agent, in this client, for this task. How the four parts compose, and why each one matters on its own, is the subject of &lt;a href="https://www.speakeasy.com/resources/agent-composite-identity" rel="noopener noreferrer"&gt;agent composite identity&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/agent-identity#what-does-agent-identity-bind-together-in-a-composite-identity" rel="noopener noreferrer"&gt;View the composite identity diagram on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Credentials follow the same shape. The agent never holds a raw secret for an upstream system. It presents a short-lived credential minted for the task, bound to the identity, and expiring when the task completes, which is covered in &lt;a href="https://www.speakeasy.com/resources/task-scoped-credentials" rel="noopener noreferrer"&gt;task-scoped credentials&lt;/a&gt;. The session itself authenticates over OAuth 2.1 with PKCE and dynamic client registration, so modern agent clients complete the flow without custom integration.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does agent identity differ from non-human identity (NHI)?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;Non-human identity (NHI)&lt;/a&gt; is the category of digital identities that authenticate and are authorized on behalf of software, covering service accounts, workloads, pipelines, bots, and AI agents. An agent is an NHI, and the vendors who define the category, among them Okta and Oasis, now include AI agents in it alongside service accounts and tokens.&lt;/p&gt;

&lt;p&gt;Agent identity is the practice the agent class requires within that category. A service account typically runs a job someone defined in advance. An agent chooses its next call at runtime, and that difference makes the binding more consequential. The &lt;a href="https://www.speakeasy.com/resources/agent-types" rel="noopener noreferrer"&gt;four agent working arrangements&lt;/a&gt; describe accountability and engagement, while authority is a separate dimension. An agent identity must resolve to the principal behind each action: a person for delegated-user authority, a dedicated identity with a named human owner for service or workload authority, or the applicable principal at each step of a hybrid run. &lt;a href="https://www.speakeasy.com/resources/extend-iam-to-agents" rel="noopener noreferrer"&gt;Extending IAM to agents&lt;/a&gt; covers that binding and the harder question of whose permissions a custom agent built by one person and triggered by another should use.&lt;/p&gt;

&lt;h2&gt;
  
  
  What happens to AI agent access when a person is deprovisioned?
&lt;/h2&gt;

&lt;p&gt;Under agent identity, offboarding can end agent access through the same directory event that ends everything else. Directory Sync keeps users, groups, and attributes current from the identity provider, so when a person is deprovisioned, every agent session bound to their identity loses access on the same event that disables their login. Where the binding holds, there is no separate list of agent keys to find, because the agent never held a standing key of its own.&lt;/p&gt;

&lt;p&gt;Two registers make that binding checkable rather than assumed. The &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; records each agent, the identities it uses, and its human owner of record. That field can surface an organization agent using service or workload authority whose owner has left, so the identity can be reassigned or revoked. &lt;a href="https://www.speakeasy.com/resources/agent-discovery" rel="noopener noreferrer"&gt;Agent discovery&lt;/a&gt; finds the agents that never got an identity at all, the population described in &lt;a href="https://www.speakeasy.com/resources/shadow-ai" rel="noopener noreferrer"&gt;what is shadow AI&lt;/a&gt;, so they can be brought under the same binding instead of running outside it.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does the Speakeasy AI Control Plane implement AI agent identity management?
&lt;/h2&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt; ships the binding described above as one system, on the path agents already take to tools:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Sessions authenticate through the identity provider the organization runs&lt;/strong&gt;, whether Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or most SAML or OIDC providers, over OAuth 2.1 with PKCE and dynamic client registration.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The platform holds the identity, never the secret.&lt;/strong&gt; It records the agent's name, its owner, its grants, and a rule saying that an assertion from a trusted issuer is that agent. It holds no secret for the agent and cannot reissue one.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every tool call is authorized against the principal's grants.&lt;/strong&gt; Agents reach tools through the platform's &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;, so the check fires on the call, and every allow or deny is recorded under a name from the directory.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Task-scoped credentials are minted per task.&lt;/strong&gt; Short-lived, identity-bound, and expired when the task completes, so deprovisioning a person in the identity provider ends their agents' access with them.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Together, these controls replace the shared service account with AI agent identity management the organization can actually audit. The commercial page, with the identity model and the attestation classes behind it, is &lt;a href="https://www.speakeasy.com/product/agent-identity" rel="noopener noreferrer"&gt;agent identity&lt;/a&gt;. To see a session resolve to a name from your own directory, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is agent identity?
&lt;/h3&gt;

&lt;p&gt;Agent identity is the binding of every AI agent session to a real principal in the organization's directory, the person driving it, or a dedicated identity with a named human owner. The session authenticates through the identity provider, every tool call is authorized against that principal's grants, and every allow or deny is recorded under a name. It replaces the shared service account, which gives every agent one key and leaves no trail.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why is a shared service account a problem for AI agent identity?
&lt;/h3&gt;

&lt;p&gt;A shared service account is one key presented by every agent on the team, so three controls fail at once. The audit attributes every action to the account, and it is usually impossible to say which person issued a refund. The key carries the union of every task on the team, so read-only and destructive tools travel on one credential. And when a person leaves, nothing in the directory ends the key's access, because the key was never bound to them.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is a composite identity for an AI agent?
&lt;/h3&gt;

&lt;p&gt;A composite identity binds four things into one session, the person from the directory, the agent workload, the client it runs in, and the task at hand. Authorization then has a complete answer to who is acting, this person, through this agent, in this client, for this task. Each tool call is evaluated against the person's grants rather than against a standing machine credential.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does agent identity differ from non-human identity (NHI)?
&lt;/h3&gt;

&lt;p&gt;Non-human identity (NHI) is the category of identities for software, such as service accounts, workloads, pipelines, bots, and AI agents. Agent identity is the practice of binding the agent class of NHI to a directory principal. An agent chooses its next call at runtime and usually acts on a person's behalf, so its identity has to resolve to that person, or to a dedicated identity with a named human owner, rather than to a standing machine credential that answers for the whole team.&lt;/p&gt;

&lt;h3&gt;
  
  
  What happens to an agent's access when its owner is deprovisioned?
&lt;/h3&gt;

&lt;p&gt;Under agent identity, delegated access ends with the person's directory account. Directory Sync keeps users, groups, and attributes current from the identity provider, so deprovisioning ends sessions bound to that identity. An organization agent using service or workload authority is reassigned or revoked through its owner of record rather than left running under a departed sponsor.&lt;/p&gt;

&lt;h3&gt;
  
  
  What are task-scoped credentials?
&lt;/h3&gt;

&lt;p&gt;Task-scoped credentials are short-lived credentials minted for one task and bound to the identity behind the session. The agent never sees the raw secret for an upstream system. It presents the scoped credential, which expires when the task completes, so there is no long-lived token to leak or reuse. Combined with per-call authorization, the credential is only ever as broad as the principal's grants and only ever as long as the work.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does the Speakeasy AI Control Plane implement AI agent identity management?
&lt;/h3&gt;

&lt;p&gt;Sessions authenticate through the identity provider the organization already runs, whether Okta, Microsoft Entra ID, Auth0, WorkOS, Google Workspace, Ping Identity, or most SAML or OIDC providers, using OAuth 2.1 with PKCE and dynamic client registration. The platform holds the agent's name, its owner, its grants, and a rule that an assertion from a trusted issuer is that agent. It holds no secret for the agent and cannot reissue one. Every tool call is authorized against the principal's grants, and every allow or deny is recorded under a name.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is MCP governance?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Tue, 17 Nov 2026 09:54:03 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-mcp-governance-42i2</link>
      <guid>https://dev.to/speakeasy/what-is-mcp-governance-42i2</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/mcp-governance" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP governance
&lt;/h2&gt;

&lt;p&gt;MCP governance is the process of managing the Model Context Protocol (MCP)&lt;br&gt;
servers an organization's AI agents connect to as owned assets with a&lt;br&gt;
lifecycle. Each server is discovered, reviewed, promoted into an approved&lt;br&gt;
registry, distributed by role, monitored through a tool-call audit log, and&lt;br&gt;
updated or retired, and every stage writes to one MCP inventory.&lt;/p&gt;

&lt;p&gt;Agents connected to the tools a company uses are infinitely more useful than agents without any access. Consequently, MCP sprawl and &lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;shadow MCP&lt;/a&gt; are becoming problems at every company with serious AI use. Adoption has been outpacing governance. And yet, as AI use has grown, and agents have become increasingly independent, it's become clear that the MCP servers agents use need to be managed the same way as any software product the company licenses.&lt;/p&gt;

&lt;p&gt;IT and security teams are now catching up and putting together comprehensive MCP governance programs that treat each server as an asset with a lifecycle. Every server, sanctioned or not, gets an owner, a recorded approval decision, distribution to the users (agents) that need it, a log of what it is doing, and a point at which it is re-reviewed or retired. Collectively, the managed servers form the company's &lt;a href="https://www.speakeasy.com/resources/mcp-inventory" rel="noopener noreferrer"&gt;MCP inventory&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  The six stages of the MCP server lifecycle
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Discover.&lt;/strong&gt; Find the MCP servers agents already call, including &lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;shadow MCP&lt;/a&gt; servers nobody approved, and record each one in an &lt;a href="https://www.speakeasy.com/resources/mcp-inventory" rel="noopener noreferrer"&gt;MCP inventory&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Review and approve.&lt;/strong&gt; Give each server an owner, gather evidence about what it can do and what it asks for, and record a decision.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Promote.&lt;/strong&gt; Move approved servers into the &lt;a href="https://www.speakeasy.com/resources/mcp-registry" rel="noopener noreferrer"&gt;approved registry&lt;/a&gt;, with authentication and permitted tools configured once for everyone.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Distribute.&lt;/strong&gt; Provision servers to the roles that need them, from identity provider groups, instead of per-laptop config edits.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Monitor.&lt;/strong&gt; Record every tool call in an audit log tied to the user, agent, server, and tool.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Update or retire.&lt;/strong&gt; Re-review servers whose scopes or tools change, and revoke servers that go unused, lose their owner, or fail review.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  What happens at each stage of the MCP server lifecycle?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/mcp-governance#what-happens-at-each-stage-of-the-mcp-server-lifecycle" rel="noopener noreferrer"&gt;View the MCP server lifecycle diagram on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Each stage has an output, an owner, and a common way it fails. The stages below are listed in the order a new server moves through them.&lt;/p&gt;

&lt;h3&gt;
  
  
  Discover: find the servers agents already use
&lt;/h3&gt;

&lt;p&gt;Discovery compares the servers agents are observed in production against the servers the organization has approved, and surfaces the gaps between the two. Non-approved servers are considered shadow MCP, and the team that maintains the inventory needs to evaluate each server on an individual basis.&lt;/p&gt;

&lt;p&gt;One of the challenges of discovery is that, by definition, these servers fall outside the approved path. That can make detection difficult. Some companies rely on network telemetry to catch remote MCP traffic. A better option is agent-side hooks that check which MCP tools are being used within every agent session.&lt;/p&gt;

&lt;p&gt;Whatever the mechanism, the activity needs to be added to an immutable record in the &lt;a href="https://www.speakeasy.com/resources/mcp-inventory" rel="noopener noreferrer"&gt;MCP inventory&lt;/a&gt; for every server, sanctioned or not, with its URL or package, transport, credential type, users, and last-seen time. A common point of failure is treating discovery as a one-time scan, rather than ongoing monitoring.&lt;/p&gt;

&lt;h3&gt;
  
  
  Review and approve: assign an owner and record a decision
&lt;/h3&gt;

&lt;p&gt;Every discovered server needs someone to answer three questions: who operates it, how it is authenticated (OAuth scopes, secrets, headers), and what capabilities it enables, especially the ones that write or delete. The reviewer records a decision and its scope. An approval might cover one requester, one team, or the whole organization.&lt;/p&gt;

&lt;p&gt;The review should sit on the server's inventory record, with the evidence and rationale attached, so the next reviewer can see why a server was approved or denied. The common failure is review in chat threads or tickets that nobody can find six months later, which forces the same server through review twice.&lt;/p&gt;

&lt;h3&gt;
  
  
  Promote: move approved servers into the official registry
&lt;/h3&gt;

&lt;p&gt;Promotion turns an approved server into a supported one. The server gets an entry in the organization's &lt;a href="https://www.speakeasy.com/resources/mcp-registry" rel="noopener noreferrer"&gt;approved MCP registry&lt;/a&gt;, its authentication is configured once (OAuth on the user's own identity, or a managed credential stored centrally), and its tool list is curated so that destructive tools can be excluded or granted separately. If the server should only be reachable from inside the company network, this is where that exposure is set, as described in &lt;a href="https://www.speakeasy.com/resources/private-mcp-gateway" rel="noopener noreferrer"&gt;private MCP gateway&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Promotion is also how shadow MCP gets resolved without friction. If discovery shows that dozens of engineers have each wired up the same vendor server with their own personal access token, promoting that server replaces every one of those unmanaged credentials with one governed entry. The common failure is an approved registry that lags behind demand, which sends people back to wiring servers up themselves.&lt;/p&gt;

&lt;h3&gt;
  
  
  Distribute: provision servers by role
&lt;/h3&gt;

&lt;p&gt;Distribution decides who receives each promoted server and delivers it without a manual step per person. Roles map from identity provider groups to servers and tools, and a new hire in the right group gets the right servers on day one. Delivery happens through the gateway or a managed client configuration, rather than someone sending an &lt;code&gt;mcp.json&lt;/code&gt; snippet in a message.&lt;/p&gt;

&lt;p&gt;Role-based distribution depends on the identity provider's groups being accurate. If the groups do not reflect who does what, the distribution inherits the error, so the first role mapping usually turns into a review of the groups. The common failure is admins provisioning servers one request at a time, which platform teams we talk to name as their most acute problem with MCP today.&lt;/p&gt;

&lt;h3&gt;
  
  
  Monitor: audit every tool call
&lt;/h3&gt;

&lt;p&gt;Monitoring records every tool call with the user, the agent or client, the server, the tool, the decision the gateway made, and the time. That audit log answers the security team's questions after an incident, and it also answers the governance questions: which servers are used, by whom, and how often.&lt;/p&gt;

&lt;p&gt;Monitoring also feeds the loop. A server nobody has called in months is a retirement candidate. A new server appearing in client telemetry is a discovery finding. A spike in denied calls to one server is a request for access that nobody has filed yet.&lt;/p&gt;

&lt;h3&gt;
  
  
  Update or retire: re-review what changes, remove what is unused
&lt;/h3&gt;

&lt;p&gt;MCP servers change after approval. A vendor adds tools, requests broader OAuth scopes, or publishes an advisory. Re-review compares what a server asks for now with what it asked for when it was approved, and flags the difference for a new decision. Checking published evidence has a limit, because a server can change its behavior without changing its interface, so re-review narrows the risk rather than removing it.&lt;/p&gt;

&lt;p&gt;Retirement removes a server when it goes unused for the review period, loses its owner, is replaced, or fails re-review. Retiring a server means revoking its credential and removing it from every role. Deleting the registry entry alone leaves the credential live and the connection easy to restore.&lt;/p&gt;

&lt;h2&gt;
  
  
  What makes MCP governance a closed loop?
&lt;/h2&gt;

&lt;p&gt;A closed loop means the output of each stage is the input to another, with no step that depends on someone remembering to do it. In practice, three connections close it:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Blocked calls become review requests.&lt;/strong&gt; When an agent calls an unapproved server and the call is blocked, the user gets a way to request access from the same place, and the request lands on the server's inventory record for review.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Approvals become distribution.&lt;/strong&gt; A server approved for a team is provisioned to that team's role without a separate ticket to the platform team.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Usage becomes retirement and rediscovery.&lt;/strong&gt; The audit log sets each server's last-used date, and client telemetry keeps surfacing servers that are not in the registry.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The measure of the loop is the time between someone wanting a server and having it, provisioned by role and working. Platform teams we talk to name the same gap repeatedly: no inventory, no approval process, and no golden path, so every new server is a manual request. A loop that turns that request around quickly removes most of the reason to wire servers up outside the approved path. A loop that takes weeks produces shadow MCP.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why do most MCP gateways skip discovery?
&lt;/h2&gt;

&lt;p&gt;Most MCP gateways start at the approved registry. An administrator adds servers, the gateway enforces who can reach them, and the gateway logs what passes through it. That design assumes the organization already knows which servers exist, which is the assumption discovery exists to test.&lt;/p&gt;

&lt;p&gt;A gateway only sees its own traffic, so it cannot see a server that bypasses it. Discovery needs a sensor where agents run (hooks inside the coding agent, a device agent pushed through mobile device management, or a scan of client configuration files) or on the network. Few gateways ship that sensor as part of the same product, and the ones that do differ in which clients they cover.&lt;/p&gt;

&lt;p&gt;For MCP governance, this means checking whether a gateway covers the first stage, and if it does not, deciding what will. A registry and gateway without discovery govern the servers that were going to be well-behaved anyway.&lt;/p&gt;

&lt;h2&gt;
  
  
  Who owns MCP governance?
&lt;/h2&gt;

&lt;p&gt;Ownership splits across three groups, and the split works best when it is written down:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Role&lt;/th&gt;
&lt;th&gt;Owns&lt;/th&gt;
&lt;th&gt;Typical team&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Program owner&lt;/td&gt;
&lt;td&gt;The inventory, the approved registry, distribution by role, and the loop's turnaround time&lt;/td&gt;
&lt;td&gt;Platform engineering, IT, or AI enablement&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Review authority&lt;/td&gt;
&lt;td&gt;The approval criteria, the decision on high-risk servers, and enforcement policy&lt;/td&gt;
&lt;td&gt;Security&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Server owner&lt;/td&gt;
&lt;td&gt;One server's configuration, credential, re-review, and retirement&lt;/td&gt;
&lt;td&gt;The team that requested or built it&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The program owner needs to be the platform or IT team, because the loop is mostly a provisioning and inventory problem. Security teams set the review criteria and make the calls on servers with write access to sensitive systems. When security owns the whole program, the loop tends to optimize for denial, and the turnaround time that keeps shadow MCP down stops being anyone's metric. At enterprise size each stage becomes a queue with its own owner, and the &lt;a href="https://www.speakeasy.com/resources/enterprise-mcp-gateway" rel="noopener noreferrer"&gt;enterprise MCP gateway&lt;/a&gt; page works through what a slow promotion queue costs.&lt;/p&gt;

&lt;h2&gt;
  
  
  How do you start an MCP governance program?
&lt;/h2&gt;

&lt;p&gt;Start in the order of the lifecycle, and turn on enforcement last:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Run discovery in observe-only mode.&lt;/strong&gt; Record every server agents call without blocking anything, long enough to see the servers teams use weekly as well as daily.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Triage by exposure.&lt;/strong&gt; Sort the inventory by number of users and by whether the server can write, and review from the top.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Promote the most-used servers first.&lt;/strong&gt; Replacing the servers most people already use removes the most unmanaged credentials per review.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Map roles from the identity provider.&lt;/strong&gt; Start with a few broad roles and narrow them as usage data comes in.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Turn on blocking with a request path.&lt;/strong&gt; Block unapproved servers only once a blocked user can request access from the block itself.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Set a re-review and retirement schedule.&lt;/strong&gt; Decide the idle period after which a server is reviewed for retirement, and who reviews it.&lt;/li&gt;
&lt;/ol&gt;

&lt;h2&gt;
  
  
  Which tools support MCP governance?
&lt;/h2&gt;

&lt;p&gt;The tools below are listed by how much of the lifecycle they cover. Each entry describes only what the vendor documents.&lt;/p&gt;

&lt;h3&gt;
  
  
  Speakeasy
&lt;/h3&gt;

&lt;p&gt;The &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt; runs the full MCP governance loop on one &lt;a href="https://www.speakeasy.com/product/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Discover.&lt;/strong&gt; &lt;a href="https://www.speakeasy.com/blog/release-shadow-mcp-detection" rel="noopener noreferrer"&gt;Shadow MCP detection&lt;/a&gt; classifies every MCP tool call in an instrumented agent session and flags calls to servers outside the platform, including third-party URLs and local &lt;code&gt;stdio&lt;/code&gt; servers. Findings land in a &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/secure/shadow-mcp" rel="noopener noreferrer"&gt;shadow MCP inventory&lt;/a&gt; with last-called and last-seen times, and a flagging policy builds that inventory before any blocking starts.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Review and approve.&lt;/strong&gt; Each discovered server has an &lt;a href="https://www.speakeasy.com/blog/release-mcp-risk-approval" rel="noopener noreferrer"&gt;access review&lt;/a&gt; with automatically gathered evidence on its publisher, requested scopes, and tools. A blocked user gets a request link, and a reviewer approves or denies with a scope of one person, a team, or a project, with the rationale recorded.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Promote.&lt;/strong&gt; Servers enter the gateway by generation from an OpenAPI document, by adding a vendor server by URL, or by importing from a &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/catalog" rel="noopener noreferrer"&gt;catalog&lt;/a&gt; powered by the official MCP Registry, with authentication and tool curation configured per server.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Distribute.&lt;/strong&gt; &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/org-admin/roles-and-permissions" rel="noopener noreferrer"&gt;Roles and permissions&lt;/a&gt; grant access down to individual servers and tools, and roles can be assigned from the identity provider through directory sync. &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/plugins" rel="noopener noreferrer"&gt;Plugins&lt;/a&gt; bundle servers and skills and assign them to roles.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Monitor.&lt;/strong&gt; &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/observe/tool-logs" rel="noopener noreferrer"&gt;Tool logs&lt;/a&gt; record every call on the gateway, including shadow MCP calls.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Update or retire.&lt;/strong&gt; A daily check re-gathers evidence for approved servers and flags changes in OAuth scopes, credentials, or advisories for a new decision.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two limits apply. Discovery depends on agent sessions being instrumented, so a client without the device agent or hooks produces no findings. Plugin role assignments gate delivery only through the device agent today, so a plugin installed from a client's marketplace is available to anyone with access to that marketplace.&lt;/p&gt;

&lt;h3&gt;
  
  
  Open-source gateways
&lt;/h3&gt;

&lt;p&gt;Microsoft MCP Gateway is an open-source reverse proxy and management layer for MCP servers running on Kubernetes, with Azure identity and monitoring integrations. IBM ContextForge is an open-source gateway and registry that federates MCP servers and REST services behind one endpoint. Both start from servers an administrator registers. ContextForge's "auto-discovery" refers to gateways finding each other on a network, which is a different meaning from discovering shadow MCP.&lt;/p&gt;

&lt;h3&gt;
  
  
  Commercial vendors
&lt;/h3&gt;

&lt;p&gt;Other commercial vendors building MCP gateways, registries, or MCP discovery include Runlayer, Mintive (formerly MintMCP), Kong, Docker MCP Gateway, Obot, Lasso, and Bifrost.&lt;/p&gt;

&lt;p&gt;If you're setting up the approval and provisioning loop for MCP servers your teams already use, we'd be interested to hear where it breaks down for you. &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;Talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is MCP governance?
&lt;/h3&gt;

&lt;p&gt;MCP governance is the process of managing the Model Context Protocol (MCP) servers an organization's AI agents connect to as owned assets with a lifecycle. Each server is discovered, reviewed, promoted into an approved registry, distributed by role, monitored through a tool-call audit log, and updated or retired, and every stage writes to one MCP inventory. The goal is a repeatable process that runs every week, rather than a cleanup project that is stale a month after it finishes.&lt;/p&gt;

&lt;h3&gt;
  
  
  What are the stages of the MCP server lifecycle?
&lt;/h3&gt;

&lt;p&gt;The MCP server lifecycle has six stages. Discover finds the MCP servers agents already use, including shadow MCP. Review and approve assigns an owner and records a decision. Promote adds approved servers to the approved registry. Distribute provisions them to the roles that need them. Monitor records every tool call in an audit log. Update or retire re-reviews servers that change and removes ones that are no longer needed or no longer safe.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why does MCP governance start with inventory rather than security?
&lt;/h3&gt;

&lt;p&gt;Because an organization cannot secure an MCP server it has not found. Allowlists, data loss prevention, and tool-level permissions apply only to traffic that passes through the point enforcing them, and an MCP server wired into a local mcp.json file never touches that point. Discovery and an MCP inventory come first so that every later control has a complete list of servers to act on, and a review workflow comes next so that blocking an unapproved server gives the user a path to an approved one.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is MCP governance different from MCP security?
&lt;/h3&gt;

&lt;p&gt;MCP security is the set of runtime controls on an MCP connection: authentication, tool allowlists, logging, and inspection at the tool boundary. MCP governance is the process that decides which servers those controls apply to, who owns each one, which roles receive it, and when it is retired. Security controls without governance are enforced against an incomplete list of servers, and governance without security controls is a register nobody enforces.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is MCP governance different from agent governance and AI governance?
&lt;/h3&gt;

&lt;p&gt;AI governance covers how an organization controls what AI tools may see, do, and decide. Agent governance narrows that to the agents themselves: which agents exist, what identity they act under, and what each may reach. MCP governance narrows further to the MCP servers agents connect to, managing each server through a lifecycle from discovery to retirement. The three nest inside each other, and an MCP governance process feeds the tool side of an agent governance program.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is MCP lifecycle management the same as the MCP protocol lifecycle?
&lt;/h3&gt;

&lt;p&gt;No. The MCP specification defines a connection lifecycle with three phases, initialization, operation, and shutdown, which covers a single session between a client and a server. MCP lifecycle management, the core of MCP governance, covers an MCP server as an organizational asset over months: discovery, approval, promotion to an approved registry, distribution by role, monitoring, and retirement.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is MCP server management?
&lt;/h3&gt;

&lt;p&gt;MCP server management usually means the operational work of running MCP servers: adding them, configuring authentication, curating their tools, and deciding who can connect. MCP governance is the process that work sits inside, covering how a server is found, approved, promoted, distributed by role, monitored, and retired, with every decision recorded in an MCP inventory.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does shadow MCP fit into MCP governance?
&lt;/h3&gt;

&lt;p&gt;Shadow MCP is an MCP server employees connect to without approval, and finding it is the discover stage of MCP governance. Each shadow MCP finding becomes an MCP inventory record with an owner and a disposition. The reviewer then approves it, promotes a reviewed alternative into the approved registry, or blocks it and rotates the credential it used.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is an approved MCP registry?
&lt;/h3&gt;

&lt;p&gt;An approved MCP registry is the organization's catalog of MCP servers that have passed review, with an owner, a configured authentication method, and a set of permitted tools for each. In MCP governance, promotion is the step that moves a reviewed server into the approved registry. Pairing the registry with an MCP gateway makes approval binding, because the gateway enforces which servers and tools each caller may use.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do you distribute MCP servers by role?
&lt;/h3&gt;

&lt;p&gt;Map roles from the identity provider's groups to the MCP servers and tools each role needs, then provision servers to users through the gateway or a managed client configuration instead of per-laptop mcp.json edits. Role-based distribution depends on accurate groups. If the identity provider's groups do not reflect who does what, MCP governance inherits that error, so the first role mapping is usually a review of the groups themselves.&lt;/p&gt;

&lt;h3&gt;
  
  
  What should an MCP audit log record?
&lt;/h3&gt;

&lt;p&gt;An MCP audit log should record, for every tool call, the user, the agent or client, the MCP server, the tool, the decision the gateway made, and the time. For MCP governance, the audit log also supplies the last-used date for each server, which is the signal that decides when a server should be re-reviewed or retired.&lt;/p&gt;

&lt;h3&gt;
  
  
  When should an MCP server be retired?
&lt;/h3&gt;

&lt;p&gt;Retire an MCP server when nobody has called it for a review period the organization sets, when its owner leaves without a successor, when a vendor replaces it, or when re-review finds that its OAuth scopes, credentials, or published advisories have changed in a way the reviewer will not accept. Retirement should revoke the credential and remove the server from every role, not only delete the registry entry.&lt;/p&gt;

&lt;h3&gt;
  
  
  Do MCP gateways handle shadow MCP discovery?
&lt;/h3&gt;

&lt;p&gt;Most MCP gateways start at the approved registry and govern only the traffic routed through them, so they assume the organization already knows which MCP servers exist. Few gateways also discover the servers employees have wired up on their own, which requires a signal from the endpoint or the network rather than from the gateway's own traffic. MCP governance needs both halves, whether from one product or two.&lt;/p&gt;

&lt;h3&gt;
  
  
  Which tools support MCP governance?
&lt;/h3&gt;

&lt;p&gt;Speakeasy covers the full MCP governance loop on one platform, from shadow MCP discovery through an approved registry, role-based access, and a tool-call audit log. Open-source gateways such as Microsoft MCP Gateway and IBM ContextForge cover registration and routing for servers an organization already knows about. Commercial vendors in the space include Runlayer, Mintive, Kong, Docker MCP Gateway, Obot, Lasso, and Bifrost.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is an MCP inventory?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Mon, 16 Nov 2026 09:12:34 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-an-mcp-inventory-1e2d</link>
      <guid>https://dev.to/speakeasy/what-is-an-mcp-inventory-1e2d</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/mcp-inventory" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP inventory
&lt;/h2&gt;

&lt;p&gt;An MCP inventory is a continuously updated record of every Model Context&lt;br&gt;
Protocol server in an organization: the tools each server exposes, the&lt;br&gt;
credentials it authenticates with, who owns it, which agents may call it, and&lt;br&gt;
whether it is sanctioned. It records servers and tools. An agent inventory&lt;br&gt;
records the agents that call them.&lt;/p&gt;

&lt;p&gt;An endpoint scan of an engineer's laptop may list Cursor on the software register, while the same machine has a GitHub Model Context Protocol (MCP) server configured in &lt;code&gt;~/.cursor/mcp.json&lt;/code&gt;. That server can authenticate with a personal access token that reads and writes every repository the engineer can. The software register records the client, while an MCP inventory records the server, its tools, and the credential behind its access.&lt;/p&gt;

&lt;p&gt;The public &lt;a href="https://www.speakeasy.com/resources/mcp-registry" rel="noopener noreferrer"&gt;MCP Registry&lt;/a&gt; serves a different purpose. It shows which servers are available to install, while an MCP inventory records server identity, connected agents, exposed tools, authentication state, and sanctioned status in one organization. Security teams need that record to govern the servers and tools their agents call.&lt;/p&gt;

&lt;p&gt;This guide focuses on servers and tools. The &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; covers the agents that call them.&lt;/p&gt;

&lt;p&gt;Together, the two records make MCP security policies enforceable: a policy needs to know which servers exist, which tools they expose, and which agents can call them.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why can't a CMDB or the public MCP Registry serve as an MCP inventory?
&lt;/h2&gt;

&lt;p&gt;A &lt;a href="https://www.speakeasy.com/resources/agent-discovery" rel="noopener noreferrer"&gt;configuration management database (CMDB)&lt;/a&gt; and software asset inventory track installed software. An MCP server can be a few lines of JSON in a dotfile or a remote URL. A local stdio server tells an agent which package to execute, while a remote server appears as a runtime connection. Asset scans capture the editor. The servers, tools, and credentials it reaches remain outside the record. Our guide on &lt;a href="https://www.speakeasy.com/resources/shadow-ai" rel="noopener noreferrer"&gt;shadow AI&lt;/a&gt; covers the wider detection problem.&lt;/p&gt;

&lt;p&gt;The public MCP Registry is a catalog that vendors and open-source maintainers publish to so clients and aggregators can discover servers. An enterprise MCP inventory covers the servers that are actually running in one organization, including:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;Local stdio servers configured in dotfiles such as &lt;code&gt;~/.cursor/mcp.json&lt;/code&gt;
&lt;/li&gt;
&lt;li&gt;Remote servers reached by URL, hosted by SaaS vendors&lt;/li&gt;
&lt;li&gt;Internal servers the organization built or generated from its own APIs&lt;/li&gt;
&lt;li&gt;Hosted connectors bundled inside SaaS agent platforms&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The inventory records which candidates were approved, what each one authenticates with, and whether agents are actually calling it.&lt;/p&gt;

&lt;h2&gt;
  
  
  What belongs in an MCP inventory record?
&lt;/h2&gt;

&lt;p&gt;Each MCP inventory record needs the fields a security team will query when a credential leaks or a tool becomes destructive:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Server identity.&lt;/strong&gt; The URL for a remote server, or the package specifier and version for a local one. This identifier ties the record together across renames and vendor migrations.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Transport.&lt;/strong&gt; A stdio server runs as a child process on the endpoint, while a remote server is an HTTP endpoint elsewhere. Transport determines where the credential lives and which controls can observe the traffic.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tools and their disposition.&lt;/strong&gt; Every tool the server exposes, including whether it only reads or can create, modify, or delete data. A server whose tools are all read-only needs a different review from one exposing &lt;code&gt;create_refund&lt;/code&gt;. Tool lists can change over time, so this field needs a live feed.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Credential and auth method.&lt;/strong&gt; OAuth on the caller's own identity, a managed API key, or a personal access token in a dotfile. The record should name the identity the server presents upstream. A shared credential makes every caller appear as the same actor, the failure covered in &lt;a href="https://www.speakeasy.com/resources/non-human-identity" rel="noopener noreferrer"&gt;what is NHI&lt;/a&gt;.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Human owner of record.&lt;/strong&gt; The person who answers for the server, renews its review, and retires it. An owner field keeps review and retirement work assigned when teams change.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Connected agents.&lt;/strong&gt; Which agents and clients are allowed to call the server. This field links to the &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt;, and each agent record links back.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sanctioned status.&lt;/strong&gt; Whether the organization approved the server. Approved servers and discovered ones sit in the same register with different dispositions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Last seen.&lt;/strong&gt; When the server last served a call. A dormant server is a revocation candidate, while an active server without approval needs investigation.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  MCP inventory vs agent inventory vs shadow MCP: what's the difference?
&lt;/h2&gt;

&lt;p&gt;An MCP inventory answers &lt;strong&gt;which servers expose a destructive tool and what each one authenticates with.&lt;/strong&gt; An &lt;a href="https://www.speakeasy.com/resources/agent-inventory" rel="noopener noreferrer"&gt;agent inventory&lt;/a&gt; answers which agents can touch billing and who owns each one. The records link to each other: each server record identifies the agents that can call it, and each agent record identifies the servers it reaches.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/mcp-inventory#mcp-inventory-vs-agent-inventory-vs-shadow-mcp-whats-the-difference" rel="noopener noreferrer"&gt;View the MCP inventory relationship diagram on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;The diagram shows why the records need to link. The agent inventory answers who is acting. The MCP inventory answers what it can call and how that server authenticates. Together, they show the path from an agent to the systems and data it can reach.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;Shadow MCP&lt;/a&gt; means unsanctioned servers operating outside formal security governance. Discovery surfaces those servers one finding at a time. The MCP inventory turns each finding into a record with an owner and a disposition, alongside every approved server. &lt;a href="https://www.speakeasy.com/resources/shadow-ai" rel="noopener noreferrer"&gt;What is shadow AI&lt;/a&gt; explains endpoint discovery, &lt;a href="https://www.speakeasy.com/blog/release-mcp-risk-approval" rel="noopener noreferrer"&gt;MCP risk approval&lt;/a&gt; shows how a finding becomes a scoped decision, and &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;what is an MCP gateway&lt;/a&gt; explains enforcement in front of the servers.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does an MCP inventory stay current?
&lt;/h2&gt;

&lt;p&gt;A static MCP inventory ages quickly. A spreadsheet compiled for an audit is accurate on the day it is finished and describes last quarter by the time anyone reads it. Because wiring up a new server is a config-file edit, a register maintained by survey decays in weeks. Staying current requires two live feeds:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Discovery on the endpoint.&lt;/strong&gt; &lt;a href="https://www.speakeasy.com/resources/ai-agent-hooks" rel="noopener noreferrer"&gt;Agent hooks&lt;/a&gt; fire inside coding agents on every prompt and tool call. They can report the MCP servers a session is actually wired to, including servers that never passed review. The &lt;a href="https://www.speakeasy.com/resources/shadow-ai" rel="noopener noreferrer"&gt;shadow AI reference&lt;/a&gt; describes this architecture end to end.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The sanctioned path.&lt;/strong&gt; When agents reach tools through a gateway, every session and tool call passes a point that can record the server, tool, and caller. Traffic then keeps the sanctioned-server records and last-seen field current.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  How does an MCP inventory support MCP security?
&lt;/h2&gt;

&lt;p&gt;An MCP inventory makes an allow-or-block policy enforceable. A policy can block a call to a server with no record or a record marked unsanctioned. It also supports least privilege at tool granularity, allowing a policy to grant &lt;code&gt;get_invoice&lt;/code&gt; without granting &lt;code&gt;create_refund&lt;/code&gt;, one of the six controls in &lt;a href="https://www.speakeasy.com/resources/mcp-security" rel="noopener noreferrer"&gt;MCP security&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;When a server is compromised or &lt;a href="https://www.speakeasy.com/resources/mcp-tool-poisoning" rel="noopener noreferrer"&gt;rug-pulled&lt;/a&gt;, its record is where the organization revokes access. When an assessor asks which servers agents can reach and what each authenticates with, the inventory provides the evidence.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does the Speakeasy AI Control Plane keep the MCP inventory live?
&lt;/h2&gt;

&lt;p&gt;An organization can assemble this architecture from its existing systems. The &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt; provides it as one system and maintains the MCP inventory as servers are added and called:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The gateway is the register of sanctioned servers.&lt;/strong&gt; Servers enter the &lt;a href="https://www.speakeasy.com/product/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt; in three ways: generation from the OpenAPI documents the organization already has, adding an existing vendor server &lt;a href="https://www.speakeasy.com/blog/release-remote-mcp" rel="noopener noreferrer"&gt;remote by URL&lt;/a&gt;, or import from a &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/catalog" rel="noopener noreferrer"&gt;catalog&lt;/a&gt; powered by the official MCP Registry. The catalog identifies a candidate server. The gateway row, with its tools, credential, owner, and traffic, becomes the inventory record.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Shadow MCP detection fills the unsanctioned half.&lt;/strong&gt; &lt;a href="https://www.speakeasy.com/blog/release-shadow-mcp-detection" rel="noopener noreferrer"&gt;Shadow MCP detection&lt;/a&gt; recognizes, from instrumented agent traffic, when a session connects to a server outside the sanctioned setup, and surfaces it by URL, host, or resolved identity. Allow and deny rules then apply at runtime. If policy evaluation is unavailable, the organization's fail-open or fail-closed setting determines whether the call proceeds; explicit denials and invalid credentials still block.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Identity and credentials sit on the gateway.&lt;/strong&gt; Upstream auth is provisioned per server through one-click OAuth on the user's own identity, a managed credential stored once, or header pass-through. Each inventory row carries a named owner and a known auth method.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The MCP inventory is built from live traffic, so it stays useful between reviews. To see the inventory the platform maintains for the servers your agents already call, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is an MCP inventory?
&lt;/h3&gt;

&lt;p&gt;An MCP inventory is a continuously updated record of every Model Context Protocol server in an organization: the tools each server exposes, the credentials it authenticates with, who owns it, which agents may call it, and whether it is sanctioned. It records servers and tools, while an agent inventory records agents. Allowlists, tool-level least privilege, and audit evidence depend on it.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is the difference between an MCP inventory and an agent inventory?
&lt;/h3&gt;

&lt;p&gt;An MCP inventory records the MCP servers in use, the tools each one exposes, and the credentials behind it. An agent inventory records the agents themselves, the identity each runs as, and who owns it. The registers answer different questions and link to each other: a server record lists the agents allowed to call it, and an agent record lists the servers it connects to.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is the public MCP Registry an MCP inventory?
&lt;/h3&gt;

&lt;p&gt;The official MCP Registry at registry.modelcontextprotocol.io is a catalog of servers anyone can publish. An enterprise MCP inventory records the servers actually running in one organization: local stdio servers in dotfiles, remote vendor URLs, internal generated servers, and hosted connectors. The registry supplies candidates for the sanctioned list, while the inventory records which of them agents call.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does an MCP inventory relate to shadow MCP?
&lt;/h3&gt;

&lt;p&gt;Shadow MCP means unsanctioned servers operating outside formal security governance. Discovery surfaces those servers one finding at a time. The MCP inventory turns each finding into a record with an owner and a disposition, alongside every sanctioned server. Together, those records give the organization a tool-layer view.&lt;/p&gt;

&lt;h3&gt;
  
  
  What fields should an MCP inventory record capture?
&lt;/h3&gt;

&lt;p&gt;Each record should capture the server's identity (a URL for a remote server, a package specifier for a local one), its transport (stdio or remote), the tools it exposes with their read-only or destructive disposition, the credential it authenticates with and whose identity that credential carries, a human owner of record, the agents and clients allowed to connect, its sanctioned status, and when it was last seen serving a call.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does an MCP inventory stay current?
&lt;/h3&gt;

&lt;p&gt;A spreadsheet compiled for an audit describes last quarter by the time anyone reads it, because wiring up a new server is a config-file edit. A live inventory uses two feeds: hooks inside coding agents observe every server a session connects to, including unsanctioned ones, and a gateway on the sanctioned path records server and tool-call traffic. Together, they keep the last-seen field current.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is an MCP registry?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Mon, 16 Nov 2026 08:31:16 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-an-mcp-registry-3ida</link>
      <guid>https://dev.to/speakeasy/what-is-an-mcp-registry-3ida</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/mcp-registry" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP registry
&lt;/h2&gt;

&lt;p&gt;An MCP registry is a catalog of Model Context Protocol (MCP) server metadata.&lt;br&gt;
It names the server, its install location, and its connection method. The&lt;br&gt;
official registry lists publicly accessible servers. It does not record which&lt;br&gt;
servers your organization actually runs or accept private ones.&lt;/p&gt;

&lt;p&gt;An MCP registry supplies discovery metadata. It records what exists and, in its private form, what is approved to exist. It does not show what runs on employee laptops, which credentials those servers hold, or which agents call them. Those records belong to an &lt;a href="https://www.speakeasy.com/resources/mcp-inventory" rel="noopener noreferrer"&gt;MCP inventory&lt;/a&gt;, while enforcement belongs to an &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;. A registry, inventory, and gateway answer different security questions.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is an MCP registry?
&lt;/h2&gt;

&lt;p&gt;An MCP registry, also called an MCP server registry, stores metadata about MCP servers, and clients, marketplaces, and platform teams query it to discover them. The &lt;a href="https://modelcontextprotocol.io/registry/about" rel="noopener noreferrer"&gt;official registry documentation&lt;/a&gt; describes each entry as a standardized &lt;code&gt;server.json&lt;/code&gt; record containing the server's unique name in reverse-DNS format, such as &lt;code&gt;io.github.user/server-name&lt;/code&gt;, a pointer to where the server lives, such as an npm package name or a remote server URL, execution instructions such as command-line arguments and environment variables, and discovery data such as a description and capabilities.&lt;/p&gt;

&lt;p&gt;The registry hosts none of the code. Packages can stay on npm, PyPI, or Docker Hub, while remote servers can remain on the vendor's infrastructure. The registry entry points at them. Consumers read the catalog through a &lt;a href="https://modelcontextprotocol.io/registry/registry-aggregators" rel="noopener noreferrer"&gt;REST API&lt;/a&gt;, with &lt;code&gt;GET /v0.1/servers&lt;/code&gt; at &lt;code&gt;registry.modelcontextprotocol.io&lt;/code&gt; returning the full list for downstream systems to ingest.&lt;/p&gt;

&lt;h2&gt;
  
  
  Is there an official MCP registry?
&lt;/h2&gt;

&lt;p&gt;Yes. The official MCP Registry at &lt;a href="https://registry.modelcontextprotocol.io/" rel="noopener noreferrer"&gt;registry.modelcontextprotocol.io&lt;/a&gt; launched in &lt;a href="https://blog.modelcontextprotocol.io/posts/2025-09-08-mcp-registry-preview/" rel="noopener noreferrer"&gt;preview in September 2025&lt;/a&gt; as part of the MCP open-source project, backed by Anthropic, GitHub, PulseMCP, and Microsoft. It remains in preview as of its &lt;a href="https://modelcontextprotocol.io/registry/about" rel="noopener noreferrer"&gt;about page&lt;/a&gt;, which warns that breaking changes or data resets may occur before general availability, so treat any dependency on it as a dependency on a preview service.&lt;/p&gt;

&lt;p&gt;Its scope is narrower than the name suggests. The boundaries matter for anyone evaluating it as a governance control.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Namespace authentication does not verify server code.&lt;/strong&gt; Publishing under &lt;code&gt;io.github.*&lt;/code&gt; requires the matching GitHub account, and domain namespaces require DNS or HTTP verification. The registry performs no security scanning of server code. It &lt;a href="https://modelcontextprotocol.io/registry/about" rel="noopener noreferrer"&gt;delegates scanning&lt;/a&gt; to package registries and downstream aggregators, and its own moderation is limited to takedowns of spam and malicious entries.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Public servers only.&lt;/strong&gt; The registry &lt;a href="https://modelcontextprotocol.io/registry/about" rel="noopener noreferrer"&gt;does not support private servers&lt;/a&gt;, meaning anything on an internal hostname or a private package registry. The official recommendation for those is to host your own private MCP registry.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Not built for self-hosting.&lt;/strong&gt; The official codebase is not designed to be run internally, and the maintainers state they cannot support forks.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Aggregators are the intended readers.&lt;/strong&gt; The registry expects marketplaces and subregistries to consume its API and serve host applications, rather than host applications querying it directly, with the &lt;a href="https://modelcontextprotocol.io/registry/faq" rel="noopener noreferrer"&gt;OpenAPI spec&lt;/a&gt; as the shared interface.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What are the third-party MCP registries?
&lt;/h2&gt;

&lt;p&gt;Third-party MCP registries have multiplied since the official preview launched. The official project's &lt;a href="https://modelcontextprotocol.io/registry/faq" rel="noopener noreferrer"&gt;naming convention&lt;/a&gt; defines an "MCP registry" in lowercase as any third-party service implementing the MCP Registry API. For a CISO, sorting them into three kinds is more useful than enumerating them because each kind answers a different procurement question.&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Registry&lt;/th&gt;
&lt;th&gt;Kind&lt;/th&gt;
&lt;th&gt;What it is&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://github.blog/ai-and-ml/github-copilot/meet-the-github-mcp-registry-the-fastest-way-to-discover-mcp-servers/" rel="noopener noreferrer"&gt;GitHub MCP Registry&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Aggregator&lt;/td&gt;
&lt;td&gt;Curated directory launched September 2025 with one-click install into VS Code. GitHub is working with Anthropic and the MCP Steering Committee so servers published to the official registry flow into it.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://www.pulsemcp.com/" rel="noopener noreferrer"&gt;PulseMCP&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Aggregator&lt;/td&gt;
&lt;td&gt;Community server directory whose maintainer helped build the official registry and serves as one of its maintainers.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Azure API Center&lt;/td&gt;
&lt;td&gt;Cloud catalog&lt;/td&gt;
&lt;td&gt;Registers remote and local MCP servers as inventory assets and exposes them at a registry endpoint in the official &lt;code&gt;/v0.1/servers&lt;/code&gt; format.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://jfrog.com/ai-catalog/mcp-registry/" rel="noopener noreferrer"&gt;JFrog AI Catalog MCP Registry&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Cloud catalog&lt;/td&gt;
&lt;td&gt;Manages MCP servers as artifacts inside the JFrog platform, with policy-based blocking of unvetted servers and role-based access to tools.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Kong MCP Registry&lt;/td&gt;
&lt;td&gt;Enterprise product&lt;/td&gt;
&lt;td&gt;Registry entity inside Kong Konnect, in Tech Preview, paired with the Kong AI Gateway for runtime enforcement.&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;a href="https://portkey.ai/docs/product/mcp-gateway/mcp-registry" rel="noopener noreferrer"&gt;Portkey MCP Registry&lt;/a&gt;&lt;/td&gt;
&lt;td&gt;Enterprise product&lt;/td&gt;
&lt;td&gt;Central catalog of MCP server integrations inside the Portkey MCP gateway, with per-workspace access control and per-server authentication.&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;The evaluation question is which kind you are looking at. An aggregator improves discovery of public servers. A cloud catalog folds MCP servers into an inventory you already keep. An enterprise product adds governance to the same OpenAPI shape. Whichever kind you pick, the record of what is actually running on your endpoints still comes from an &lt;a href="https://www.speakeasy.com/resources/mcp-inventory" rel="noopener noreferrer"&gt;MCP inventory&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  What is a private or central MCP registry?
&lt;/h2&gt;

&lt;p&gt;A private MCP registry is the catalog an organization hosts for the servers the public one will not take. The official documentation &lt;a href="https://modelcontextprotocol.io/registry/about" rel="noopener noreferrer"&gt;recommends&lt;/a&gt; that servers on internal hostnames or private package registries be published to a private MCP registry the organization runs itself, implementing the same OpenAPI spec so existing clients and host applications can consume it without custom work.&lt;/p&gt;

&lt;p&gt;A central MCP registry is the organization-wide version of the same idea, and it is the phrase that matters in a security review. It identifies which servers employees may install, who owns each one, and which environments see them, instead of relying on per-developer &lt;code&gt;mcp.json&lt;/code&gt; files. The official preview announcement &lt;a href="https://blog.modelcontextprotocol.io/posts/2025-09-08-mcp-registry-preview/" rel="noopener noreferrer"&gt;describes this pattern&lt;/a&gt; for private subregistries inside enterprises that use the official registry as their upstream data source.&lt;/p&gt;

&lt;h3&gt;
  
  
  What a central MCP registry records
&lt;/h3&gt;

&lt;p&gt;A central registry records that a server is approved and who owns the approval, not which employees actually run it or whether an unapproved server has appeared. Filling that gap takes a continuously updated record of what's running, which is the job of an &lt;a href="https://www.speakeasy.com/resources/mcp-inventory" rel="noopener noreferrer"&gt;MCP inventory&lt;/a&gt;; the unsanctioned population it surfaces is &lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;shadow MCP&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  How is an MCP registry different from an MCP gateway?
&lt;/h2&gt;

&lt;p&gt;Once a client has an entry's connection details, the registry's job is done. Everything that happens on the tool-call path, identity checks, allowlists, audit logging, data controls, belongs to an &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;, the layer where &lt;a href="https://www.speakeasy.com/resources/mcp-security" rel="noopener noreferrer"&gt;MCP security&lt;/a&gt; controls actually execute.&lt;/p&gt;

&lt;h3&gt;
  
  
  When should an organization use an MCP registry and gateway together?
&lt;/h3&gt;

&lt;p&gt;Each works without the other, with predictable gaps:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A registry alone cannot block a call. An approved-server catalog without an enforcement point is a policy document.&lt;/li&gt;
&lt;li&gt;A gateway alone governs traffic when servers are added by URL. It does not provide discovery of public servers or a sanctioned catalog for employees to browse.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Together, the registry defines what is approved and the gateway makes that approval binding. That pairing explains why the enterprise products in the table include both.&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/mcp-registry#when-should-an-organization-use-an-mcp-registry-and-gateway-together" rel="noopener noreferrer"&gt;View the diagram separating discovery, runtime enforcement, and observation on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  How does Speakeasy use the official MCP Registry?
&lt;/h2&gt;

&lt;p&gt;The Speakeasy AI Control Plane uses the official MCP Registry as the source for its &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/catalog" rel="noopener noreferrer"&gt;catalog&lt;/a&gt;. The Catalog page, under Connect &amp;gt; Catalog in the dashboard, lets teams browse, search, and filter registry entries, then install the servers they approve into a project. Viewing requires the &lt;code&gt;project:read&lt;/code&gt; or &lt;code&gt;mcp:write&lt;/code&gt; scope and adding a server requires &lt;code&gt;mcp:write&lt;/code&gt;, so a Member can browse the catalog while installs stay with holders of the write scope, which the default Admin role includes.&lt;/p&gt;

&lt;p&gt;An install creates a &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/remote-servers" rel="noopener noreferrer"&gt;remote MCP server&lt;/a&gt; on the platform. The vendor keeps running the server. The platform registers its URL and proxies sessions to it, adding authentication, per-tool access control, and tool logs without copying or re-hosting the server. One catalog entry can create several servers when it publishes multiple remote endpoints. Only streamable HTTP endpoints are accepted, and entries marked Manual Setup require configuration outside the one-click path.&lt;/p&gt;

&lt;p&gt;The registry feed covers the sanctioned side only. Servers employees wire up on their own are surfaced by &lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;shadow MCP detection&lt;/a&gt;, which works from agent hooks and live traffic rather than from any registry, and both populations land in the &lt;a href="https://www.speakeasy.com/resources/mcp-inventory" rel="noopener noreferrer"&gt;MCP inventory&lt;/a&gt; the platform maintains. The official registry supplies the catalog of what exists, the platform turns the approved subset into a governed and auditable path, and the gateway and inventory cover what is actually running. To see the catalog and the inventory against your own estate, visit the &lt;a href="https://www.speakeasy.com/product/ai-control-plane" rel="noopener noreferrer"&gt;AI Control Plane&lt;/a&gt; or &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;Organization administrators can also search the catalog, register servers, and check readiness from an agent through the &lt;a href="https://www.speakeasy.com/blog/release-platform-mcp" rel="noopener noreferrer"&gt;Speakeasy Platform MCP&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is an MCP registry?
&lt;/h3&gt;

&lt;p&gt;An MCP registry is a catalog of Model Context Protocol (MCP) server metadata. It names the server, its install location, and its connection method. The official registry lists publicly accessible servers. It does not record which servers your organization actually runs or accept private ones. Each entry points at the package registry or remote endpoint where the server lives. A registry answers what exists and how to install it. An inventory records what is currently running.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is there an official MCP registry?
&lt;/h3&gt;

&lt;p&gt;Yes. The official MCP Registry at registry.modelcontextprotocol.io launched in preview in September 2025 and is backed by Anthropic, GitHub, PulseMCP, and Microsoft. It is still in preview as of its documentation, which warns that breaking changes or data resets may occur before general availability. It authenticates namespaces, hosts metadata in a standardized server.json format, and delegates security scanning of server code to package registries and downstream aggregators.&lt;/p&gt;

&lt;h3&gt;
  
  
  What are the third-party MCP registries?
&lt;/h3&gt;

&lt;p&gt;Third-party MCP registries group into three kinds. Aggregators and marketplaces such as the GitHub MCP Registry and PulseMCP consume the official registry's API and add curation, ratings, and one-click installs. Cloud and vendor catalogs such as Azure API Center and the JFrog AI Catalog MCP Registry inventory MCP servers inside a platform the organization already runs. Enterprise registry products such as the Kong MCP Registry, in Tech Preview, and the Portkey MCP Registry implement the same OpenAPI shape and add access control and governance on top.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is a private or central MCP registry?
&lt;/h3&gt;

&lt;p&gt;A private MCP registry is a catalog one organization hosts for servers the official registry does not accept. Internal hostnames and private package registries stay out of the public catalog by design. The official documentation recommends hosting a registry that implements the same OpenAPI spec so clients can consume it. A central MCP registry is the organization-wide version of the same idea. It records which servers employees may install, who owns each one, and which environments see them instead of leaving the information in individual mcp.json files. Both are catalogs of metadata rather than live inventories of what is running.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is an MCP registry different from an MCP gateway?
&lt;/h3&gt;

&lt;p&gt;A registry handles discovery. It records server metadata, install targets, and namespaces outside the tool-call path. An MCP gateway handles enforcement. It terminates tool calls and applies identity, allowlists, audit logging, and data controls on every request. A registry cannot block a call, and a gateway works without a registry when servers are added by URL. Organizations that need both a sanctioned catalog and runtime enforcement can run the two together, with the registry feeding the gateway's allowlist.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does Speakeasy use the official MCP Registry?
&lt;/h3&gt;

&lt;p&gt;The Speakeasy AI Control Plane uses the official MCP Registry to power its catalog. Teams browse, search, and filter registry entries from Connect &amp;gt; Catalog in the dashboard, then install the servers they approve. Each install registers the vendor's remote server URL and proxies sessions to it. The platform adds authentication, per-tool access control, and tool logs without copying or re-hosting the server. A separate detection feed built on agent hooks and live traffic surfaces unsanctioned servers.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is an MCP tunnel?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Fri, 13 Nov 2026 13:11:37 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-an-mcp-tunnel-33gn</link>
      <guid>https://dev.to/speakeasy/what-is-an-mcp-tunnel-33gn</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/mcp-tunnels" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP tunnel
&lt;/h2&gt;

&lt;p&gt;An MCP tunnel is an outbound-only connection that lets an AI agent or platform&lt;br&gt;
outside a private network reach a specific Model Context Protocol (MCP) server&lt;br&gt;
inside it. A small tunnel client runs next to the server and dials out over TLS&lt;br&gt;
to the endpoint that needs to reach it. Tool calls travel back down that&lt;br&gt;
connection, and nothing inside the network accepts inbound traffic.&lt;/p&gt;

&lt;p&gt;The MCP servers most worth connecting to agents are usually the ones an organization can least afford to expose. Because they remain private, a Postgres MCP tool that queries live data, an admin tool that can edit a user's plan, or a wrapper for a company API stays hidden. It has no public URL, and its firewall exists to keep it that way.&lt;/p&gt;

&lt;p&gt;They run differently. &lt;a href="https://www.speakeasy.com/resources/background-agents" rel="noopener noreferrer"&gt;Background agents&lt;/a&gt; operate using vendors' cloud infrastructure or separate VMs, with no access to company systems, while MCP apps like Claude and ChatGPT reach services through URLs. A tool running outside the network cannot access servers that exist only within it.&lt;/p&gt;

&lt;p&gt;Before tunnels, fixing that split came down to one of 2 things. The machine gained an open endpoint, the risk the firewall was meant to block, or the software got in through a VPN or peering setup, touching much more than one machine. With MCP, a link lets the app reach only that server and no other, while the server remains hidden.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does an MCP tunnel work?
&lt;/h2&gt;

&lt;p&gt;A tunnel is a reverse connection. A tunnel client runs on a machine already connected to the MCP server and dials outbound, rather than accepting inbound connections:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;The client opens one outbound connection.&lt;/strong&gt; It connects over HTTPS or a secure WebSocket to a tunnel endpoint outside the network. Most corporate firewalls already allow outbound traffic on port 443, so a tunnel typically requires no firewall changes and no network team coordination.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tool calls travel through that connection.&lt;/strong&gt; When an agent calls a tool, the request travels down the connection the client opened, the client forwards it locally to the MCP server, and the response returns the same way. Concurrent requests are multiplexed as separate streams over the single connection.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The server remains hidden inside.&lt;/strong&gt; There is no inbound firewall rule, no public hostname, and no port forward. The only path to the server is the connection the client chose to open, and stopping the client closes it.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Two details separate a well-built tunnel from an ad hoc one. It should only send data to the nearby IP given when configured on startup; then its endpoint, once it dials, cannot redirect it toward another machine in the LAN. It must authenticate against the endpoint through a secret the team may rotate, so an exposed secret becomes invalid with no host changes.&lt;/p&gt;

&lt;h2&gt;
  
  
  Where do MCP tunnels connect?
&lt;/h2&gt;

&lt;p&gt;A tunnel connects one private server to one endpoint. That endpoint is the thing trying to contact the server:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;An agent vendor's platform.&lt;/strong&gt; &lt;a href="https://claude.com/blog/claude-managed-agents-updates" rel="noopener noreferrer"&gt;Anthropic&lt;/a&gt; and &lt;a href="https://developers.openai.com/blog/connect-private-mcp-servers-to-openai-products" rel="noopener noreferrer"&gt;OpenAI&lt;/a&gt; each ship an MCP tunnel so their hosted products can reach private servers. A Claude tunnel serves Managed Agents and the Messages API, and an OpenAI tunnel serves ChatGPT, Codex, and other OpenAI products.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;An MCP gateway.&lt;/strong&gt; The tunnel terminates at an &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt;, which then serves the private server to every agent surface behind it and applies its identity, permission, and logging controls to tunneled traffic.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;A developer's own tooling.&lt;/strong&gt; A developer building an MCP server on a laptop can tunnel it so a hosted client can call it before it is deployed anywhere.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The decision counts because a link provides connectivity, without control. A tunneled host follows rules set at the endpoint it reaches. Setting up one path per vendor means every vendor gets a separate endpoint on the system, so none can see what another dialed. Routing through a gateway means the firm gets a single user on each host, plus one spot logging every request.&lt;/p&gt;

&lt;h2&gt;
  
  
  When does an organization need an MCP tunnel?
&lt;/h2&gt;

&lt;p&gt;Software on a device within a network can connect directly to a private host. A tunnel becomes necessary when an agent and a host operate across a network boundary. Common scenarios include:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Hosted agents needing internal systems.&lt;/strong&gt; A background agent on vendor infrastructure requires access to an issue tracker behind SSO, a staging database, or an internal API that only exist inside the network.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Internal APIs behind the firewall.&lt;/strong&gt; APIs built for callers on the corporate network cannot be exposed publicly without inverting the security model they were designed for.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Development servers on localhost.&lt;/strong&gt; An MCP server under development has no address outside the developer's machine. A tunnel is the only way for a hosted agent to call it before deployment.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;VPC-only services.&lt;/strong&gt; Databases and internal admin platforms are intentionally private, and a tunnel provides access without changing that privacy posture.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;On-premises systems in restricted networks.&lt;/strong&gt; Where policy prohibits inbound traffic, an outbound-only connection is the only pattern that satisfies security review.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  What value do MCP tunnels provide?
&lt;/h2&gt;

&lt;p&gt;An MCP tunnel offers distinct advantages over other connectivity approaches:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Private servers become usable by agents.&lt;/strong&gt; The most valuable servers, the ones holding sensitive data or controlling consequential actions, are private for a reason. A tunnel makes them available to agents without forcing organizations to decide whether they are safe to publish.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;No new inbound firewall exposure.&lt;/strong&gt; No inbound rule or port forward is added, and the private server needs no public hostname. The tunnel still creates a new access path, so the endpoint it connects to needs appropriate authentication and policy.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;The network path is scoped to one server.&lt;/strong&gt; The client forwards to only one configured local address; it does not put the agent on the network. Access to that server still depends on the controls where the tunnel terminates.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Deployment is lightweight.&lt;/strong&gt; The tunnel client is a single process or container running anywhere the server is reachable. Since outbound port 443 is almost universally open, most deployments require no firewall changes or network team coordination.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Control remains with the organization.&lt;/strong&gt; The tunnel exists only while the client runs. The authentication key can be rotated, and the local destination address is fixed at launch time. Nothing external can widen the tunnel's scope.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Governance placement is a choice.&lt;/strong&gt; Terminate the tunnel at a policy gateway and the private server gains identity, permissions, and an audit trail without leaving the network. Terminate it at an agent directly and the server becomes reachable but ungoverned, which creates a &lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;shadow MCP&lt;/a&gt; problem.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  MCP tunnel vs VPN: Key differences
&lt;/h2&gt;

&lt;p&gt;An MCP tunnel and a VPN both bridge networks, but serve different purposes and operate at different scopes:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;VPN scope:&lt;/strong&gt; Gives a client network-layer access to the services permitted by its routes and access rules&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MCP tunnel scope:&lt;/strong&gt; Connects a single MCP server to a single endpoint; the tunnel client forwards only to one configured local address&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;VPN exposure:&lt;/strong&gt; Depends on routes, access rules, and device policy; a VPN can be tightly scoped&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MCP tunnel exposure:&lt;/strong&gt; The tunnel forwards only to its configured MCP endpoint; the terminating platform decides who may call it&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;VPN setup:&lt;/strong&gt; Requires VPN client software, credentials, and ongoing session management&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;MCP tunnel setup:&lt;/strong&gt; Single outbound connection on port 443, usually requires no firewall changes&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;For organizations needing agents to reach a specific private MCP server without giving them a VPN session, a tunnel narrows the application path. It does not replace authentication and authorization at the endpoint.&lt;/p&gt;

&lt;h2&gt;
  
  
  How does Speakeasy provide MCP tunnels?
&lt;/h2&gt;

&lt;p&gt;In the &lt;a href="https://www.speakeasy.com/resources/ai-control-plane" rel="noopener noreferrer"&gt;Speakeasy AI Control Plane&lt;/a&gt;, a tunneled server operates as a source type. A lightweight proxy runs alongside your internal host, establishing one outbound WebSocket connection to the platform that multiplexes per-request streams through it. It forwards only to the local MCP endpoint pinned at launch, reconnects automatically with backoff if the link fails, and authenticates with a token displayed once, retained only as a hash, and rotated to revoke all active connections.&lt;/p&gt;

&lt;p&gt;The tunnel creates a persistent bridge between your private server and the external platform, with requests and responses flowing through the outbound connection established by your network, as shown in the linked diagram:&lt;/p&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/mcp-tunnels#how-does-speakeasy-provide-mcp-tunnels" rel="noopener noreferrer"&gt;View the MCP tunnel architecture diagram on Speakeasy&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;After setup, each tunneled host behaves the same as any other entry in that registry. It receives a cloud URL, runs via the same proxy layer as outside machines, and gains authentication, per-role app permissions, metering, and group entry. Calls appear in &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/observe/tool-logs" rel="noopener noreferrer"&gt;tool logs&lt;/a&gt; with the Tunneled MCP target type next to everything else the organization runs. One connection leaves it reachable to Claude, ChatGPT, the Responses API, or an organization's own tools via that governed route, not one per vendor.&lt;/p&gt;

&lt;p&gt;It appears as an option inside the dashboard. Create one tunneled MCP server from &lt;strong&gt;Sources &amp;gt; Connect&lt;/strong&gt;; use its Docker, CLI, or Kubernetes setup where it can access that server, and it appears in the registry once it dials outward. The &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/tunneled-servers" rel="noopener noreferrer"&gt;tunneled MCP servers&lt;/a&gt; docs cover configuration and monitoring, and the &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/guides/deploy-tunnel-agent-aws" rel="noopener noreferrer"&gt;AWS deployment guide&lt;/a&gt; walks through EKS, ECS Fargate, and EC2.&lt;/p&gt;

&lt;p&gt;To reach isolated hosts from your apps without exposing those, &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk with us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is an MCP tunnel?
&lt;/h3&gt;

&lt;p&gt;An MCP tunnel is an outbound-only connection that lets an AI agent or platform outside a private network reach a specific Model Context Protocol (MCP) server inside it. A small tunnel client runs next to the server, dials out over TLS to the endpoint that needs to reach the server, and tool calls travel back down that connection. The server needs no inbound firewall rule, no public hostname, and no port forward.&lt;/p&gt;

&lt;h3&gt;
  
  
  Why do organizations need MCP tunnels?
&lt;/h3&gt;

&lt;p&gt;The MCP servers most worth connecting to agents, such as a database server that queries production or an admin server for an internal system, run inside private networks. Agents increasingly run outside those networks, on a vendor's hosted infrastructure or an isolated VM. A tunnel lets the agent reach the server without the organization exposing it publicly, opening a firewall port, or standing up a VPN for the agent.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does an MCP tunnel work?
&lt;/h3&gt;

&lt;p&gt;It is a reverse tunnel. A tunnel client runs on a host that already reaches the MCP server and opens one outbound connection, usually over HTTPS or a secure WebSocket on port 443, to the endpoint outside the network. When an agent calls a tool, the request is sent down that established connection, the client forwards it to the server locally, and the response returns the same way. Concurrent requests are multiplexed as separate streams over the one connection.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is an MCP tunnel the same as a VPN?
&lt;/h3&gt;

&lt;p&gt;No. A VPN joins a machine to a network, so a connected agent could reach anything on it. An MCP tunnel connects one MCP server to one endpoint, and the tunnel client only forwards traffic to the local address it was configured with. The exposure is a single server rather than a network segment, and stopping the client closes the only path in.&lt;/p&gt;

&lt;h3&gt;
  
  
  Is an MCP tunnel the same as an MCP gateway?
&lt;/h3&gt;

&lt;p&gt;No. A tunnel is connectivity. It carries MCP traffic to a server that has no public address. An MCP gateway is a policy point that applies identity, permissions, and logging to tool calls. A tunnel can terminate at a gateway, at an agent vendor's platform, or at a developer's own tooling, and the governance a tunneled server gets depends on where the tunnel ends, not on the tunnel itself.&lt;/p&gt;

&lt;h3&gt;
  
  
  How does Speakeasy provide MCP tunnels?
&lt;/h3&gt;

&lt;p&gt;The Speakeasy AI Control Plane connects a private server through a tunneled MCP source. A lightweight tunnel agent runs next to the server and opens a single outbound WebSocket connection to the platform, which multiplexes per-request streams back down that connection. The server then behaves like any other server in the registry, with a hosted URL, authentication, per-role tool permissions, usage metering, and tool logs. One tunnel makes the server reachable from Claude, ChatGPT, the Responses API, or an organization's own agents.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
    <item>
      <title>What is MCP gateway bypass?</title>
      <dc:creator>RitzaCo</dc:creator>
      <pubDate>Fri, 13 Nov 2026 12:42:03 +0000</pubDate>
      <link>https://dev.to/speakeasy/what-is-mcp-gateway-bypass-33l9</link>
      <guid>https://dev.to/speakeasy/what-is-mcp-gateway-bypass-33l9</guid>
      <description>&lt;p&gt;By &lt;a href="https://www.speakeasy.com/author/nolan-sullivan" rel="noopener noreferrer"&gt;Nolan Sullivan&lt;/a&gt;, Founding Growth Engineer at Speakeasy. &lt;a href="https://www.speakeasy.com/resources/mcp-gateway-bypass" rel="noopener noreferrer"&gt;Originally published on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  MCP gateway bypass
&lt;/h2&gt;

&lt;p&gt;MCP gateway bypass is any route by which an AI agent reaches a Model Context&lt;br&gt;
Protocol (MCP) server, or the API behind it, without passing through the&lt;br&gt;
organization's MCP gateway. The gateway's authentication, tool policy, and&lt;br&gt;
audit log apply only to requests it receives, so a call that takes another&lt;br&gt;
route carries none of them.&lt;/p&gt;

&lt;p&gt;An &lt;a href="https://www.speakeasy.com/resources/mcp-gateway" rel="noopener noreferrer"&gt;MCP gateway&lt;/a&gt; is the policy point between agents and tools. It authenticates the caller, decides which tools they may use, and logs every call. All of that assumes the call arrives. Connecting an agent to a server takes one line of client configuration, and Cloudflare describes how it usually happens: an employee finds a server in a repository, a product guide, or a message from a colleague and adds it to their MCP client directly. Nothing about that connection passes the gateway, and the gateway has no record that it exists.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;A gateway governs the traffic it receives, so preventing MCP gateway bypass means making every other route fail, and each route is closed by a different layer.&lt;/strong&gt; Two of those layers live in the gateway. The others live on the network, on the device, and at the upstream provider, and one route stays open whatever you deploy: a device the organization doesn't manage.&lt;/p&gt;
&lt;h2&gt;
  
  
  The four bypass paths and the layer that closes each
&lt;/h2&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Local stdio servers.&lt;/strong&gt; The client launches the server as a subprocess, and no MCP traffic leaves the machine. Closed by client hooks and device-level discovery.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Direct remote URLs.&lt;/strong&gt; The client connects to a remote server, approved or not, at its own address instead of through the gateway. Closed by network egress policy and by an origin that rejects requests that didn't come through the gateway.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Personal tokens.&lt;/strong&gt; The user holds a working credential for the upstream service and uses it from any client or script. Closed by credential custody at the gateway and by the provider's own token policy.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Unmanaged clients.&lt;/strong&gt; An MCP client nobody reviewed, or a reviewed client that lost the organization's configuration, connects to the organization's tools. Closed by client admission at the gateway and by device enrollment.&lt;/li&gt;
&lt;/ol&gt;
&lt;h2&gt;
  
  
  How is MCP gateway bypass different from shadow MCP?
&lt;/h2&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;Shadow MCP&lt;/a&gt; is a connection to an MCP server the organization has not approved. The OWASP MCP Top 10 catalogs it as &lt;a href="https://owasp.org/www-project-mcp-top-10/" rel="noopener noreferrer"&gt;MCP09:2025 Shadow MCP Servers&lt;/a&gt;. Gateway bypass is the wider set. It includes every shadow MCP connection, and it also includes connections to approved servers that skip the gateway placed in front of them.&lt;/p&gt;

&lt;p&gt;Cloudflare makes the same split in its August 2026 post on MCP detection. It calls the second case portal bypass: an approved server sits behind an MCP Portal, and an employee connects to its upstream URL anyway, skipping the Portal's access policy, tool catalog, data loss prevention, and audit trail. Cloudflare's conclusion is that shadow MCP needs a network control, while portal bypass needs that network control plus an origin that can reject direct requests.&lt;/p&gt;

&lt;p&gt;Approving a server therefore doesn't close the bypass. An organization can put every approved server behind a gateway and still find calls to those servers going direct, because the old client configuration still works. &lt;a href="https://www.speakeasy.com/resources/shadow-ai" rel="noopener noreferrer"&gt;Shadow AI&lt;/a&gt; is the broader category again, covering models, agents, skills, and MCP servers used outside the security perimeter. This article covers only the routes around the MCP gateway.&lt;/p&gt;
&lt;h2&gt;
  
  
  Why can't the gateway stop bypass by itself?
&lt;/h2&gt;

&lt;p&gt;The gateway is a server, so it can refuse a request it receives but has no view of a request sent somewhere else. Three of the four bypass paths never produce a request to the gateway.&lt;/p&gt;

&lt;p&gt;The local stdio path is the clearest case. The &lt;a href="https://modelcontextprotocol.io/specification/2026-07-28/basic/transports" rel="noopener noreferrer"&gt;MCP transports specification&lt;/a&gt; defines stdio as a transport where the client launches the server as a subprocess and exchanges messages over standard input and output. A server configured that way runs entirely on the developer's machine. If it calls an API, that call is ordinary HTTPS from the laptop to the API, with nothing in it that says MCP.&lt;/p&gt;

&lt;p&gt;Direct remote connections and personal tokens are the same problem one step out. The request goes from the client to a server or API the gateway doesn't front, so the gateway's policy never runs. Unmanaged clients are the exception, because they do connect to the gateway. That makes them the one path a gateway can close at the point of connection.&lt;/p&gt;

&lt;p&gt;Deploying a gateway gives approved use a governed path. The other layers make the ungoverned paths fail, or at least show up somewhere a security team can see them.&lt;/p&gt;
&lt;h2&gt;
  
  
  How do agents route around an MCP gateway?
&lt;/h2&gt;

&lt;p&gt;Each path looks different in practice and leaves different evidence:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Bypass path&lt;/th&gt;
&lt;th&gt;What it looks like&lt;/th&gt;
&lt;th&gt;What the gateway sees&lt;/th&gt;
&lt;th&gt;Layer that closes it&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Local stdio server&lt;/td&gt;
&lt;td&gt;A client config entry that runs a command such as &lt;code&gt;npx some-mcp-server&lt;/code&gt;
&lt;/td&gt;
&lt;td&gt;Nothing&lt;/td&gt;
&lt;td&gt;Client hooks and device-level discovery&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Direct remote URL&lt;/td&gt;
&lt;td&gt;A server URL pasted into a client, either an unapproved server or the upstream address of an approved one&lt;/td&gt;
&lt;td&gt;Nothing&lt;/td&gt;
&lt;td&gt;Network egress policy, plus an origin that rejects direct requests&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Personal token&lt;/td&gt;
&lt;td&gt;A personal access token or API key in a client config or environment variable&lt;/td&gt;
&lt;td&gt;Nothing&lt;/td&gt;
&lt;td&gt;Credential custody at the gateway, plus provider token policy&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Unmanaged client&lt;/td&gt;
&lt;td&gt;An unreviewed MCP client, or a client switched to a personal account that dropped the organization's plugins and hooks&lt;/td&gt;
&lt;td&gt;An authorization from an unfamiliar client, which it may admit&lt;/td&gt;
&lt;td&gt;Client admission at the gateway, plus device enrollment&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;a href="https://www.speakeasy.com/resources/mcp-gateway-bypass#:~:text=An%20authorization%20from%20an%20unfamiliar%20client%2C%20which%20it%20may%20admit" rel="noopener noreferrer"&gt;View the MCP gateway bypass paths diagram on Speakeasy&lt;/a&gt;.&lt;/p&gt;

&lt;p&gt;The personal-token path outlives the others. A user who connected a server directly last quarter may still hold the token. Removing the server from their client config doesn't revoke it, and the &lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;shadow MCP guide&lt;/a&gt; makes the same point about closing findings: a config entry removed without addressing the credential leaves the connection easy to restore.&lt;/p&gt;

&lt;p&gt;The unmanaged-client path has a quieter version that falls under configuration drift, which Speakeasy's &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/reference/device-agent" rel="noopener noreferrer"&gt;device agent documentation&lt;/a&gt; calls the most common bypass on developer laptops. A user switches their AI agent to a personal account and silently loses the organization's plugins, telemetry, and guardrails. The client is the same one the organization approved, but its configuration is not.&lt;/p&gt;
&lt;h2&gt;
  
  
  How do you prevent MCP gateway bypass?
&lt;/h2&gt;

&lt;p&gt;Five control layers cover the four paths: network egress, the origin server, credential custody, client admission, and device-level discovery. None covers every path, and each has a documented blind spot.&lt;/p&gt;
&lt;h3&gt;
  
  
  Network egress: block direct MCP traffic on managed paths
&lt;/h3&gt;

&lt;p&gt;A secure web gateway sees HTTP traffic after it leaves the client, which makes it the widest view of remote MCP connections from managed devices. Cloudflare Gateway now classifies TLS-inspected requests as MCP when they carry the &lt;code&gt;MCP-Protocol-Version&lt;/code&gt; header, and exposes that as a beta Is MCP selector in HTTP policies. Combined with a Traffic Source selector that marks requests proxied by an MCP Portal, one rule blocks MCP traffic that didn't come through the Portal:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;experimental.is_mcp == true and not traffic.onramp in ("mcp_portal")
Action: Block
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;Docker documents the same two-layer pattern for its sandboxes. Its MCP access policies govern only server registration and requests handled by Docker's MCP gateway. A direct connection from inside a sandbox to a remote MCP server is outbound sandbox traffic, so Docker's guidance is to block the server in MCP policy and block its network destination in network policy.&lt;/p&gt;

&lt;p&gt;Egress control has three limits, and Cloudflare states all of them. Detection requires TLS decryption. Local stdio servers, off-network connections, and traffic exempted from inspection stay outside the view. And legacy MCP clients send their first &lt;code&gt;initialize&lt;/code&gt; request without the protocol header, so the first request to a previously unknown endpoint may not be classified. An egress rule is therefore a control for managed devices on managed networks, and the rest of the stack has to assume it can be absent.&lt;/p&gt;

&lt;h3&gt;
  
  
  The origin: make direct requests fail at the server
&lt;/h3&gt;

&lt;p&gt;An egress rule stops the request on the way out. A locked-down origin stops it on arrival, which also covers devices the egress proxy never sees. Cloudflare's &lt;a href="https://developers.cloudflare.com/cloudflare-one/access-controls/ai-controls/mcp-portals/" rel="noopener noreferrer"&gt;MCP server portal documentation&lt;/a&gt; is direct about why this layer is needed: users blocked by a portal's Access policy can still connect to the server, and bypass that policy, by using its direct URL, unless Access is configured as the server's OAuth provider.&lt;/p&gt;

&lt;p&gt;For MCP servers the organization runs, the strongest origin control is to give the server no address anyone else can reach. An &lt;a href="https://www.speakeasy.com/resources/mcp-tunnels" rel="noopener noreferrer"&gt;MCP tunnel&lt;/a&gt; lets the gateway reach a server inside a private network over an outbound-only connection, with no inbound port open. The server can also check that a request came through the gateway. Speakeasy's private &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/tunneled-servers" rel="noopener noreferrer"&gt;tunneled servers&lt;/a&gt; receive a short-lived signed JWT in an &lt;code&gt;X-Speakeasy-Identity&lt;/code&gt; header on each forwarded request, which the server can verify and reject when absent.&lt;/p&gt;

&lt;p&gt;Private networking on the client side is a separate decision with its own costs. A &lt;a href="https://www.speakeasy.com/resources/private-mcp-gateway" rel="noopener noreferrer"&gt;private MCP gateway&lt;/a&gt; takes the gateway's own listener off the public internet, so only devices on the private network can reach it. That narrows who can reach the gateway, and it means hosted agents such as remote connectors in ChatGPT or Claude can't reach it at all. On Speakeasy, private network access runs over a Tailscale tailnet, requires an Enterprise organization, and is set per server as public only, public and private, or private only. The &lt;a href="https://www.speakeasy.com/resources/private-mcp-gateway" rel="noopener noreferrer"&gt;private MCP gateway guide&lt;/a&gt; covers when that trade is worth making. Speakeasy runs as a &lt;a href="https://www.speakeasy.com/resources/managed-vs-self-hosted-mcp-gateway" rel="noopener noreferrer"&gt;managed gateway&lt;/a&gt; by default, and self-hosting is available for Enterprise customers (&lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;talk to our team&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;For third-party SaaS servers, the origin belongs to the vendor, and the organization's options depend on what the vendor exposes.&lt;/p&gt;

&lt;h3&gt;
  
  
  Credential custody: keep the token in the gateway
&lt;/h3&gt;

&lt;p&gt;A direct connection to a SaaS MCP server works only if the user can authenticate to it. If the upstream credential lives in the gateway and never reaches the user, a direct connection has nothing to authenticate with. This is the cheapest layer to deploy, because it needs no software on any device.&lt;/p&gt;

&lt;p&gt;The &lt;a href="https://modelcontextprotocol.io/docs/2026-07-28/tutorials/security/security_best_practices" rel="noopener noreferrer"&gt;MCP security best practices&lt;/a&gt; already forbid token passthrough, where a server accepts a client's token and forwards it upstream. Gateways implement the custody side in different ways. Kong's AI MCP OAuth2 plugin, part of AI Gateway Enterprise, validates that each token was issued for the target MCP server and doesn't forward client access tokens upstream by default. IBM's ContextForge stores per-user OAuth tokens encrypted, keyed by gateway and user, and keeps header passthrough off unless an operator enables it.&lt;/p&gt;

&lt;p&gt;Speakeasy's gateway holds &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/access/upstream-credentials" rel="noopener noreferrer"&gt;upstream credentials&lt;/a&gt; one of two ways: a token per user, obtained through the upstream's OAuth flow, encrypted at rest and refreshed by the platform, or &lt;a href="https://www.speakeasy.com/resources/shared-credentials-vs-user-delegated-identity" rel="noopener noreferrer"&gt;one shared credential&lt;/a&gt; per remote server, either a static key or an OAuth client credentials token. With &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/identity/identities/enterprise-managed-auth" rel="noopener noreferrer"&gt;Enterprise Managed Auth&lt;/a&gt; through Okta, the platform exchanges each person's Okta identity for the downstream token, so there's no per-service connect step and removing a person in Okta stops new access to every server that uses it.&lt;/p&gt;

&lt;p&gt;Custody stops new tokens from reaching users. It does nothing about tokens users already hold or can still create, and that half belongs to the provider. GitHub, for example, lets an organization &lt;a href="https://docs.github.com/en/organizations/managing-programmatic-access-to-your-organization/setting-a-personal-access-token-policy-for-your-organization" rel="noopener noreferrer"&gt;restrict access by personal access tokens&lt;/a&gt; and enable &lt;a href="https://docs.github.com/en/organizations/managing-oauth-access-to-your-organizations-data/about-oauth-app-access-restrictions" rel="noopener noreferrer"&gt;OAuth app access restrictions&lt;/a&gt;, so members can't authorize unapproved OAuth apps against organization resources. A provider without equivalent controls leaves the personal-token path open, and the remaining options are rotation and detection.&lt;/p&gt;

&lt;h3&gt;
  
  
  Client admission: refuse unreviewed clients at the gateway
&lt;/h3&gt;

&lt;p&gt;Client admission is the one bypass control that runs inside the gateway at connection time. The OAuth handshake is where the gateway learns which client is connecting, and with &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/mcp-gateway/access/client-registration" rel="noopener noreferrer"&gt;Client ID Metadata Documents&lt;/a&gt; (CIMD) the client's ID is an HTTPS URL on its vendor's domain. That URL is the same on every install, so the gateway can allowlist it, block it, and search for it.&lt;/p&gt;

&lt;p&gt;Speakeasy exposes this as a per-server &lt;strong&gt;Client access&lt;/strong&gt; setting with three options. &lt;strong&gt;Verified clients&lt;/strong&gt; admits a catalog of client documents Speakeasy has checked plus any URLs the organization adds, &lt;strong&gt;Any client&lt;/strong&gt; admits any valid document, and &lt;strong&gt;Off&lt;/strong&gt; admits no CIMD client. Separately, &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/secure/shadow-ai" rel="noopener noreferrer"&gt;Shadow AI&lt;/a&gt; records a decision per AI tool that enrolled devices report, and a tool marked &lt;strong&gt;Blocked&lt;/strong&gt; is refused when it authenticates, on every MCP server in the organization.&lt;/p&gt;

&lt;p&gt;Admission has real gaps, and the documentation states each one. Dynamic Client Registration (DCR) stays open to every client whatever the &lt;strong&gt;Client access&lt;/strong&gt; setting says, and a Shadow AI block takes effect only for callers that present a CIMD client ID. CIMD verifies that a document belongs to its vendor, and doesn't prove that the program on a user's machine is genuine. Admission also gates new authorizations, not existing sessions, so cutting off a client that is already connected takes a revocation. And admission only covers clients that connect to the gateway, which none of the other three bypass paths do.&lt;/p&gt;

&lt;h3&gt;
  
  
  Device-level discovery: see what runs on the laptop
&lt;/h3&gt;

&lt;p&gt;The device is the only place that can see a local stdio server. Cloudflare's post lays out the trade clearly: a hook inside the MCP client runs before the request is serialized, can deny a server not on an allowlist, and covers stdio servers that never produce network traffic, but the controls have to be reproduced in every client employees use.&lt;/p&gt;

&lt;p&gt;Two kinds of device software do this work. Hooks in the coding agent see each tool call, its server, and its arguments, which is how &lt;a href="https://www.speakeasy.com/resources/ai-agent-hooks" rel="noopener noreferrer"&gt;agent hooks&lt;/a&gt; catch calls to servers the gateway doesn't host. A device agent installed through MDM inventories the AI tools on a machine and keeps the organization's client configuration in place. Speakeasy's &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/reference/device-agent" rel="noopener noreferrer"&gt;device agent&lt;/a&gt; reapplies that configuration every 60 seconds, which is what closes the personal-account case above. It is in beta and enabled per organization. Docker takes a sandbox-side approach to the same problem: its MCP access policies can refuse registration of host-run stdio servers outright.&lt;/p&gt;

&lt;p&gt;Discovery depends on enrollment, and Speakeasy's Shadow AI documentation puts it in one line: a tool on an unenrolled machine appears nowhere. Shadow MCP detection has the same property, since sessions from an uninstrumented client produce no traffic to scan.&lt;/p&gt;

&lt;h2&gt;
  
  
  Which bypass paths can't be closed?
&lt;/h2&gt;

&lt;p&gt;Four gaps stay at least partly open whatever an organization deploys.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Unmanaged devices.&lt;/strong&gt; A personal laptop with no device agent, no hooks, and no managed proxy is invisible to three of the four layers. On that device, the organization's only levers are credentials it holds centrally and restrictions it sets at each provider.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Providers without token controls.&lt;/strong&gt; If an upstream service lets any user mint an API key and offers admins no way to restrict it, a user can always reach that service directly. Custody at the gateway removes the convenient token but not the ability to create one.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Off-network traffic.&lt;/strong&gt; An egress rule covers traffic that passes the proxy. A device on a home network without the proxy client running sends direct MCP traffic the rule never evaluates.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Tools without an MCP client.&lt;/strong&gt; Some agents call APIs directly and never speak MCP. Speakeasy's Shadow AI page notes that a decision about such a tool is recorded and never enforced, because there's no MCP authentication for the gateway to refuse.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The strongest argument against investing here follows from this list. A determined person with a shell and an API key can always reach the API, and the &lt;a href="https://www.speakeasy.com/resources/shadow-mcp" rel="noopener noreferrer"&gt;shadow MCP guide&lt;/a&gt; warns that enforcing a policy before a workable alternative exists can push teams toward the bypass it's meant to stop. Both points are correct, and they argue for a narrower goal: on managed devices with organization credentials, the direct path fails, and everywhere else, a direct connection shows up in an inventory with an owner.&lt;/p&gt;

&lt;h2&gt;
  
  
  In what order should you roll out bypass controls?
&lt;/h2&gt;

&lt;p&gt;Ranked from least to most effort, with the path each step closes:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Move upstream credentials into the gateway, and restrict personal tokens at providers that allow it.&lt;/strong&gt; No endpoint software, and it closes the personal-token path for every provider whose credentials move. This is realistic for every organization.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Turn on client admission.&lt;/strong&gt; Set servers to admit verified clients, and record approve or block decisions for the AI tools you already know about. It closes part of the unmanaged-client path, for clients that publish a CIMD document.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Run discovery in flag mode.&lt;/strong&gt; Deploy hooks and the device agent, and let a flag-only policy build the inventory of stdio and direct remote servers before anything is blocked. Speakeasy's &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/guides/shadow-mcp-allow-and-block-lists" rel="noopener noreferrer"&gt;shadow MCP allow and block lists guide&lt;/a&gt; describes this sequence, including the choice between a block-all and an allow-all posture.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Lock down the origins you own.&lt;/strong&gt; Move internal MCP servers behind tunnels, and have them verify the gateway's signed identity header. Add private network access for the gateway endpoint if your clients all run on enrolled devices.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Block direct MCP traffic at the egress proxy.&lt;/strong&gt; This needs TLS inspection and a managed proxy on every device, which many organizations already run and many don't. If you don't have one, this step is a network rollout before it is a policy.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Each step makes the next one less disruptive. Credentials in the gateway mean a blocked direct connection has a governed alternative waiting, and an inventory built in flag mode means the first blocking policy is based on observed traffic instead of guesses.&lt;/p&gt;

&lt;h2&gt;
  
  
  A note on Speakeasy
&lt;/h2&gt;

&lt;p&gt;Speakeasy runs a managed MCP gateway as part of the AI Control Plane. Of the layers above, it covers credential custody, client admission, and origin lockdown for internal servers through tunnels, and it pairs those with device-side discovery. &lt;a href="https://www.speakeasy.com/docs/ai-control-plane/secure/shadow-ai" rel="noopener noreferrer"&gt;Shadow AI&lt;/a&gt; is generally available under Guardrails for every organization. It lists the harnesses, assistants, and local models that enrolled devices report, and lets an admin approve or block each tool at the gateway. A blocked tool is refused when it authenticates, on every MCP server in the organization.&lt;/p&gt;

&lt;p&gt;The limits are the ones described above. Enforcement needs the tool to publish a client ID metadata document. A tool with no MCP client gets a recorded decision and no enforcement. And a device that isn't enrolled doesn't appear. Blocking direct MCP traffic on the network is a job for a secure web gateway, such as Cloudflare's, alongside the gateway.&lt;/p&gt;

&lt;p&gt;If you're mapping which of these paths are open in your organization today, we'd be interested to hear how you're approaching it. &lt;a href="https://www.speakeasy.com/talk-to-us" rel="noopener noreferrer"&gt;Talk to us&lt;/a&gt;.&lt;/p&gt;

&lt;h2&gt;
  
  
  Frequently asked questions
&lt;/h2&gt;

&lt;h3&gt;
  
  
  What is MCP gateway bypass?
&lt;/h3&gt;

&lt;p&gt;MCP gateway bypass is any route by which an AI agent reaches a Model Context Protocol (MCP) server, or the API behind it, without passing through the organization's MCP gateway. The gateway's authentication, tool policy, and audit log apply only to requests it receives, so a call that takes another route carries none of them.&lt;/p&gt;

&lt;h3&gt;
  
  
  How is MCP gateway bypass different from shadow MCP?
&lt;/h3&gt;

&lt;p&gt;Shadow MCP is a connection to an MCP server the organization has not approved. MCP gateway bypass is the broader set. It includes shadow MCP, and it also includes direct connections to approved servers that skip the gateway in front of them. Cloudflare draws the same line between shadow MCP and what it calls portal bypass, and notes that the two need different controls.&lt;/p&gt;

&lt;h3&gt;
  
  
  What are the main ways agents bypass an MCP gateway?
&lt;/h3&gt;

&lt;p&gt;There are four common paths. An agent can launch a local stdio MCP server as a subprocess, connect directly to a remote MCP server URL, call the upstream service with a personal token the user holds, or connect through an MCP client the organization never reviewed or configured. Each path is closed by a different control layer.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can an MCP gateway prevent bypass on its own?
&lt;/h3&gt;

&lt;p&gt;No. An MCP gateway governs the requests that reach it, so it cannot block a local stdio server or a direct connection to a remote server. The gateway can close two paths itself: it can hold upstream credentials so users have no token to take elsewhere, and it can refuse unreviewed MCP clients at authentication. Network egress controls and device-level discovery close the rest.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do you stop local stdio MCP servers from bypassing the gateway?
&lt;/h3&gt;

&lt;p&gt;A local stdio server runs as a subprocess of the MCP client and sends no MCP traffic over the network, so a gateway or a network proxy never sees it. The control point is the client itself: hooks inside the coding agent can see and deny calls to servers that the gateway does not host, and a device agent can report and correct client configuration. Both require the device to be enrolled.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do you block direct connections to remote MCP servers?
&lt;/h3&gt;

&lt;p&gt;Use a network egress control on managed devices that can recognize MCP traffic and block requests that did not come through the approved gateway. Cloudflare Gateway, for example, offers an Is MCP selector and a Traffic Source selector for this. The control only applies to TLS-inspected traffic on managed network paths, so pair it with an origin that rejects requests that did not arrive through the gateway.&lt;/p&gt;

&lt;h3&gt;
  
  
  How do personal access tokens enable MCP gateway bypass?
&lt;/h3&gt;

&lt;p&gt;A user who holds a working token for an upstream service can use it from any MCP client, script, or server, and none of those calls touch the gateway. Moving credential custody to the gateway removes that token from the user. Restricting personal tokens at the provider, where the provider supports it, stops tokens created outside the gateway from reaching organization data.&lt;/p&gt;

&lt;h3&gt;
  
  
  What is MCP client admission?
&lt;/h3&gt;

&lt;p&gt;MCP client admission is the gateway's decision about which MCP clients may start an OAuth authorization. With Client ID Metadata Documents (CIMD), a client identifies itself by an HTTPS URL on its vendor's domain, which gives the gateway a stable identity to allowlist or block. Admission controls which clients reach the gateway; it does not see clients that never connect to the gateway.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does network egress filtering stop MCP gateway bypass?
&lt;/h3&gt;

&lt;p&gt;It stops part of it. A secure web gateway with TLS inspection can identify remote MCP traffic from managed devices and block direct connections. It cannot see local stdio servers, traffic from devices that are off the managed network, or traffic exempt from inspection, and some legacy MCP clients send their first request without the protocol header that detection relies on.&lt;/p&gt;

&lt;h3&gt;
  
  
  Can you prevent MCP gateway bypass on unmanaged devices?
&lt;/h3&gt;

&lt;p&gt;Not reliably. Device-level discovery, client hooks, and egress filtering all depend on the device being enrolled or its traffic passing a managed proxy. On an unmanaged device, the remaining controls are the ones the organization holds centrally: keeping upstream credentials in the gateway and restricting personal tokens and unapproved OAuth apps at each provider that allows it.&lt;/p&gt;

&lt;h3&gt;
  
  
  What should you roll out first to prevent MCP gateway bypass?
&lt;/h3&gt;

&lt;p&gt;Start with credential custody, because it needs no endpoint software and closes the personal-token path for every provider whose credentials move into the gateway. Then turn on client admission, then run discovery in a flag-only mode to build an inventory, and add egress blocking last, since it needs TLS inspection and a managed proxy on every device.&lt;/p&gt;

&lt;h3&gt;
  
  
  Do agents bypass the gateway on purpose?
&lt;/h3&gt;

&lt;p&gt;Cloudflare describes the typical case: an employee finds a server in a repository, a product guide, or a colleague's message and adds it to their client without checking whether it is approved. Controls that make the governed path the default and make the direct path fail on managed devices handle that case. A determined person on an unmanaged device is a different problem and needs provider-side controls.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does a private MCP gateway prevent bypass?
&lt;/h3&gt;

&lt;p&gt;A private MCP gateway keeps the gateway's own listener off the public internet, which narrows who can reach the gateway. It does not stop an agent from reaching other servers directly. Private networking helps prevent bypass at the origin, when internal MCP servers are reachable only through the gateway, for example over an outbound-only tunnel, so a direct request has nowhere to go. On Speakeasy, private network access for the gateway endpoint runs over a Tailscale tailnet and requires an Enterprise organization.&lt;/p&gt;

&lt;h3&gt;
  
  
  Does Speakeasy prevent MCP gateway bypass?
&lt;/h3&gt;

&lt;p&gt;Speakeasy is a managed MCP gateway. Its Shadow AI feature, generally available under Guardrails for every organization, lets admins approve or block each AI tool that enrolled devices report, and blocked tools are refused when they authenticate on every MCP server in the organization. Enforcement needs the tool to publish a client ID metadata document, and devices that are not enrolled are not visible.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>mcp</category>
      <category>infrastructure</category>
      <category>speakeasy</category>
    </item>
  </channel>
</rss>
