A complete dictionary of Model Context Protocol and AI agent terminology. 27 terms defined, cross-referenced, and kept current with the evolving MCP ecosystem.
Agent-to-Agent (A2A) is an open protocol created by Google that enables AI agents built on different frameworks to communicate and collaborate. Unlike MCP which connects agents to tools, A2A focuses on agent-to-agent interoperability through JSON-RPC messages, task lifecycle management, and capability discovery via Agent Cards.
An adapter is a translation layer that converts a standardized gateway request into a provider-specific API call. In ToolRoute, each adapter handles authentication, input mapping, response normalization, and error translation for one third-party service. Adapters let developers use dozens of different APIs through a single unified interface.
An agent framework is a software library or platform that provides the scaffolding for building autonomous AI agents. Frameworks like LangChain, CrewAI, AutoGen, and the Anthropic Agent SDK handle orchestration, memory, tool use, and multi-step reasoning so developers can focus on defining agent behavior rather than building infrastructure from scratch.
An API gateway is a server that sits between clients and backend services, acting as a single entry point for all API requests. It handles routing, authentication, rate limiting, billing, and protocol translation. Traditional API gateways like Kong or AWS API Gateway are designed for REST traffic, whereas MCP gateways extend this concept to the Model Context Protocol.
Auto-routing is an intelligent dispatch mechanism that selects the best tool for a given task based on natural-language intent. Instead of specifying a tool ID directly, the caller describes what they need and the router matches their request against category beliefs, tool capabilities, and usage history to pick the optimal provider and operation.
BYOK is a billing model where users register their own API keys for third-party providers with a gateway. When a BYOK key is configured, requests route through the user's own account at the provider, incurring zero markup from the gateway. Keys are typically encrypted at rest (AES-256) and never stored in plaintext.
A category belief is a confidence-weighted assertion about which tool is best for a given task category. Beliefs are formed from usage data, success rates, and explicit challenges, and they evolve over time. When a new tool consistently outperforms the current champion, the belief shifts. This is how ToolRoute's librarian learns which tools to recommend.
A champion is the highest-confidence tool for a given category in the ToolRoute registry. Champions are determined by category beliefs which track usage patterns, success rates, and quality scores. Any tool can challenge the current champion by providing evidence of superior performance, triggering a belief update if the evidence is strong enough.
A composite is a pre-built multi-tool workflow that chains several tool calls into a single logical operation. For example, a 'research and summarize' composite might chain a web search, a page scrape, and an LLM summarization into one request. Composites are reusable, versioned, and billed as the sum of their constituent tool costs.
Credits are the internal billing unit in prepaid tool-access platforms. Users purchase credits in advance (typically via Stripe), and each tool call deducts a small amount based on the operation's cost. Credits provide predictable billing, prevent surprise charges, and let developers set hard spending limits for their AI agents.
Function calling is a capability of large language models (like GPT-4, Claude, and Gemini) that lets the model output structured JSON describing a function it wants to invoke rather than generating free-form text. The host application then executes the function and feeds the result back to the model. Function calling is the mechanism that turns an LLM into an agent that can take actions in the real world.
JSON-RPC is a lightweight remote procedure call protocol encoded in JSON. Both MCP and A2A use JSON-RPC 2.0 as their wire format, sending requests with a method name, parameters, and an ID, and receiving responses with a result or error. Its simplicity and language-agnosticism make it a natural fit for AI tool protocols.
The Model Context Protocol (MCP) is an open standard created by Anthropic that defines how AI models and agents connect to external tools and data sources. MCP provides a unified interface for tool discovery, invocation, and result handling, replacing bespoke integrations with a single protocol. It uses JSON-RPC 2.0 over multiple transport layers.
An MCP client is a component that maintains an active session with an MCP server, sending JSON-RPC requests and receiving responses. Each client typically connects to one server at a time. MCP clients handle capability negotiation, request serialization, and transport management on behalf of the host application.
An MCP gateway is an intermediary server that aggregates multiple MCP servers (or tool adapters) behind a single endpoint. It handles authentication, billing, rate limiting, and protocol translation so that a client connecting to one gateway gains access to every tool behind it. ToolRoute is an MCP gateway that exposes 50+ tools through one API key.
An MCP host is the user-facing application that orchestrates one or more MCP clients and presents tool capabilities to the end user or AI model. Examples include Claude Desktop, VS Code with Copilot, and custom agent applications. The host is responsible for security policy, user consent, and deciding which tools the model can access.
An MCP registry is a searchable catalog of available MCP servers and tools. Registries let agents discover what capabilities exist before building custom integrations. ToolRoute functions as both a registry (searchable catalog with category beliefs and usage data) and a gateway (direct execution through a unified API).
An MCP server is a program that exposes tools, resources, and prompts to MCP clients over a standardized transport (stdio, SSE, or Streamable HTTP). Each server typically wraps one external service or data source, translating MCP JSON-RPC calls into provider-specific API requests. Servers declare their capabilities during the initialization handshake.
Prepaid billing is a payment model where users fund their account with credits before making tool calls. Each API request deducts credits based on the operation's cost. This model prevents unexpected charges, simplifies metering for micro-transactions (fractions of a cent per call), and gives developers hard spending limits for autonomous agents.
In MCP, a prompt is a reusable template that defines a specific interaction pattern for an AI model. Prompts are one of the three core primitives alongside tools and resources. They are user-controlled, meaning the host application decides when and how to surface them. Prompts can include arguments, multi-turn message sequences, and embedded resource references.
In MCP, a resource is a read-only data source that an MCP server exposes to clients. Resources are identified by URIs and can represent files, database records, API responses, or live system data. They are application-controlled, meaning the host decides how to incorporate them into the model's context. Resources support subscriptions for real-time updates.
Server-Sent Events (SSE) is a transport mechanism where the server pushes real-time updates to the client over a long-lived HTTP connection. In MCP, SSE transport was used in earlier protocol versions for server-to-client streaming. It has largely been superseded by Streamable HTTP, which provides bidirectional communication in a single request-response cycle.
Stdio (standard input/output) is the simplest MCP transport, where the client spawns the server as a child process and communicates by writing JSON-RPC messages to stdin and reading from stdout. Stdio is easy to set up for local development but does not scale to multi-tenant or remote deployments because each client session requires its own server process.
Streamable HTTP is the recommended remote transport for MCP. The client sends JSON-RPC requests via HTTP POST, and the server can respond with a single JSON result or upgrade to a Server-Sent Events stream for long-running operations. This gives the simplicity of REST for quick calls and the streaming capability of SSE when needed, all through a single endpoint.
In MCP, a tool is an executable operation that an MCP server exposes to AI models. Tools are one of the three core primitives alongside resources and prompts. They are model-controlled, meaning the AI model decides when to invoke them (with human-in-the-loop approval from the host). Each tool has a name, description, and a JSON Schema defining its input parameters.
A tool call is a structured request from an AI model (or agent) to execute a specific operation. It includes the tool identifier and a JSON object of input parameters. In MCP, tool calls are sent as JSON-RPC requests with the method tools/call. The gateway validates the request, routes it to the correct adapter, and returns a tool result.
A tool result is the structured response returned after a tool call executes. It contains the output data from the external service (text, JSON, images, or binary), plus metadata like execution time and cost. In MCP, tool results are returned as JSON-RPC responses with content arrays that can include text and image blocks.