Home/Blog/Designing a governance layer for autonomous assistants: stateless MCP, per-request identity and observability
Designing a governance layer for autonomous assistants: stateless MCP, per-request identity and observability
October 2, 2026

Autonomous assistants become difficult to govern when identity, authorization context, routing decisions, and audit signals depend on a long-lived connection or an opaque server session. A well-designed MCP governance layer uses stateless MCP as the transport foundation, then makes identity, policy, state handles, and tracing explicit on every request.
That distinction matters for teams operating specialist agents, tool servers, and multi-agent workflows across enterprise infrastructure. The stateless MCP direction allows ordinary HTTP load balancing and removes protocol-level session affinity, but it does not remove the need for application state or governance. It changes where those responsibilities belong: in a deliberate control plane and in request-scoped evidence rather than in hidden transport state.
Direct answer: what an MCP governance layer should do
An MCP governance layer should authenticate and authorize each request, attach verifiable workload and user context, route using request metadata, propagate distributed trace context, enforce tool policy, and record decisions in an audit trail. It should treat MCP as stateless at the protocol layer while allowing applications to use explicit state handles for durable work.
The model is especially useful when a host application routes work to several MCP-connected agents and tools. Rather than giving each server its own isolated rules, logs, and session assumptions, a unified endpoint can consistently apply controls before a request reaches an MCP server and capture the outcome after the response returns.
The relevant protocol changes support this architecture. In the 2026-07-28 release candidate, MCP moved to a stateless protocol core, removing protocol-level sessions and the initialize/initialized handshake. Protocol version, client identity, and client capabilities move into per-request _meta, while server/discover provides capability discovery.
Identity plane:
establish who or what is calling, what workload is acting, and which user or tenant context is delegated.
Policy plane:
decide whether that principal may invoke a server, tool, resource, or action with the supplied arguments.
Routing plane:
select a gateway path, server pool, or specialist workflow without relying on a sticky protocol session.
Observability plane:
carry trace context and produce records that connect a user request to agent decisions, tool calls, and downstream effects.
State plane:
manage durable application state through explicit handles, not an ambient transport session.
These planes can be implemented by separate services, but their contract must be coherent. A gateway that validates a token but cannot preserve the resulting principal in telemetry creates an audit gap. Likewise, a tracing system that can show latency but cannot identify the delegated workload cannot answer the governance questions that matter after an automated action.
Why stateless MCP changes governance architecture
Sessionful designs often place too much operational meaning in connection ownership. A request must return to the same server instance because that instance holds the protocol session, negotiated capabilities, or interaction state. This makes horizontal scaling and governance enforcement more complicated: load balancers need affinity, gateways need session awareness, and incident investigation has to reconstruct context from distributed, transient session stores.
SEP-2567 removes protocol-level sessions and the Mcp-Session-Id er. This means sticky routing and shared session stores are no longer protocol requirements. The specification’s changelog treats this as a wire-format change, not merely an SDK implementation convention. A compliant deployment can therefore place server instances behind normal round-robin infrastructure without maintaining a persistent protocol connection.
Separate protocol statelessness from application state
Stateless transport does not mean assistants have no memory, no long-running work, or no user interaction. The specification explicitly frames the model as “stateless protocol, stateful applications.” The difference is that state is represented intentionally, with explicit handles in tool arguments, rather than being implicitly bound to a connection.
For governance, this makes state easier to reason about. A policy engine can evaluate whether a caller may use a particular handle, whether the handle belongs to the caller’s tenant, and whether it remains valid. Those checks are much clearer than assuming that whoever holds a live session is authorized to continue an operation.
Use MRTR for mid-call interaction without persistent connections
Multi Round-Trip Requests (MRTR, SEP-2322) replace older server-initiated request patterns. When a tool requires additional user input or an approval-related interaction, the server returns input_required. The client later retries with inputResponses and requestState.
That retry boundary is a governance checkpoint. The control plane can require that the returned input remains associated with the original principal and trace, validate that the requested continuation is still allowed, and apply policy again before the work resumes. It should not treat an earlier allow decision as a perpetual grant for all future continuations.
Build per-request identity into the MCP governance layer
Per-request identity is the central design requirement in a stateless system. The client identity and capabilities carried in _meta provide protocol-level context, while server identity is returned in the response envelope. The TypeScript SDK migration guidance places server identity in _meta['io.modelcontextprotocol/serverInfo'] on every response, and the C# SDK guidance says clients should include clientInfo on every request while servers include serverInfo on every response.
Those fields should be treated as useful protocol evidence, not as a complete enterprise identity system by themselves. A production governance layer generally needs to distinguish at least the initiating end user, the host application, the agent or workflow acting on behalf of that user, and the workload or service instance that makes the network call.
Define the identity chain before choosing enforcement points
Identify the initiator.
Capture the human user, service account, or upstream system that started the requested outcome.
Identify the acting agent.
Record the specialist agent, workflow version, or orchestration component making a tool-selection decision.
Identify the calling workload.
Associate the request with the deployed client workload, environment, and tenant boundary where relevant.
Identify the target.
Bind the decision to the MCP server, tool name, resource, or prompt-sensitive operation that will be reached.
Bind the delegation.
Make the allowed scope, audience, and validity of the delegation explicit enough that the target can enforce it.
This chain prevents a common failure mode: a tool server sees only a gateway credential and cannot determine which workflow, user, or tenant caused the action. If all actions appear to come from one shared principal, authorization may be technically enforced but accountability is weak.
Keep protocol identity and authorization claims distinct
Client and server information in the MCP envelope help identify participating software and improve diagnostics. Authorization still requires a trust model. The governance layer should validate the credentials and claims it relies on, map them to internal principals, and make an explicit decision on the requested action.
The MCP roadmap identifies identity and delegation work such as DPoP, Workload Identity Federation, and token exchange as areas of focus. Teams should design so stronger delegation mechanisms can be adopted without changing every tool contract. In practice, that means keeping identity validation and policy evaluation at a gateway or shared authorization boundary, rather than embedding inconsistent authorization logic in every agent prompt or individual server.
Require a known client workload for calls into protected tool domains.
Preserve the initiator and acting-agent identities as structured attributes where policy and privacy rules permit.
Scope credentials and delegation to the intended server or tool audience.
Validate tenant and environment boundaries before forwarding an explicit state handle.
Return server identity on each response and retain it with the transaction record.
Route and enforce policy with stateless MCP request metadata
Stateless MCP enables infrastructure to make useful decisions before parsing a request. Streamable HTTP requests include Mcp-Method and Mcp-Name ers, allowing gateways, rate limiters, and load balancers to route based on the method and operation name. This is a practical building block for a unified MCP endpoint model where governance, identity, and observability are concentrated around a common ingress path.
Header-based routing should not become authorization by er. An untrusted caller can present a er, so the gateway must authenticate the caller, validate the request according to the protocol, and then use the declared method and name as inputs to routing and policy. The advantage is operational: the routing tier has enough standardized information to select controls without inspecting every payload simply to discover the operation.
A useful policy decision sequence
Apply controls in a stable order so denials are explainable and logs are consistent. Different organizations may combine steps, but a clear separation makes policy changes safer.
Accept the HTTP request at the unified endpoint and associate it with a request identifier and trace context.
Authenticate the presenting workload and validate the credential form required by the endpoint.
Read the MCP method and name ers, then validate the request envelope and required per-request metadata.
Resolve the identity chain, including user delegation and agent or workflow context when present.
Evaluate authorization for the target server and operation before exposing sensitive tool metadata or forwarding arguments.
Apply rate, concurrency, geography, tenant, or environment controls appropriate to the authenticated principal and operation.
Route to an eligible server instance, then record the result, server identity, and policy decision.
This approach works for discovery as well as invocation. Since server/discover replaces the old one-time handshake for capability discovery, discovery itself should be governed. An agent should not automatically learn about every tool in an organization simply because it can reach an endpoint. Discovery can be filtered by identity, environment, tenant, and delegated scope.
Policy should consider tool arguments, not only tool names
Tool names are necessary but incomplete authorization inputs. A document retrieval tool may be allowed for one repository and prohibited for another; a deployment tool may be allowed in a development environment but not a production environment; a state handle may be valid only for one tenant. The gateway or target service needs a policy model that can evaluate the relevant argument-level constraints.
Do not assume every argument can or should be inspected centrally. Encrypted, highly sensitive, or large payloads may require enforcement at the target server. The governance layer should define which controls are centralized, which remain local to the tool server, and how both layers report their decision. Centralization improves consistency, while target-local enforcement retains domain-specific knowledge.
Design explicit state handles for autonomous workflows
Once protocol sessions disappear, teams need a durable way to represent work that lasts longer than one request. Explicit state handles are that mechanism. A handle can refer to a workflow run, a pending approval, a user interaction state, an artifact, or a server-side job, and it is passed in tool arguments when the next request needs to continue the work.
The important governance decision is to treat a handle as a protected capability reference, not as a harmless convenience string. Possession alone should not necessarily authorize use. The target should validate the handle’s integrity and bind it to the right tenant, operation, principal, and lifecycle conditions.
Give state handles a lifecycle contract
Creation:
specify who can create the handle and what identity, workflow, and target context are bound at creation time.
Use:
verify that the present caller and delegated authority may read, update, or continue the referenced work.
Scope:
limit use to the appropriate server, tool family, tenant, and environment where applicable.
Expiry:
define when the handle ceases to be valid, particularly for incomplete interactions or high-impact work.
Revocation:
provide a way to stop use after a user cancels, a policy changes, or a security event occurs.
Audit:
capture creation, use, failure, cancellation, and completion events with the relevant trace and identities.
Tasks provide a concrete pattern. They were moved out of MCP core into an extension because real-world deployments required a better stateless lifecycle. The extension uses explicit task handles and operations including tasks/get, tasks/update, and tasks/cancel. That design makes status and cancellation addressable operations instead of implicit properties of a connection.
The same principle applies to MRTR. When a server returns input_required, the associated requestState should be protected against cross-user continuation, replay outside its intended workflow, and use after cancellation. A governance layer does not need to know every business detail inside the state, but it should be able to verify that a continuation request is legitimate before allowing it through.
Make observability a request-scoped control, not an afterthought
Autonomous systems require more than application logs. Operators need to trace a request from the host application through an agent, client SDK, MCP gateway, MCP server, and downstream services. SEP-414 standardizes W3C Trace Context propagation in _meta, including traceparent, tracestate, and baggage. This provides a protocol-defined path for distributed tracing that is compatible with OpenTelemetry-oriented backends.
The release candidate specifically identifies an observability benefit: a trace can follow a tool call through the host application, client SDK, MCP server, and downstream services. That is a meaningful operational improvement because agent workflows frequently cross ownership boundaries. A useful trace makes latency, errors, retries, and decision points visible as one transaction rather than as disconnected events.
Record both technical and governance events
Trace context alone does not make an audit record. Traces are optimized for following execution, while governance records need durable answers about who requested an action, what policy was evaluated, and what was permitted or denied. Connect the two by storing trace identifiers in structured policy and audit events.
The authenticated workload and resolved delegated principal.
The agent or workflow identity that selected the tool call.
The MCP method and name used for routing.
The target server identity returned in the response.
The authorization result, applicable policy reference, and denial reason where safe to retain.
The state or task handle reference in a protected or minimized form when lifecycle tracking is needed.
The trace context needed to navigate from the governance event to the execution path.
Be careful with baggage and logs. Distributed tracing metadata can travel across services, so organizations should define which attributes are acceptable to propagate and which sensitive data must remain out of tracing fields. Use identifiers and controlled references where possible rather than putting user content, secrets, or raw tool arguments into telemetry.
Measure what helps operators make decisions
Observability should support practical questions: Which agent generated a failed action? Which tool server is slowing a workflow? Was a request denied at the gateway or by the target service? Did a continuation follow an input_required response? Which version of a specialist workflow was active when an incident occurred?
Answering these questions requires consistent attribute names and propagation behavior across the host, gateway, agents, and tool servers. An orchestration workspace can establish those conventions at handoff points, attaching the current trace and workflow context whenever work moves from one specialist agent to another. The trace is then useful not just for performance debugging, but for explaining the sequence of automated decisions.
Use discovery, caching, and deployment patterns deliberately
Stateless MCP makes standard HTTP deployment easier, but architecture still involves choices. The release notes position the stateless core as a scalability unlock because MCP servers can run behind standard round-robin infrastructure without sticky sessions or persistent connections. This is valuable for elastic server pools, rolling deployments, and failure recovery.
It does not mean every component becomes interchangeable. Tool servers may have different permissions, data locality, model access, or compliance responsibilities. The governance layer should route only to instances eligible for the request and preserve enough server identity in telemetry to establish where the work actually ran.
Discover capabilities through policy-aware inventory
With server/discover replacing the initialization handshake for capability discovery, teams can build a governed catalog of available MCP servers and capabilities. A control plane can maintain approved server registrations, ownership metadata, environments, supported tools, and required authorization policies. Discovery responses can then be filtered to what the requesting client is permitted to see.
This is preferable to treating every reachable endpoint as equally trusted. A specialist agent should receive the smallest relevant capability set for its task. Reduced discovery scope can lower accidental tool selection and makes it easier for product and operations teams to understand what an agent is allowed to do.
Use TTL and cache scope as operational signals
The specification adds TTL and cache scope for list and resource results. These fields provide freshness and sharing guidance analogous to HTTP cache semantics, reducing dependence on long-lived streaming state. For a governance layer, they can inform how long a discovery result or resource listing may be reused and whether reuse is appropriate across callers.
Cache guidance is not a substitute for authorization. If a response varies by caller, tenant, or delegated scope, a shared cache must not make it available to an unauthorized requester. Design cache keys and cache placement with the same identity boundaries used for policy enforcement. Where that cannot be guaranteed, use a narrower cache scope or avoid sharing the result.
Account for limits and migration risks in stateless MCP
The stateless core simplifies protocol infrastructure, but it shifts responsibility into application design. Teams that previously relied on a session identifier must identify every place where session state was silently carrying authorization, capability negotiation, pending interaction, or workflow ownership. Moving only the load balancer configuration while leaving those assumptions unexamined can create correctness and security gaps.
Official SDK documentation describes stateless operation as a first-class mode, including support for distributed servers without session validation. It also warns that some SDK-level stateless behavior was still being refined. Treat migration as an interoperability and operational validation exercise, especially when hosts, clients, gateways, and servers may upgrade at different times.
Common design mistakes
Replacing a session ID with an unprotected handle:
an explicit handle needs validation, scope, expiry, and lifecycle management.
Trusting envelope identity as authorization:
protocol identity fields should complement, not replace, verified credentials and policy evaluation.
Using ers as a security boundary:
Mcp-Method
and
Mcp-Name
enable routing, but inputs must be authenticated and validated.
Tracing raw sensitive content:
trace correlation is valuable; indiscriminate payload capture can create an unnecessary exposure surface.
Allowing unrestricted discovery:
capability discovery should be constrained by the same identity and tenant boundaries applied to invocation.
Skipping policy on retries:
MRTR continuations and task updates are new requests and should receive appropriate validation.
Phase a migration around observable boundaries
Start by inventorying session-dependent behavior in current MCP deployments. Classify each dependency as protocol transport state, durable application state, identity context, or observability context. Protocol transport state can align with the stateless core; durable behavior should become an explicit application resource; identity and trace context should be sent and recorded per request.
Next, introduce a unified endpoint in front of a limited set of low-risk servers. Verify round-robin behavior, policy enforcement, server discovery filtering, trace continuity, and MRTR continuation handling. Only then extend the pattern to broader tool estates and higher-impact operations. This staged approach helps teams discover contract mismatches while the blast radius is constrained.
Operational blueprint for a unified MCP endpoint
A unified endpoint does not require a single monolithic service. It is an architectural boundary where the same request contract applies regardless of which specialist agent or MCP server ultimately handles the work. The roadmap and release materials describe this direction as centralizing governance, identity, and observability around one endpoint rather than scattering them across sessionful transports.
For platform teams, the practical objective is consistency: every tool call should have a comparable identity chain, policy decision, trace relationship, and response record. For product and operations teams, the objective is explainability: when an autonomous workflow does something useful or unexpected, the organization should be able to identify the responsible workflow, target capability, and control decision.
Define a canonical per-request context model covering client information, server identity, user delegation, agent identity, trace context, and tenant or environment attributes.
Publish policy contracts for discovery, invocation, task lifecycle operations, and MRTR continuations.
Deploy gateway controls that authenticate, route using MCP ers, authorize, rate limit, and emit structured events.
Require tool servers to validate explicit state handles and return per-response server identity.
Propagate W3C trace context through host applications, SDKs, orchestration handoffs, servers, and downstream services.
Review traces and audit records together during operational testing so evidence is useful to both engineers and governance stakeholders.
This blueprint accommodates a multi-agent environment without making all agents equally privileged. An orchestration layer can route a request to a specialist agent, preserve its context at handoff, and require a new policy decision when that specialist invokes an MCP tool. The result is a control plane that supports autonomous work while maintaining explicit boundaries around identity, authority, and state.
Stateless MCP removes the protocol-level session as the organizing principle for distributed agent infrastructure. The stronger replacement is not an absence of state, but explicit state handles, per-request identity, er-aware routing, and standardized trace propagation that make each action independently governable.
Teams designing an MCP governance layer should begin with one question for every request: can we prove who acted, what they were allowed to do, where the request went, what state it used, and how the outcome connects to the wider workflow? If the answer is consistently yes, stateless MCP becomes a practical foundation for scalable, observable autonomous assistants.