Agent infrastructure glossary
Updated 18 November 2026 · Editorial assessment
Agent registry
An agent registry is a central service that stores agent cards and lets clients search for agents by criteria such as skills. Under the A2A protocol, the registry is an intermediary service that maintains a collection of Agent Cards for clients to query, and the current specification does not prescribe a standard API for curated registries. Google Cloud's Agent Registry lets you register AI agents so developers and orchestrator agents can discover and invoke their capabilities, and it integrates with versions 0.3 and 1.0 of A2A.
AI gateway
AI gateway is the term for a proxy layer between applications or agents and the models, tools and agents they call, where routing and access control are applied. Platform owners deploy one as a shared entry point for agent traffic. AWS describes Amazon Bedrock AgentCore Gateway as a fully managed AI gateway that gives agentic traffic one secure entry point. Kong's AI Gateway lets teams define a single endpoint for LLM, MCP or A2A traffic.
Artifact
Artifact, in A2A, is the concrete output a remote agent produces while working on a task. Buyers ask about it when they want to know what an agent hands back besides messages. The A2A documentation calls an artifact a tangible output or concrete result generated during a task. Each one has a unique artifactId, a human-readable name and one or more parts, and artifacts can be streamed to the client in increments. An RFP that asks for A2A protocol support can also ask how artifacts are stored and retrieved.
Attribute-based access control
Attribute-based access control (ABAC) grants or denies access by evaluating attributes of the caller, the resource and the environment against policy. Engineers meet it when policy has to depend on facts such as team or data class instead of a fixed role. In Google Cloud, Workload Identity Federation lets you define up to 50 custom attributes and use them in IAM principalSet role bindings. SPIFFE warns that attributes are scoped to a trust domain, so an entity with role admin in one domain is not assumed to be an admin in another.
Capability negotiation
Capability negotiation is the step in which an MCP client and server declare the optional protocol features each supports, so both know what a session can use. In version 2025-11-25 it happens during initialization, and both parties must only use capabilities that were successfully negotiated. Sampling, for example, requires the client to declare support.
Client credentials grant
The client credentials grant is the OAuth 2.0 flow in which a client obtains an access token with its own credentials rather than a user's. RFC 6749 says client credentials are used as a grant typically when the client is acting on its own behalf or under an authorization previously arranged with the authorization server. The MCP authorization specification lets clients acting on their own behalf attempt step-up authorization or abort the request. In Microsoft Entra Agent ID, autonomous agents authenticate with their agent identity and the client credentials flow.
Confused deputy
A confused deputy attack makes a trusted service use its own authority on behalf of a party that should not have it. In MCP, the attack becomes possible when a proxy server uses a static client ID with a third-party authorization server and lets clients register dynamically, that server sets a consent cookie after the first authorization, and the proxy does not implement proper per-client consent before forwarding to third-party authorization. The MCP security best practices say that to prevent confused deputy attacks, proxy servers must implement per-client consent and proper security controls. On Google Cloud, an attribute condition can stop credentials intended for another platform from being used with Google Cloud, which the documentation says helps avoid the confused deputy problem.
Dynamic client registration
Dynamic client registration lets an OAuth client register with an authorization server through a protocol call instead of a manual console step. Teams running many agents run into it when each one needs a client identifier and nobody wants to file them by hand. RFC 7591 describes how an OAuth 2.0 client can be dynamically registered to obtain that identifier. The MCP authorization specification lists Dynamic Client Registration as one of three ways to obtain a client ID.
Elicitation
Elicitation lets an MCP server ask the user for more information through the client. Version 2025-11-25 defines a form mode, in which servers can request structured data, and a URL mode, in which servers can direct users to external URLs for sensitive interactions. Teams writing agent identity and access requirements should ask which modes a host supports.
JSON-RPC 2.0
JSON-RPC 2.0 is a stateless, light-weight remote procedure call protocol that defines message data structures and the rules for processing them. Its specification calls it transport agnostic, usable within one process, over sockets or over HTTP. MCP requires that all messages between clients and servers follow the JSON-RPC 2.0 specification.
MCP client
An MCP client is the connector inside a host application that holds the connection to one MCP server. The specification overview describes clients as connectors within the host application. Version 2025-11-25 says a host creates multiple clients, each with a 1:1 relationship with a particular server, and that each client establishes one stateful session per server. Architects should count clients, not only servers, when sizing connections.
MCP gateway
MCP gateway is the term for a proxy in front of one or more MCP servers that applies routing, authentication and policy to tool traffic. Platform teams add one when many tool servers need a single controlled address. The agentgateway documentation shows how to federate tools from multiple MCP servers on one gateway endpoint. It also describes CEL-based RBAC rules that control which MCP tools clients can access based on JWT claims.
MCP host
The MCP host is the LLM application that creates MCP clients and opens connections to servers. Buyers meet it as the application the user works in. The specification overview describes hosts as LLM applications that initiate connections. Version 2025-11-25 gives the host control of client connection permissions and lifecycle and says it enforces security policies and consent requirements, which makes the host the component to examine for consent handling during an evaluation.
MCP prompt
An MCP prompt is a server-provided template of structured messages and instructions for working with a language model. The 2025-11-25 prompts page gives servers a standard way to expose prompt templates and says clients can provide arguments to customize them. Prompts are designed to be user-controlled, and the page says they would typically be triggered through user-initiated commands, giving slash commands as one example.
MCP Registry
The MCP Registry is the official centralized metadata repository for publicly accessible MCP servers. Platform owners meet it when deciding where internal servers get listed, because the registry does not support private servers and the project recommends that you host your own private MCP registry for those. The registry is currently in preview, and breaking changes or data resets may occur before general availability.
MCP resource
An MCP resource is data that a server exposes as context for a language model, addressed by its own URI. The 2025-11-25 resources page names files, database schemas, or application-specific information as examples and says each resource is uniquely identified by a URI. Resources are designed to be application-driven, with host applications deciding how to bring that context in, so the user experience depends on the host product. Servers that support resources must declare the resources capability.
MCP server
An MCP server is a service that provides context and capabilities to MCP clients, as the specification overview defines servers. Platform owners meet it as the wrapper an agent calls to reach a data source or business system. The 2025-11-25 architecture section says servers expose resources, tools and prompts and can be local processes or remote services, so where each server runs is a deployment decision to settle per server.
Message broker
A message broker is an intermediary that receives messages and routes them to receivers, so senders do not address each receiver directly. In Solace Agent Mesh, every cross-process message travels on the event broker, and peer agents never call each other over HTTP. Multiple replicas can bind to one named queue, and the broker hands each message to exactly one replica. The Desktop app instead runs an in-memory event broker meant for single-user local use.
mTLS
mTLS, or mutual TLS, is a TLS connection in which client and server each present a certificate and authenticate each other. RFC 8705 describes OAuth client authentication using mutual TLS with X.509 certificates, along with certificate-bound access and refresh tokens. Istio offers mutual TLS as a full stack solution for transport authentication that can be enabled without requiring service code changes. A2A discovery guidance lists mTLS among the methods for access controls on the endpoint serving the Agent Card.
OAuth 2.1
OAuth 2.1 is an Internet-Draft authorization framework that stays compatible with OAuth 2.0 while applying known best current practices. Architects meet it in vendor claims about agent authorization, so agent identity requirements should ask which of its restrictions a product enforces. The draft makes features such as PKCE required. It leaves the Implicit or Resource Owner Password Credentials grant types unspecified, and it restricts redirect handling to strict string matching of redirect URIs.
Part
Part is the A2A content container that carries text, file content or structured data inside a message or an artifact. Integration teams work with it when mapping agent payloads to their own formats. The A2A core concepts page says a Part must contain exactly one of the content fields text, raw, url and data. Every Part can include a mediaType, and it can also carry an optional filename and a metadata map.
PKCE
PKCE, or Proof Key for Code Exchange, is the technique RFC 7636 describes to mitigate the authorization code interception attack against OAuth 2.0 public clients that use the Authorization Code Grant. The authorization request carries a challenge derived from that verifier. RFC 7636 explains that an attacker who intercepts the authorization code is unable to redeem it without the code_verifier secret. OAuth 2.1 requires PKCE, which the draft names as a feature not specified in OAuth 2.0 core.
Protected resource metadata
Protected resource metadata is a JSON document that an OAuth protected resource publishes about itself, retrieved from a well-known location. Engineers hit it when a client has to find which authorization server guards an API. RFC 9728 defines a metadata format for this purpose. In MCP, servers must implement it, and clients must use it for authorization server discovery.
Push notification
Push notification, in A2A, is a call from the agent server to a webhook the client supplied, sent on a significant task update. The core concepts page says the server calls a client-provided webhook and that this suits very long-running tasks or disconnected clients. The client provides a TaskPushNotificationConfig, which includes the HTTPS webhook URL and an optional token. A server must signal support by setting capabilities.pushNotifications: true in its Agent Card.
Resource indicator
A resource indicator is the resource request parameter that tells an authorization server which protected resource will use the requested access token. Architects need it where one authorization server issues tokens for many APIs or tenants. RFC 8707 describes a need for the client to explicitly signal where it intends to use the token. Once informed of that resource, the authorization server can restrict the intended audience of the token to the given resource so it cannot be used successfully at other resources.
Roots
Roots are filesystem boundaries that an MCP client exposes to servers to mark where they may work. Engineers meet them when an agent needs scoped access to project directories. The 2025-11-25 roots page says roots define the boundaries of where servers can operate within the filesystem, and that servers can request the list of roots from supporting clients. Version 2026-07-28 deprecates the Roots feature and suggests passing directories or files via tool parameters, resource URIs, or server configuration.
Sampling
Sampling is a request in which an MCP server asks the client to obtain a language model completion for it. In version 2025-11-25, servers request LLM sampling via clients, so the client keeps control over model access, selection, and permissions. The page says there should always be a human in the loop able to deny those requests. The 2026-07-28 changelog deprecates Roots, Sampling, and Logging and suggests implementers integrate directly with LLM provider APIs instead.
Server-Sent Events
Server-Sent Events, or SSE, is a way for a server to push a series of events to a client over one HTTP connection that stays open. Architects see it when agents report progress on long tasks. A2A lists streaming with Server-Sent Events as an interaction pattern in which clients open a stream and receive incremental results. A streaming A2A server responds with HTTP 200 OK and Content-Type: text/event-stream, and that connection remains open while it sends events to the client.
Service mesh
A service mesh is an infrastructure layer that gives applications zero-trust security, observability and advanced traffic management without code changes. Istio, which is a graduated project in the Cloud Native Computing Foundation, says services on Kubernetes or VMs, multi-cloud, hybrid or on-premises can be included within a single mesh. Its security documentation says Istio provisions strong identities to every workload with X.509 certificates.
SPIFFE ID
A SPIFFE ID is a structured string used to identify a resource or caller under the SPIFFE standard. The SPIFFE standard specifies a framework capable of bootstrapping and issuing identity to services across heterogeneous environments and organizational boundaries. Workloads carry it in an SVID, the mechanism by which a compute endpoint can present its SPIFFE ID for cryptographic verification. SVIDs are valid for a limited period, mainly to reduce the likelihood and damage of a key compromise.
stdio transport
The stdio transport carries MCP messages over the standard input and output streams of a server process that the client launches. The 2025-11-25 transports page lists stdio as communication over standard in and standard out and says clients should support stdio whenever possible. The 2026-07-28 transports overview describes messages over the standard streams of a client-launched subprocess. Engineers meet stdio when an agent or IDE starts an MCP server on the same machine.
Streamable HTTP
Streamable HTTP is the MCP transport that carries messages over HTTP to one server endpoint. Under version 2025-11-25, the server must provide a single HTTP endpoint that supports both POST and GET, and each client message must be a new HTTP POST to that endpoint. Servers must validate the Origin header on all incoming connections to prevent DNS rebinding attacks, a check to write into gateway requirements. The 2026-07-28 changelog marks the older HTTP+SSE transport as Deprecated and says to migrate to Streamable HTTP.
Token exchange
Token exchange is an OAuth 2.0 request in which a client trades one security token for another issued by an authorization server. Architects meet it when an agent calls a backend on a user's behalf. RFC 8693 defines how to request and obtain security tokens from OAuth 2.0 authorization servers, including tokens employing impersonation and delegation. Under delegation, principal A still has its own identity separate from B, and actions are taken by A representing B. Workload Identity Federation on Google Cloud follows the OAuth 2.0 token exchange specification.
Token passthrough
Token passthrough is an MCP anti-pattern where a server accepts tokens from a client without validating that they were properly issued to it and passes them to the downstream API. The MCP guidance says it is explicitly forbidden in the authorization specification. The server or downstream APIs might apply controls like rate limiting and request validation, and clients that use tokens directly downstream without proper validation bypass these controls. With RFC 8693 token exchange, the new token might be more narrowly scoped for the downstream service.
Well-known URI
Well-known URI is the name for a fixed path on a host where an application publishes metadata about the whole origin. A client that knows only a domain can fetch metadata from that path without extra configuration. RFC 8615 defines it as a URI whose path component begins with "/.well-known/", provided the scheme is defined to support well-known URIs. A2A servers can host their Agent Card at the standard path /.well-known/agent-card.json on their domain.
Workload identity
A workload identity is an identity assigned to a piece of software, such as a service or container, so it can authenticate to other services and resources. In Microsoft Entra, workload identities are applications, service principals and managed identities, and the same page notes that the terminology is inconsistent across the industry. Google Cloud's Workload Identity Federation lets you grant on-premises or multicloud workloads access to Google Cloud resources by using federated identities instead of service account keys.
Which sources does this page cite?
- Specification (modelcontextprotocol.io)
- Architecture (modelcontextprotocol.io)
- Resources (modelcontextprotocol.io)
- Prompts (modelcontextprotocol.io)
- Sampling (modelcontextprotocol.io)
- Key Changes (modelcontextprotocol.io)
- Elicitation (modelcontextprotocol.io)
- Roots (modelcontextprotocol.io)
- Transports (modelcontextprotocol.io)
- Overview (modelcontextprotocol.io)
- JSON-RPC 2.0 Specification JSON-RPC Home (jsonrpc.org)
- Overview (modelcontextprotocol.io)
- Lifecycle (modelcontextprotocol.io)
- draft-ietf-oauth-v2-1-17 (datatracker.ietf.org)
- RFC 9728: OAuth 2.0 Protected Resource Metadata (rfc-editor.org)
- Authorization (modelcontextprotocol.io)
- RFC 7591: OAuth 2.0 Dynamic Client Registration Protocol (rfc-editor.org)
- RFC 7636: Proof Key for Code Exchange by OAuth Public Clients (rfc-editor.org)
- RFC 8707: Resource Indicators for OAuth 2.0 (rfc-editor.org)
- Core Concepts (a2a-protocol.org)
- Streaming & Asynchronous Operations (a2a-protocol.org)
- RFC 8615: Well-Known Uniform Resource Identifiers (URIs) (rfc-editor.org)
- Agent Discovery (a2a-protocol.org)
- Amazon Bedrock AgentCore Gateway: A secure AI gateway for agents, tools, and mod (docs.aws.amazon.com)
- Kong AI Gateway (docs.konghq.com)
- MCP connectivity (agentgateway.dev)
- The MCP Registry (modelcontextprotocol.io)
- Register agents (docs.cloud.google.com)
- Workload identities (learn.microsoft.com)
- Workload Identity Federation (cloud.google.com)
- spiffe/spiffe: standards/SPIFFE-ID.md (GitHub)
- RFC 8693: OAuth 2.0 Token Exchange (rfc-editor.org)
- RFC 6749: The OAuth 2.0 Authorization Framework (rfc-editor.org)
- Fundamental concepts in Microsoft Entra Agent ID (learn.microsoft.com)
- RFC 8705: OAuth 2.0 Mutual-TLS Client Authentication and Certificate-Bound Acces (rfc-editor.org)
- Istio / Security (istio.io)
- Security Best Practices (modelcontextprotocol.io)
- Istio / The Istio service mesh (istio.io)
- The Event-Driven Mesh --> Support (docs.solace.com)
Reviewed Nov 2026