This is a reference piece, not a news issue — a plain-language glossary of the terms that come up most often in this newsletter. It's meant to be a page you can link back to, not something you need to read start to finish. Terms are listed alphabetically. We'll expand this as new terminology enters common use in the field.

Agent Memory The mechanism by which an AI agent retains information across steps of a task, or across separate sessions, rather than treating every interaction as a blank slate. Short-term ("working") memory usually lives in the context window for the duration of a task; longer-term memory is typically stored externally (a database or vector store) and retrieved when relevant. Memory design is one of the harder open problems in agent engineering, since too little memory causes repeated mistakes and too much can introduce stale or contradictory context.

Agent Orchestration The layer of software that coordinates multiple agents, tools, and steps toward a larger goal — deciding what runs next, in what order, and how results get passed along. In enterprise deployments, orchestration is usually where governance controls (approval steps, spending limits, escalation rules) actually get enforced, which is why it's treated as a distinct discipline from building any single agent.

Agent2Agent Protocol (A2A) An open standard, originally introduced by Google in 2025, that lets AI agents built on different frameworks or by different vendors discover each other's capabilities and communicate directly to coordinate on a task. It addresses a specific enterprise pain point: agents built by different teams or vendors that can't otherwise talk to one another. In August 2026 stewardship of A2A moved to the vendor-neutral Agentic AI Foundation, whose membership has grown from under 40 to more than 250 organizations since December 2025 — a sign of how quickly the industry is consolidating around shared agent-interoperability standards. (background)

Agentic AI A system that can independently plan, reason across multiple steps, and coordinate actions across several agents, tools, and systems to reach a broader goal — as opposed to a single agent completing one well-defined task. Agentic AI is meant to handle end-to-end workflows that span departments or applications, adapting as conditions change along the way, which also means it needs more governance and oversight than a narrow, single-purpose agent.

AI Agent A software system that perceives information, reasons over it, and takes action to accomplish a defined goal — typically operating within clear boundaries on a specific, well-scoped task (validating a record, classifying a ticket, retrieving a document) rather than an open-ended objective. This is the basic building block that larger "agentic AI" systems are composed of.

Autonomous Workflow A business process where an AI agent (or several, coordinated through orchestration) completes an end-to-end task without a human performing each individual step — though it may still include human checkpoints at points of real consequence. The distinction from simple automation (a fixed script or rules engine) is that an autonomous workflow can adapt its steps based on what it encounters, rather than following one rigid path every time.

Evals Short for "evaluations" — the tests used to measure whether an agent is actually doing its job correctly, safely, and consistently, both before deployment and on an ongoing basis in production. Because agents can fail in ways traditional software testing doesn't catch (a technically "successful" tool call that nonetheless does the wrong thing), evals have become their own specialty within agent engineering rather than an afterthought.

Function Calling / Tool Use The capability that lets a language model invoke external functions, APIs, or tools mid-conversation — running a calculation, querying a database, sending an email — rather than just generating text. This is the foundational capability that turns a conversational model into something that can take real action, and it's what most "AI agent" products are built on top of.

Governance (AI/Agent Governance) The policies, approval workflows, and audit mechanisms an organization puts around what its AI agents are allowed to do — which systems they can touch, what actions require human sign-off, and how their decisions get logged for later review. As agents move from answering questions to taking real actions in production systems, governance has shifted from a compliance afterthought to a prerequisite for deployment at most enterprises.

Guardrails The technical constraints placed on an agent to keep it operating within intended bounds — input/output filtering, hard limits on which actions it can take, or automatic checks that catch and stop clearly wrong behavior before it causes damage. Guardrails are usually the first thing added once a system moves from a controlled pilot into production, where the range of things that can go wrong is much less predictable.

Human-in-the-Loop (HITL) A design pattern where a human explicitly reviews or approves an agent's proposed action before it executes, typically reserved for higher-stakes decisions (sending money, deleting records, external communications). It's the most common way enterprises currently balance the efficiency of automation against the risk of an agent making a costly mistake unsupervised.

Model Context Protocol (MCP) An open standard, introduced by Anthropic, for connecting AI applications to external data sources, tools, and workflows in a consistent way — often described as a "USB-C port" for AI applications, since it replaces one-off custom integrations with a single standard interface. Broad adoption across major AI assistants and developer tools since its introduction has made it one of the more consequential pieces of shared infrastructure in the agent ecosystem. (official docs)

Multi-Agent System An architecture where several distinct agents, often each specialized for a narrower task, work together (via orchestration and protocols like A2A) rather than relying on one large, general-purpose agent to do everything. The appeal is similar to microservices in traditional software: smaller, more reliable, more independently testable components — at the cost of needing real coordination infrastructure to make them work together.

Observability (Agent Observability) The tooling and practices used to see what an agent is actually doing while it runs — which tools it called, what it reasoned, where it succeeded or failed — rather than treating it as a black box that either produces a right answer or doesn't. This has become its own category of enterprise software, largely because debugging an agent after the fact is far harder than debugging conventional code without this kind of trace.

Prompt Injection An attack where malicious instructions are hidden inside content an agent processes (a webpage, a document, an email) with the goal of hijacking the agent into taking unintended actions. It's one of the most-cited security concerns specific to agentic systems, precisely because an agent that can browse content and take actions creates a new attack surface that didn't exist in a plain chatbot.

Retrieval-Augmented Generation (RAG) A technique where a model's response is grounded in specific documents or data retrieved at the moment of the query, rather than relying solely on what it learned during training. In enterprise settings this is the standard way to get an agent to answer accurately about internal, proprietary, or fast-changing information a general-purpose model was never trained on.

Task Decomposition The process of breaking a large, ambiguous goal into smaller, well-defined steps an agent (or set of agents) can actually execute and verify individually. Most of the practical difference between a demo that works once and a system reliable enough for production comes down to how well this decomposition is designed.

If you found this page through a search rather than your inbox: this is one piece of The Autonomous Edge, a weekly briefing on AI agents and enterprise automation — real deployments, funding, security disclosures, and the adoption data behind the headlines. Subscribe at https://buttondown.com/TheAutonomousEdge.

See also: the Field Guide series for deeper dives into specific topics.