Agentic AI, defined
The Motiontic glossary defines the terms used in building AI agents and AI products, one term per page, each opening with a single-sentence definition.
All glossary
A2A protocol
The open protocol for agents talking to other agents, now under the Linux Foundation.
Agent Card (A2A)
The business card an A2A agent publishes so other agents can find and call it.
Agent-computer interface (ACI)
The tools, docs and outputs an agent sees, designed as carefully as a UI.
Agent framework
A library of agent building blocks: loop, tools, memory, orchestration and traces.
Agent gateway
One control point for every call an agent makes.
Agent graph
Nodes for model calls and code, edges for what runs next, and state that flows through.
Agent handoff
One agent passes the conversation to another, which carries on from there.
Agent harness
The loop, tools, context, permissions and state that sit around the model.
Agentic AI
AI that acts toward a goal, from model-assisted workflows to fully model-directed agents.
Agentic coding
Engineers delegate whole tasks to a coding agent and spend their time on direction and review.
Agentic eagerness
The dial between an agent that over-explores and one that hands back too soon.
Agentic search
Retrieval as a tool the agent calls, step by step, rather than a pipeline stage.
Agentic workflow
Model calls on a path set in code: predictable, cheaper and easier to test than a free-running agent.
Agent identity
Each agent gets its own credential, permissions and audit trail.
Agent loop
Model call, tool call, result, repeat: the cycle at the centre of every agent.
Agent memory
Session state for the task at hand, plus stored knowledge the agent recalls later.
Agent observability
Step-by-step traces of what an agent did, why, and what it cost.
AgentOps
DevOps and MLOps, adapted for systems that decide their own next step.
Agent orchestration
The logic that decides what runs next, with what context, and who combines the results.
Agent quality flywheel
Production failures feed the eval suite, and the suite gates the next release.
Agent runtime
Where agents actually run: durable sessions, checkpoints, sandboxes and resume.
Agent sandbox
Hard walls around where an agent can read, write and connect.
Agent Skills
Folders of instructions, scripts and resources that an agent loads only when the task needs them.
AGENTS.md
A README for coding agents: the file an agent reads first in a repo.
Agent state
The facts about where a task stands, kept as data instead of buried in chat history.
Agent teams
Several full agent sessions on one project, claiming tasks and talking to each other.
AG-UI
The protocol between an agent backend and the app a person is using.
AI agent
A model that picks its own next step and tool, in a loop, until the job is done.
AI guardrails
Checks on what goes into a model, what comes out, and what an agent is allowed to do.
AI hallucination
Confident output that is not true, and how production systems contain it.
AI red teaming
Attacking an AI system on purpose, so the attacks that matter are found first.
Amazon S3 Vectors
Vector storage and similarity search built into S3, priced like storage rather than a database.
Approval fatigue
Too many approval prompts, and people stop reading them.
Artifacts (AI agents)
Large data kept out of the prompt, or outputs that show a person what the agent did.
Attention budget
Every token in context costs some of the model's focus, not just some of its window.
Augmented LLM
A model plus retrieval, tools and memory: the unit every workflow and agent is built from.
Background agent
An agent that works while nobody watches, and hands back a pull request.
Blast radius (AI agents)
The worst an agent could do, measured by what it can reach.
BM25
The keyword ranking function behind most full-text search, and half of hybrid search.
Capability eval
Hard tasks the agent fails today, kept to measure progress.
Chain-of-thought prompting
Asking the model to show its working, now mostly built into the model itself.
Chunking (RAG)
Splitting documents into passages before indexing, which quietly sets retrieval quality.
Classifier-gated permissions (auto mode)
A model reviewer in place of a permission prompt, with published error rates.
Claude Agent SDK
Claude Code's harness as a library: the same loop, tools and context management, in a team's own process.
Coding agent
An agent with a shell and a repository: it reads, edits, runs the tests and tries again.
ColPali
Searching PDFs as images, with one vector per patch instead of extracted text.
Compaction
Summarise the old turns, keep working: the standard move for long agent runs.
Computer use agent
Agents that work through the screen for systems with no API.
Context anxiety
The model thinks it is running out of room, so it rushes to finish.
Context editing
Clear the old tool results, keep the conversation, keep the agent running.
Context engineering
Curating everything in the model's view, not just the wording of the prompt.
Context reset
Throw away the window, keep the handoff, start the next session clean.
Context rot
Why agents get worse the longer they run, and what keeps context clean.
Contextual retrieval
Give every chunk a line of context before it is indexed, so it can still be found.
Context window
The model's working memory for one request, measured in tokens, and finite.
Cosine similarity
The angle between two embeddings, and the default way to compare them.
Deep Agents
LangChain's batteries-included, model-neutral harness for long-running agents.
Delegated approval
An approval gate that can wait days without costing anything.
Deployment overhang
Models could do more on their own than they are currently allowed to.
DiskANN
Graph vector search that lives on SSD, not in RAM.
"Done when" criteria
Completion written down as checks before the agent starts, not judged after.
Dual LLM pattern (privileged and quarantined LLMs, CaMeL)
Keep the model that acts away from the text an attacker controls.
Durable execution
Runs that survive crashes and pauses because every finished step is recorded.
Durable project memory
The spec, plan and status files a long agent run is anchored to.
Embeddings
Meaning turned into vectors, so similar things can be found by distance.
Eval
Repeatable, scored tests that tell a team whether an AI change made things better or worse.
Eval awareness
When the model notices the test, the score stops meaning what it should.
Eval harness
The machinery that runs evals, separate from the agent it tests.
Eval saturation
When every score is near 100% and the eval stops telling anyone anything.
Execution derailment
When an agent loop loses the thread as its context fills up.
Extended thinking
Claude reasoning in thinking blocks before it answers, now steered by effort.
Few-shot prompting
Teaching a model the task by showing a few examples, not by retraining it.
Filtered vector search
Vector search with a WHERE clause, which is harder than it looks.
Fine-tuning
Changing the model itself with examples, rather than changing what it is shown.
Generator-critic loop
One model drafts, another grades, and the loop runs until the grade passes.
Golden dataset
The reviewed, versioned test cases an eval trusts as ground truth.
Golden principles
Repo rules that background agents enforce continuously, like garbage collection for code.
Google ADK
Google's open-source agent framework, now with graph workflows, in five languages.
Grader (AI evals)
The part of an eval that decides pass or fail.
GraphRAG
RAG over a model-built knowledge graph, for questions about a whole corpus.
Harness engineering
Designing the environment an agent works in, so its output can be checked and shipped.
HNSW
The layered graph index behind most vector search.
Human in the loop
Approval gates where a person decides, placed by risk rather than on every step.
Hybrid search
Keyword ranking and vector similarity, fused into one result list.
Infrastructure noise (evals)
Score changes that come from the machine, not the model.
Initializer agent
The one-off first session that sets up everything later agent sessions rely on.
IVF index
Vector search by clusters: pick the nearest few, scan only those.
Just-in-time context
Keep the address in context, fetch the contents when the step needs them.
Large language model (LLM)
A next-token predictor trained at scale, and the engine inside every AI agent.
Late interaction (ColBERT)
Many vectors per passage, matched token by token: finer retrieval, more storage.
LLM as a judge
A model grading model output against a rubric, checked against human labels.
Long-running agent
Agents that work for hours or days, and the state that lets them pick up where they stopped.
Long-term memory (AI agents)
What an agent keeps after the conversation ends, and the rules for writing and recalling it.
Manager pattern (agents as tools)
One agent stays in charge and calls specialist agents the way it would call any other tool.
Matryoshka embeddings
Embeddings that can be cut short, like nested dolls, without starting over.
MCP server
The program that wraps a system so any MCP-compatible agent can use it.
Memory tool
A file directory Claude can read and write across sessions, stored where the developer chooses.
Meta-harness (brain vs hands)
Stable interfaces that split reasoning, execution and memory so each can fail alone.
Microsoft Agent Framework
Microsoft's one forward path for agents, replacing Semantic Kernel and AutoGen.
Model Context Protocol (MCP)
The open standard for plugging tools and data into AI agents.
Model-native harness
A harness shipped by the model's own maker, tuned to how that model works.
Multi-agent system
Several agents splitting one job, with some way of coordinating who does what.
Multimodal RAG
RAG over scans, slides, charts, audio and video, not only extracted text.
Narrative casting
Show the next agent what another agent did, labelled as someone else's work.
No-code agent builder
Build an agent by configuring it in a visual tool instead of writing code.
Object-storage vector database
Vector search built on S3-style storage, with a cache for the hot data.
Online evals
Grading live traffic in production, not only test sets before release.
OpenAI Agents SDK
OpenAI's code-first agent framework: a small set of primitives that run in a team's own app.
OpenTelemetry GenAI semantic conventions
Standard gen_ai.* names for agent and model telemetry, still at Development status.
Orchestrator-worker pattern
A lead agent plans, workers run in parallel with their own context, the lead merges.
Parallelization (agent pattern)
Several model calls at once, on separate parts of a task or as repeated votes, merged in code.
Parallel tool calls
Several tool calls in one model turn, run together to save round trips.
pass@k and pass^k
Can the agent do it at all, versus does it do it every time.
Plan-and-execute agent
Plan the whole task first, then execute the steps, and replan only when something breaks.
Programmatic tool calling
The model writes a script that calls the tools, so raw results never fill its context.
Progressive disclosure
Show the menu first, load the dish only when it is ordered.
Prompt caching
Paying less for the part of the prompt that does not change between calls.
Prompt chaining
A fixed sequence of model calls, each one easier than the whole task, with checks in between.
Prompt injection
Untrusted text that hijacks a model's instructions, and how agents are built to survive it.
Query rewriting
Fixing the question before searching, so retrieval has something to match.
ReAct agent
Reason, act, observe, repeat: the pattern most agent loops descend from.
Reasoning model
A model that thinks before it answers, at a price in tokens and time.
Recall@k
Did the right passages make the shortlist? The first number to check in RAG.
Reciprocal rank fusion (RRF)
Merging keyword and vector results by rank, not by score.
Regression eval
The suite that catches what a change broke before users do.
Reranker
A second pass that rereads the shortlist and puts the right passages first.
Retrieval-augmented generation (RAG)
Fetch the right passages at query time, then answer from them with citations.
Right altitude (system prompts)
Specific enough to steer, general enough not to break: the target for a system prompt.
Routing (agent pattern)
Classify first, then send each input to the branch built for it.
Self-reflection (agents)
An agent critiques its own attempt in words and tries again with that critique in hand.
Semantic cache
Reuse an answer when a new question means the same as an old one.
Session (AI agents)
The durable log of a run, kept outside the window, that every prompt is built from.
Source-sink analysis
Find where attacks get in and what they could reach, then cut the path.
Sparse vectors (SPLADE)
Learned keyword weights: the middle ground between BM25 and dense embeddings.
Spec-driven development
Write down what the software must do first, then let the coding agent plan and build against it.
Sprint contract
Generator and evaluator agree on done before any code is written.
Structured note-taking
The agent keeps its own notebook outside the context window, in a format it can trust.
Structured outputs
JSON that matches the schema because the decoder allows nothing else.
Subagent
A helper agent with a clean context that hands back a short answer.
Subagent sprawl
Too many overlapping subagents, each owned by a different team and none by the whole.
System prompt
The standing instructions that frame every turn of a conversation or agent run.
Task, trial and transcript (eval vocabulary)
The basic units every agent eval is built from.
Temperature (LLM sampling)
The randomness knob on token sampling, and why the newest models dropped it.
Think tool
A tool that does nothing, so the model has somewhere to stop and think between actions.
Token (LLM)
The unit models read, write and bill in: a word or a piece of one.
Tool calling
How a model asks software to do something: a named tool, typed arguments, a result.
Tool preamble
The plain-language plan and progress notes a model writes around its tool calls.
Tool risk rating
Sorting an agent's tools by how much damage a bad call could do.
Tool search
Load tools when they are needed, not all at once before the work starts.
Tool use examples
Sample calls on a tool definition that teach usage a schema cannot.
Trace grading
Scoring a whole recorded agent run, step by step.
Trajectory evaluation
Grading the route an agent took, not just where it ended up.
Trimming vs summarization
Drop the old turns or compress them: the two basic short-term memory tactics.
turbopuffer
Vector and full-text search built on object storage, priced for very large and many-tenant corpora.
Vector database
Storage and nearest-neighbour search for embeddings, now in many shapes.
Vector quantization
Fewer bits per dimension: smaller, cheaper indexes at a small cost in recall.
Vibe coding
Prompt, accept, run, repeat: building by results without reading the code.
Working context
The per-call view of the agent's state, compiled fresh for each model call.
Running agents that have to hold up?
Describe the agent, the systems it touches and what it must never get wrong. The first call is with a lab engineer, who will say plainly whether it is ready for production, and whether Motiontic is the right team.