Agent2Agent protocol — an open standard (Google, now a Linux Foundation project) for how independent, opaque agents discover one another and collaborate on stateful tasks over JSON-RPC 2.0 across organizational and framework boundaries.
a2a-artifact
A durable output an A2A agent produces during a task (document, image, structured data), composed of Parts with a stable artifactId; can be streamed in incremental chunks.
a2a-message
A single turn of A2A communication, carrying a role ("user" or "agent") and an array of typed Parts, plus a messageId and the literal kind "message".
a2a-part
The smallest unit of A2A content within a Message or Artifact, a kind-discriminated union: TextPart (kind "text"), FilePart (kind "file", bytes or uri), or DataPart (kind "data").
a2a-task
A2A's stateful unit of work, with a unique id, a contextId grouping related work, a status holding the current TaskState, and accumulated message history and artifacts.
acp
Agent Communication Protocol — an open, REST-based, async-first protocol (originally from IBM Research / BeeAI) for communication between AI agents, applications, and humans, using GET /agents discovery, POST /runs invocation, and MIME-typed multipart messages; merged into A2A under the Linux Foundation in 2025.
adk
Google's Agent Development Kit — a model-agnostic, deployment-agnostic orchestration framework offering LlmAgents and deterministic workflow agents (sequential, parallel, loop), with native MCP tool support and direct A2A implementation via A2AServer and RemoteA2aAgent.
agent
A single language-model-driven actor that pursues a goal by using tools in a loop, deciding for itself what action to take next based on feedback from its environment.
agent-badge
AGNTCY Identity's core credential — an enveloped Verifiable Credential captured as a JSON-LD object that asserts a specific definition of an agent (MCP server, or multi-agent system) under a given schema, such as an OASF definition or an A2A Agent Card; an entity may hold several badges for nuanced, least-privilege access.
agent-card
A JSON metadata document published by an A2A server (canonically at /.well-known/agent-card.json) describing the agent's identity, service endpoint, capabilities, skills, and authentication requirements.
agent-computer-interface
SWE-agent's term (ACI) for the purpose-built interface layer through which an LM agent perceives and acts on a computer — commands and feedback formats tailored to the model rather than to a human, whose design significantly affects agent performance.
agent-description-protocol
ANP's application-layer self-description — a JSON-LD ("AgentDescription") document carrying protocolType "ANP", name, did, url, securityDefinitions/security, and a list of interfaces (NaturalLanguageInterface or StructuredInterface over OpenRPC/MCP/WebRTC/OpenAPI), made tamper-evident by a signed proof.
agent-directory
AGNTCY's discovery layer (the Agent Directory Service, dir/dirctl) — a federated, registry-of-registries store of content-addressed OASF records (each identified by a CID, kept in an OCI/Zot store) whose skills, domains, modules, and locators are routed to record identifiers over a Distributed Hash Table so peers can publish, list, and search agents across the network.
agent-loop
The core observe-reason-act cycle of an agent: assemble context, reason about it, emit an action (usually a tool call), receive an observation, and repeat until a stopping condition.
agent-to-agent
The full name of A2A: a vendor-neutral standard, now under the Linux Foundation, for communication and task delegation between independent AI agent systems.
agentic-rag
Retrieval-augmented generation with retrieval exposed as a tool inside the agent loop — the model decides whether and when to retrieve, grades what comes back, and rewrites queries — replacing the fixed retrieve-then-generate pipeline with autonomous retrieval decisions.
agentic-system
Software in which one or more language-model-driven agents pursue goals by repeatedly observing context, deciding on an action, and acting through tools, together with the orchestration, memory, and guardrails that connect them to the world.
agntcy
An open-source collective and component stack ("Internet of Agents") open-sourced by Cisco's Outshift and governed by the Linux Foundation, centered on the OASF schema and a federated Agent Directory for cross-vendor agent discovery, interoperable with A2A and MCP.
ambient-agent
An agent triggered by an event stream (cron, queue, webhook, inbound email) rather than a human message, running in the background with asynchronous human-in-the-loop touchpoints — notify, question, and review — instead of a live chat session.
anp
Agent Network Protocol — a decentralized, peer-to-peer agent communication standard ("the HTTP of the agentic web") built on W3C DID identity (did:wba), well-known-URI discovery, and signed JSON-LD agent descriptions, standardized via the W3C AI Agent Protocol Community Group.
autogen
A multi-agent framework that frames work as a conversation among "conversable" agents (the ConversableAgent building block); Microsoft's AutoGen was rearchitected around v0.4 into a layered Core/AgentChat/Extensions design, and AG2 is a community fork "formerly AutoGen."
blackboard
A pattern where specialist agents (knowledge sources) collaborate indirectly by reading from and writing to a shared structured workspace, with a control component deciding which agent acts next; decouples agents and suits web-like dependencies.
capability-negotiation
MCP's mechanism by which client and server each declare supported features (capabilities) during the initialize handshake; a feature is only usable in the session if its capability was declared.
claude-agent-sdk
Anthropic's SDK (Python and TypeScript) that runs the same agent loop, built-in tools, and context management that power Claude Code inside your own process, with subagents, hooks, a permission system, and first-class MCP support.
computer-use
An agent flow in which the model perceives a screen through screenshots and acts through mouse and keyboard actions, letting it operate GUIs built for humans; run in a sandboxed VM or browser because everything rendered on screen is untrusted input.
context-compaction
Taking a conversation nearing the context window limit, summarizing its contents, and reinitiating a new context window seeded with that summary. A lossy operation: the challenge is choosing what to preserve so that subtle but critical context survives the compaction.
context-engineering
The discipline of curating and maintaining the optimal set of tokens during LLM inference — managing system instructions, tools, retrieved data, and message history across a long-running agent. The successor to prompt engineering.
context-window
The finite maximum number of tokens (prompt plus generation) a model can attend to in a single forward pass; the agent's volatile working memory.
controller
The role the LLM plays in an agent loop: the policy that inspects the current context and selects the next action, rather than the entire program.
crewai
A Python agent framework built independently of LangChain whose central abstraction is a crew of role-playing agents (each with a role, goal, and backstory) running tasks under a sequential or hierarchical process, complemented by event-driven Flows.
decentralized-identifier
A globally unique, self-owned identifier (a DID) that resolves to a document of public keys and service endpoints; ANP uses the did:wba method for cross-platform agent identity.
deep-research
A flow architecture in which an agent system clarifies and plans a research question, searches broadly (often with parallel subagents), and synthesizes the findings into a long-form citation-backed report over minutes rather than seconds.
did
Decentralized Identifier — a W3C standard for self-sovereign, cryptographically verifiable identifiers that resolve to a DID document without a central registry; ANP uses the did:wba (web-based agent) method.
did-wba
ANP's "Web-Based Agent" DID method — a blockchain-free extension of did:web in which identifiers (e.g. did:wba:example.com:user:alice) resolve over HTTPS to a DID document at /.well-known/did.json, and a caller authenticates in a single request by signing a DIDWba Authorization header (did, nonce, timestamp, verification_method, signature).
elicitation
An MCP client feature by which a server requests additional information from the user during a session.
embedding
A vector (list) of floating-point numbers representing a piece of text, produced so that the distance between two vectors reflects how semantically related the inputs are; small distances mean high relatedness.
episodic-memory
Long-term memory of specific past experiences — successful interactions stored as learning examples that capture the situation, the reasoning that led to success, and why it worked, used as few-shot exemplars for future behavior.
function-calling
Another name for tool use: a model emits a structured request naming a function/tool and a JSON arguments object, which the host application executes and returns.
guardrails
Deterministic, programmatic checks placed around a model (input filters, output validators, action gates) that enforce safety and policy independently of the model's probabilistic behavior.
handoff
A direct transfer of control from one agent to another, after which the receiving agent becomes active; in the OpenAI Agents SDK handoffs are exposed to the model as tools (e.g. transfer_to_<agent_name>), and in LangGraph as a Command(goto=...).
hierarchical
A multi-agent topology that nests supervisors — a top-level coordinator manages mid-level supervisors, each running its own team of workers — to scale past a single supervisor's fan-out limit; the "supervisor of supervisors" case.
human-in-the-loop
A pattern in which a human inspects, approves, edits, or supplies input to an agent's execution at chosen points, rather than letting the agent run fully autonomously.
initialize
The first request of every MCP session, in which the client sends its protocolVersion, capabilities, and clientInfo and the server replies with its own, after which the client sends notifications/initialized.
json-ld
JSON for Linking Data — a JSON-based serialization for linked data that adds semantic context via @context; ANP's Agent Description Protocol uses JSON/JSON-LD self-descriptions.
json-rpc
A lightweight remote-procedure-call protocol that encodes requests, responses, and notifications as JSON objects with jsonrpc, id, method, params, and result/error fields; the wire format for MCP (2.0).
json-schema
A vocabulary for describing the structure of JSON data (types, enums, required fields, nested objects); used to define tool/function parameters across providers and MCP.
langgraph
A low-level, MIT-licensed orchestration framework (from the LangChain team) that models an agent as a stateful graph (StateGraph) of nodes and edges that may contain cycles, with durable execution, persistence, and human-in-the-loop.
lethal-trifecta
Simon Willison's term for the dangerous combination of three agent capabilities present at once — access to private data, exposure to untrusted content, and the ability to communicate externally — which together enable prompt-injection-driven data exfiltration.
llm-as-judge
An evaluation technique in which a strong language model, given a rubric and a candidate output, grades quality or picks a winner in a pairwise comparison; scalable but prone to biases such as position, verbosity, and self-preference.
long-term-memory
Information that persists across conversations, sessions, and threads, held in external storage (a store) and retrieved into the context window only when relevant.
mcp
Model Context Protocol — an open standard for connecting an LLM application (host) to external tools, data, and prompt templates exposed by servers, using stateful JSON-RPC 2.0 sessions over a chosen transport.
mcp-client
A connector inside an MCP host that maintains exactly one stateful session with one MCP server (a 1:1 relationship), handling capability negotiation and bidirectional JSON-RPC message routing.
mcp-host
The LLM application in MCP (e.g. an AI IDE or chat app) that owns the model and the conversation, creates and manages clients, enforces consent and security policy, and aggregates context across all of its server connections.
mcp-prompt
An MCP server primitive: a reusable, parameterized message template discovered via prompts/list and rendered via prompts/get; it is user-controlled (often surfaced as a slash command).
mcp-resource
An MCP server primitive: data identified by a URI that provides context to the model, discovered via resources/list and retrieved via resources/read; it is application-driven.
mcp-server
An MCP service that exposes resources, tools, and prompts to a client; it runs locally or remotely, operates with a focused responsibility, and may initiate sampling, roots, or elicitation requests back through the client.
mcp-tool
An MCP server primitive: a named, JSON-Schema-described function the model can discover via tools/list and execute via tools/call; it is model-controlled.
meta-protocol
ANP's middle layer, in which two agents that share no predefined interface negotiate how they will communicate using natural-language descriptions and AI code generation — producing, debugging, and deploying the agreed protocol at connection time and caching it for reuse, so the wire contract is emergent rather than pre-standardized.
model-context-protocol
The full name of MCP: an open, JSON-RPC-based standard, introduced by Anthropic in November 2024, for connecting agents to external tools, resources, and prompts.
multi-agent
An architecture that splits a problem across several agents, each with its own instructions, tools, and often its own context, coordinated by a control structure; traded against higher token, latency, and coordination cost versus a single agent.
multi-agent-system
An agentic system that decomposes a goal across several specialized, coordinating agents (e.g. planner, worker, critic), often owned by different teams or organizations.
oasf
Open Agentic Schema Framework — AGNTCY's extensible, schema-driven data model for describing an agent (skills taxonomy, domains, modules, extensions, locators), published as records in the Agent Directory and able to wrap A2A Agent Cards and MCP servers.
oasf-record
The core data structure of OASF — a record object built from typed fields, objects, and classes (where classes belong to the Skills, Domains, and Modules families) that describes one agent, annotated with skills and domains for discovery and carrying locators; published to the AGNTCY Agent Directory and addressed there by its CID.
observability
The discipline of making an agent's runtime behavior inspectable after the fact by recording every prompt, tool call, observation, cost, and latency, so failures can be replayed and understood.
openai-agents-sdk
OpenAI's lightweight production framework, the successor to the experimental Swarm project, built around three core primitives — agents (equipped with tools), handoffs, and guardrails — with handoffs exposed to the model as tools and built-in tracing.
orchestration
The coordination strategy that routes work and messages among multiple agents — e.g. supervisor/worker hierarchies, sequential or parallel pipelines, routing, and reflection.
orchestrator-worker
Anthropic's pattern in which a central LLM dynamically breaks a task into subtasks (not predefined), delegates them to worker LLMs, and synthesizes their results; suited to complex tasks whose decomposition can't be predicted in advance.
parallel-tool-calls
When a model requests multiple independent tool invocations in a single assistant turn; all corresponding results must be returned together in one subsequent message.
planning
A pattern in which an agent devises a multi-step plan before acting (plan-and-execute), reducing missing-step errors; robust planners re-plan when observations invalidate the plan.
policy
The mapping from an agent's percept history to its next action — reinforcement learning's name for the decision rule; in an LLM agent this role is played by the prompted model itself rather than by hand-coded logic.
prompt-injection
An attack in which adversarial instructions are smuggled into content an LLM processes; because instructions and data share one channel with no privileged separation, the model may obey the injected instructions. Direct injection comes from the user; indirect injection arrives via tool or MCP output the agent reads.
push-notification
An A2A mechanism where the server POSTs asynchronous task updates to a client-registered webhook URL, letting the client disconnect; configured via tasks/pushNotificationConfig/set.
rag
Retrieval-augmented generation: an architecture that combines a model's parametric memory (knowledge in its weights) with non-parametric memory (an external index), retrieving relevant passages and conditioning generation on them. Introduced by Lewis et al. (NeurIPS 2020).
rational-agent
In the classical Russell & Norvig definition, an agent that for each possible percept sequence selects the action expected to maximize its performance measure, given the evidence of its percepts and its built-in knowledge.
react
A reasoning pattern (Yao et al., 2022/2023) that interleaves free-form reasoning traces ("thoughts") with tool actions in the same loop, augmenting the action space with language so the model can plan and self-correct between grounded actions.
reflection
A pattern in which an agent critiques its own output and feeds the critique back as context for a later attempt; Reflexion formalizes this as verbal reinforcement stored in memory, improving behavior without updating model weights.
rest
Representational State Transfer — an architectural style using standard HTTP methods and resource URLs; ACP's transport, contrasting with the JSON-RPC envelopes used by MCP and A2A.
roots
An MCP client feature by which a server inquires which filesystem or URI boundaries it is permitted to operate within.
router
A lightweight dispatcher that classifies an input once and directs it to a specialized downstream handler (e.g. cheap vs expensive model), then steps out of the way — unlike a supervisor, which stays in the loop across many delegation rounds.
sampling
An MCP client feature that lets a server ask the host's LLM to generate a completion, enabling agentic and recursive behavior; the protocol limits the server's visibility into the prompt and requires user approval.
sandboxing
Running an agent's tools — especially code execution and file access — inside an isolated environment with restricted or no network egress and no host secrets, so a hijacked agent cannot reach beyond its box.
semantic-kernel
Microsoft's multi-language (.NET, Python, Java) SDK that hosts plugins (callable functions, importable from native code, OpenAPI, or MCP servers) on a central Kernel, with an Agent Framework providing agent types such as ChatCompletionAgent and AzureAIAgent.
semantic-memory
Long-term memory of facts and general knowledge that ground an agent's responses, stored either as an unbounded searchable collection or as a schema-constrained profile.
server-sent-events
A unidirectional HTTP streaming mechanism in which a server pushes a stream of text/event-stream events to a client over one connection; ACP uses SSE for its streaming run mode.
short-term-memory
Information an agent retains within a single conversation or session — the running message transcript and scratchpad — replayed into the context window each turn and typically persisted by a checkpointer keyed to a thread.
slim
Secure Low-Latency Interactive Messaging — AGNTCY's secure transport layer for agent communication, built on gRPC over HTTP/2 and extended beyond request/reply to publish/subscribe, streaming, fire-and-forget, and group/channel patterns, with end-to-end Message Layer Security (MLS) encryption and a SLIMRPC (SRPC) protobuf-RPC facility; it carries protocols such as A2A and MCP.
sse
Server-Sent Events — a one-way HTTP streaming format (Content-Type text/event-stream) used by MCP's Streamable HTTP transport to deliver multiple server-to-client messages over a single response.
stdio-transport
An MCP transport in which the client launches the server as a subprocess and exchanges newline-delimited JSON-RPC messages over its stdin and stdout (with stderr available for logs).
streamable-http
The current MCP remote transport: JSON-RPC over a single HTTP endpoint supporting POST and GET, optionally using Server-Sent Events to stream server messages; it replaces the older HTTP+SSE transport.
structured-output
A guarantee that a model's output conforms to a supplied JSON Schema, achieved via strict tool definitions or a JSON-Schema response format rather than free-form text.
supervisor
A coordinating agent that owns a goal and delegates scoped subtasks to specialist worker agents, deciding who runs next and (often) synthesizing their results, without doing the domain work itself; also called orchestrator or lead/manager agent.
swarm
A decentralized multi-agent pattern (popularized by OpenAI's experimental Swarm framework) with no central coordinator, where agents transfer control to one another via handoffs as the conversation flows.
task-state
The lifecycle state of an A2A task; the spec defines submitted, working, input-required, auth-required, completed, canceled, failed, rejected, and unknown, with the last four terminal.
tool-result
The block returned to the model after a tool runs: in the Anthropic API a type "tool_result" block carrying tool_use_id, content, and an optional is_error flag.
tool-schema
The definition of a tool the model may call — a name, a natural-language description, and a JSON Schema for its parameters (input_schema in Anthropic, parameters in OpenAI).
tool-use
An agent's ability to invoke typed, named capabilities (read a file, query a database, call an API) by name with structured arguments, feeding the result back into the loop. The LLM-API "tool_use"/"tool_result" content blocks live at this layer, distinct from MCP's own wire format (a tools/call request whose response carries a content field).
tool-use-block
The structured call a model emits to invoke a tool — in the Anthropic API a type "tool_use" block with a unique id, the tool name, and an input arguments object.
tracing
Recording an agent run as a tree of timed, nested spans (a root span for the run, child spans for each model call and tool call), the core primitive of observability.
trajectory-eval
Evaluating an agent by the sequence of steps it took — which tools were called, in what order, with what arguments, and whether the intermediate reasoning was sound — rather than only the final outcome.
vector-store
A database that stores embeddings and answers nearest-neighbor (similarity) queries efficiently, returning the k items whose vectors are closest to a query vector. It is the non-parametric memory of a RAG system.
verifiable-credential
A W3C-standard, cryptographically signed claim about a subject; in AGNTCY Identity an agent's universally unique identifier is bound to one or more VCs (whose enveloped JSON-LD form is the Agent Badge), giving the three identity properties of Open, Collision-free, and Verifiable.
well-known-uri
A standardized, predictable URL path under /.well-known/ (per RFC 8615) where a service publishes metadata, such as A2A's agent card or an OAuth resource-metadata document.