Part VIII · Reference
2026 Landscape & Complete Glossary
What's happening in agentic AI right now, and a complete A–Z reference of every term in the field — 150+ definitions with examples
Chapter 30The 2026 Agentic AI Landscape
The agentic AI field is moving fast. This chapter captures the practical landscape engineers should understand in 2026 — frameworks, protocols, capability trends, and what is likely to matter next.
Framework ecosystem — practical positioning
| Framework | Best fit | Why engineers use it | Watch-outs |
|---|---|---|---|
| LangGraph | Stateful, long-running workflows | Durable execution, checkpoints, streaming, human-in-the-loop, explicit graph control | Lower-level API; you own architecture decisions |
| CrewAI | Role-based multi-agent teams | Fast prototyping with agents, tasks, crews, delegation, and readable team structure | Less natural for complex state machines and strict audit flows |
| OpenAI Agents SDK | Managed agent loops on OpenAI models | Agents, tools, handoffs, guardrails, tracing, sessions, and MCP support in one SDK | Best when your stack is already comfortable with OpenAI primitives |
| Pydantic AI | Typed outputs and validation-heavy agents | Pydantic-native schemas, structured results, retries, and strong Python developer experience | Keep examples tied to the installed version; APIs move quickly |
| AutoGen / AG2 | Research and conversational multi-agent experiments | Good for exploring agent collaboration, group chat, and iterative workflows | Production patterns need careful evaluation and observability |
| Google ADK | Google Cloud and A2A-oriented agents | Useful when building around Gemini, Vertex AI, and Google's agent ecosystem | Cloud coupling may be a trade-off for portable systems |
| Smolagents | Minimal code-agent experiments | Small surface area, Hugging Face ecosystem fit, quick local prototyping | Not a complete production platform by itself |
| LlamaIndex | RAG and knowledge-heavy applications | Strong indexing, retrieval, document workflows, and agentic RAG patterns | Use evals to tune retrieval, not framework defaults alone |
Protocol adoption
| Protocol | Released | Role in the stack | Governance / source |
|---|---|---|---|
| MCP | Nov 2024 | Standard way for AI applications to connect to tools, data sources, and workflows | Open protocol with official specification and SDK ecosystem |
| A2A | Apr 2025 | Standard way for independent agents to discover each other, exchange messages, and manage tasks | Linux Foundation A2A project specification |
| ANP (Agent Network Protocol) | 2025 | Emerging agent networking proposal; worth watching, not a default choice yet | Ecosystem proposal |
LLM capabilities — what changed in 2025–2026
- Reasoning models — models increasingly expose stronger planning, tool-use, and multi-step problem-solving behavior. In practice, treat them as better task planners, not magic correctness machines.
- Multimodal tool use — agents can now receive images, audio, and video as tool results, not just text. Vision-capable tool calling enables new categories of agents.
- Computer use — Claude Computer Use, Operator (OpenAI), and similar let agents control browsers and desktop apps directly. Web scraping agents no longer need custom scraper code.
- Context windows — Gemini 1.5/2.0 at 1M+ tokens enables new patterns: entire codebases in context, full document libraries, hour-long meeting transcripts.
- Local and hosted open models — Llama, Mistral, Gemma, Phi, and similar model families enable lower-cost, private, or offline agent patterns when paired with careful evals.
Industry signals — 2026
- Hiring demand is shifting from prompt-only skills toward AI platform engineering, evals, RAG, agent orchestration, and LLMOps.
- Enterprise teams are moving from demos to controlled pilots with audit trails, permissions, cost caps, and human approval flows.
- Agent session cost varies widely by model, context size, number of tool calls, retries, and whether retrieval or reranking is used.
- Production performance often trails lab benchmarks because real inputs are messy, adversarial, incomplete, and full of tool failures.
- Top hiring categories: AI Agent Engineer, AI Platform Engineer, LLM Ops Engineer
What's coming next — 2026–2028 horizon
- Persistent agent instances — agents that run continuously, not just per-session. Always-on background agents monitoring and acting on your behalf.
- Agent marketplaces — buy, sell, and compose specialised agents like SaaS. Already emerging: Zapier AI, Make.com agents, Agent.ai marketplace.
- Self-improving agents — agents that analyse their own failures, update their system prompts, and improve over time within safety bounds.
- Physical world agents — robotic arms, autonomous vehicles, smart building systems — the same agentic AI patterns applied to physical actuators.
- Agent-native databases — storage systems designed from the ground up for agent access patterns: semantic + structured + memory in one.
- Formal agent verification — mathematical proofs of agent safety properties, required for high-stakes deployments (medical, financial, legal).
Chapter 31Complete Glossary A–Z
Every term you will encounter in agentic AI — precisely defined with real examples. 150+ terms, alphabetically organised.
A
A2A (Agent-to-Agent Protocol)
An open standard for communication between independent AI agents from different frameworks or organisations. Defines Agent Cards (capability manifests), Messages, Tasks, Parts, and Artifacts. The current specification is maintained through the Linux Foundation A2A project.
A LangGraph orchestrator submits a Task to a specialist research agent via A2A — no shared framework needed.
Agent
A software system that perceives its environment, reasons about what to do next, takes actions using tools, observes results, and loops — all toward a goal given by a user or another system. Distinguished from chatbots by the ability to act, not just respond.
Agent Card
A JSON document served at /.well-known/agent.json describing an agent's capabilities, supported input/output types, authentication requirements, and pricing. The A2A discovery mechanism — agents find and understand each other by reading Agent Cards.
Agentic AI
AI systems designed to take autonomous action rather than just generate text responses. Encompasses single agents, multi-agent systems, and any architecture where LLMs drive real-world decisions and actions.
Attention mechanism
The core component of transformer neural networks. Allows each token to "look at" all other tokens in the context window when computing its representation. Foundation of context-awareness in LLMs. Quadratic in sequence length — the fundamental reason for context window limits.
Artifact (A2A)
The output of a completed A2A Task. Can be text, structured JSON, a file, or any typed content. Artifacts are versioned and can be referenced by other agents.
ANN (Approximate Nearest Neighbour)
Algorithms (HNSW, IVF, FAISS) that find vectors close to a query vector without exhaustive comparison. Trade a small accuracy loss for massive speed gains. Foundation of all production vector database search.
AutoGen / AG2
Multi-agent framework family used for conversational agent collaboration, coding workflows, and research prototypes. Strong when you want to explore agent-to-agent interaction patterns before hardening a production architecture.
B
BM25
Best Match 25 — the standard keyword relevance algorithm used by Elasticsearch, OpenSearch, Solr. Ranks by term frequency, inverse document frequency, and document length normalisation. No embeddings needed. Excellent for exact terminology, poor for semantic meaning.
Searching "rate limiting" with BM25 finds documents with that exact phrase. Won't find documents about "throttling" or "quota enforcement".
Budget cap
A hard cost limit per agent session or per user. When token spend exceeds the cap, the agent is forced to conclude with what it has. Essential production safety mechanism — prevents a confused agent from spending $100 on one query.
C
Chain-of-Thought (CoT)
Prompting style that asks a model to reason through a task before answering. In production agents, prefer concise planning traces or hidden/internal reasoning over exposing long private reasoning verbatim to users.
Checkpointer
In LangGraph, a mechanism that persists complete graph state after every node execution. Enables: pause-and-resume workflows, human-in-the-loop interrupts, time-travel debugging, and rollback. A Postgres-backed saver is a common production choice when durable workflow state matters.
Chunking
Splitting documents into smaller pieces for indexing and retrieval in RAG systems. Strategy choice (fixed-size, semantic, recursive, hierarchical, late) is the single biggest determinant of RAG retrieval quality.
CLEAR framework
Practical production agent evaluation frame: Cost, Latency, Efficacy, Assurance, Reliability. The five dimensions that matter beyond simple accuracy benchmarks.
Computer use (agents)
Capability allowing agents to directly control browsers, desktop applications, and GUIs. Anthropic's Computer Use, OpenAI Operator. Enables agents to interact with any software without custom API integrations.
Context window
The maximum number of tokens an LLM can process in a single call — the agent's immediate working memory. Everything the agent sees must fit here: system prompt, history, tool schemas, tool results, retrieved context, and pending response. Exact limits vary by model and change over time.
Cosine similarity
Standard metric for comparing embedding vectors. Measures angle between vectors regardless of magnitude. Score of 1.0 = identical meaning, 0 = unrelated, -1 = opposite. Vector databases typically store cosine distance (1 - similarity) for sorting.
CrewAI
Role-based multi-agent framework. Agents have roles, goals, and backstories. Tasks define what each agent produces. Crews orchestrate collaboration through sequential, hierarchical, or team-style workflows.
D
Dense embedding
An embedding where most or all dimensions have non-zero values. Captures semantic meaning. Produced by transformer-based models. Contrast with sparse embeddings which capture keyword information. Most RAG systems use dense embeddings.
Deterministic routing
Agent design pattern where routing decisions (which tool to call, which agent to hand off to) are made by deterministic code rather than LLM inference. Faster, cheaper, and more reliable for simple routing; use LLM routing only for ambiguous cases.
DuckDB
In-process analytical database. Reads CSV, Parquet, JSON directly. No server needed. Excellent for agent-side analytics, data transformation, and cost-free local OLAP queries. Increasingly used as the analytics layer in local-first agent architectures.
E
Embedding
A fixed-size array of floating-point numbers representing the semantic meaning of a piece of text. Similar texts produce nearby vectors. Generated by embedding models (OpenAI text-embedding-3, Cohere embed-v3, BGE-M3). Foundation of semantic search and RAG.
Episodic memory
Agent memory storing past interactions, decisions, and task outcomes. Like human episodic memory — "I remember doing this last Tuesday." Stored in vector DB or Postgres. Retrieved by semantic similarity to current task.
Eval harness
An automated testing system for agents. Runs a set of test cases through the agent, measures outputs against expected results or judge scores, and tracks metrics over time. Essential for catching regressions when changing prompts, models, or tools.
F
Faithfulness
RAGAS metric measuring whether every claim in the agent's answer is grounded in the retrieved documents. Score of 1.0 = zero hallucination. Target: >0.85 for production RAG systems.
FastMCP
Python framework for building MCP servers quickly. Decorator-based API — @mcp.tool() makes any Python function a tool accessible to any LLM. Part of the official MCP Python SDK.
Function calling
OpenAI's term for tool calling. The mechanism by which LLMs request execution of external functions. Synonymous with tool calling. OpenAI uses "function" schema wrapper around the same JSON Schema format.
G
GraphRAG
RAG that retrieves from a knowledge graph (Neo4j, Amazon Neptune) rather than a vector index. Translates natural language to graph queries (Cypher, Gremlin). Powerful for relationship-heavy queries: "Which investors backed both Stripe and Adyen?"
Guardrails
Safety mechanisms that validate agent inputs and outputs. Input guardrails prevent harmful queries reaching the agent. Output guardrails prevent sensitive data, PII, or unsafe content from being returned. Guardrails AI is the main framework for this.
H
Hallucination
When an LLM generates confident-sounding text that is factually incorrect or fabricated. Caused by the model predicting statistically plausible tokens regardless of factual accuracy. In agents: hallucinated tool names, hallucinated tool results, or hallucinated data.
Handoff (OpenAI Agents SDK)
Transfer of control from one agent to another, carrying full conversation context. The receiving agent continues from where the previous left off. Used for escalation (triage → specialist), specialisation (generalist → expert), and routing (classifier → handler).
HITL (Human-in-the-loop)
Design pattern where agent workflows pause at specific points for human review or approval before continuing. Critical for irreversible actions. LangGraph implements HITL via interrupt() — graph pauses, waits for human input, then resumes with that input injected into state.
HNSW
Hierarchical Navigable Small World — the graph algorithm enabling fast approximate nearest-neighbour search in vector databases. Builds a layered graph structure; searches start at top layer and navigate down. Finds nearest vectors in milliseconds across millions of stored vectors.
Hybrid search
Combining dense vector search (semantic) with sparse keyword search (BM25) for retrieval. Results merged using Reciprocal Rank Fusion (RRF). Best-quality retrieval for most use cases — catches exact matches that semantic search misses.
HyDE (Hypothetical Document Embeddings)
RAG technique where an LLM generates a hypothetical answer to the query, then embeds that hypothetical answer for retrieval. The hypothetical answer can be semantically closer to actual answer documents than the original question, improving recall on some technical and exploratory queries.
I
Idempotent tool
A tool where calling it twice produces the same result as calling once. Critical for agent tools — agents may retry on perceived failures. Use upsert instead of insert. Include idempotency keys on write operations.
Indirect prompt injection
Attack where malicious instructions are embedded in content the agent reads (web pages, documents, emails) rather than in the user's input. The agent reads the content, encounters instructions, and follows them. Most dangerous attack vector for agents that browse the web.
L
LangGraph
LangChain's library for building stateful agent workflows as directed graphs. Nodes are Python functions, edges define execution flow, and state can be persisted by checkpointers. Strong fit for durable execution, human-in-the-loop flows, streaming, and explicit orchestration.
Late chunking
RAG technique where the entire document is embedded first (with a long-context model), then the resulting embeddings are split into chunks. Each chunk retains document-level context because it was embedded with the full document in view. State of the art for 2025-2026.
LLM-as-judge
Evaluation technique using a stronger or specialised model to score agent outputs on dimensions like accuracy, completeness, faithfulness, and safety. Cheaper than human evaluation and more scalable, but requires calibration against human judgments.
Lost in the middle
The phenomenon where LLMs pay less attention to content in the middle of long context windows than at the beginning and end. Critical for agents with long tool result histories — system prompt instructions can be effectively ignored if buried in the middle of a 100K-token context.
M
MapReduce (agent pattern)
Multi-agent pattern splitting a large task across many parallel agents (map phase), then aggregating results with a single agent (reduce phase). Perfect for processing large document sets, generating many variations simultaneously, or analysing multiple data sources in parallel.
Max steps
Safety parameter in agent loops — maximum number of Thought→Action→Observation cycles before forcing a conclusion. Prevents infinite loops. Should be set to: expected steps × 2 for simple agents, expected steps × 1.5 for well-tested agents. Default 20 is reasonable for research agents.
MCP (Model Context Protocol)
Open standard for connecting AI applications to external tools, data sources, and workflows. Servers expose tools, resources, and prompts; clients use the protocol to discover and call those capabilities. Released by Anthropic in Nov 2024 and now widely supported across AI apps and developer tools.
Mem0
Memory layer for AI agents that extracts, stores, and retrieves useful facts or preferences across conversations. Useful for long-lived assistants, personalisation, and agent workflows where session history alone is not enough.
Memory (agent)
Agent persistence across steps and sessions. Four types: working memory (context window, current session only), episodic (past interactions, stored externally), semantic (facts and preferences, stored externally), procedural (how-to knowledge, stored in prompts or weights).
Multimodal agent
Agent that can process and reason over multiple input types — text, images, audio, video — not just text. Enables: agents that read charts, analyse product images, transcribe meetings, inspect infrastructure screenshots.
MRL (Matryoshka Representation Learning)
Technique where embeddings are trained to be useful at multiple dimensions — the first N dimensions of a 3072-dim embedding are already a good 256-dim embedding. Enables dimension reduction without re-embedding. Supported by OpenAI text-embedding-3 models.
N
NL-to-SQL
Converting natural language questions to SQL queries using an LLM. Enables agents to query any database without knowing SQL. Key requirement: always use read-only database user and validate generated SQL rejects non-SELECT statements.
Node (LangGraph)
A Python function in a LangGraph graph. Takes the current state as input, returns updates to state. Can be: an LLM call, a tool execution, a human interrupt, or any arbitrary Python code. The unit of work in a LangGraph workflow.
O
Observability
The ability to understand internal agent behaviour from external outputs. In agents: tracing every LLM call, tool call, and step with latency, token counts, costs, and errors. Tools: Langfuse, LangSmith, OpenTelemetry. Non-optional for production agents.
OpenAI Agents SDK
OpenAI's framework for single and multi-agent systems. Key primitives include Agent (instructions + model + tools), handoffs or agents-as-tools, Runner, guardrails, sessions, tracing, and MCP server integration.
P
Parallel tool calls
LLM feature where multiple tool calls are requested in a single response. Executing them concurrently (asyncio.gather or ThreadPoolExecutor) cuts latency from N×T to max(T). Major throughput improvement for research agents making multiple searches simultaneously.
pgvector
PostgreSQL extension adding vector similarity search. Stores embeddings as vector columns, provides HNSW and IVF indexes, and cosine/L2/inner product distance operators. Best choice when already running Postgres — combines relational + vector in one system.
Procedural memory
Agent memory storing how-to knowledge: "always verify facts before reporting," "use structured output for financial data." Typically stored in the system prompt or in a retrievable prompt library. Updated by engineers rather than the agent itself.
Prompt caching
Provider feature where repeated prompt prefixes can be cached server-side to reduce latency and cost. Especially useful for long system prompts, large tool schemas, and stable instruction blocks that repeat across requests.
Prompt injection
Attack where malicious instructions are embedded in content the agent processes — web pages, documents, tool results. The agent, not knowing to distrust its own tool outputs, follows the injected instructions. Defence: pattern matching, output sandboxing, prompt structure that separates instructions from data.
Pydantic AI
Type-safe agent framework from the Pydantic team. Agents can declare structured result types as Pydantic models, making validation, retries, and schema-driven outputs a first-class part of the workflow.
Q
Qdrant
Open-source vector database written in Rust. Strong for vector search with metadata filtering, payload storage, dense/sparse retrieval patterns, and local or managed deployments.
Query planning
Agent technique where the first step decomposes a complex question into specific sub-questions, then those are answered in parallel or sequence. Used in deep research agents. Dramatically improves coverage and quality for multi-faceted questions.
R
RAG (Retrieval-Augmented Generation)
Technique of retrieving relevant documents from a knowledge base and including them in the LLM's context before generating a response. Solves: knowledge cutoff, private knowledge access, and context window limits for large datasets.
RAGAS
RAG Assessment — the standard evaluation framework for RAG systems. Open-source Python library. Metrics: Faithfulness, Answer Relevancy, Context Precision, Context Recall. Uses LLM-as-judge internally. Industry standard for RAG quality measurement.
Rate limiting (agents)
Caps on tool calls per user per time window. Essential safety mechanism — prevents runaway agents from making thousands of API calls or spending large amounts. Typically implemented with Redis counters. Should cap: tool calls per session, API calls per hour, and cost per day per user.
ReAct
Reasoning + Acting — the foundational agent design pattern. Interleaves reasoning (Thought) with action (Action) and result processing (Observation) in a loop. Published by Yao et al. 2022. Every agent framework is an abstraction over this loop.
Re-ranking
Post-retrieval step using a cross-encoder model to score each candidate chunk against the specific query. More accurate than embedding similarity alone because cross-encoder sees query + document together. Cohere Rerank is the standard. Applied after vector search, before LLM context injection.
Reducer (LangGraph)
Function defining how state field updates from multiple nodes are merged. The default for list fields (Annotated[list, operator.add]) appends rather than replaces — critical for accumulating message history correctly across agent steps.
RRF (Reciprocal Rank Fusion)
Algorithm for merging ranked result lists from multiple retrieval systems. Each document scores sum(1/(rank+k)) across all lists. Standard algorithm for hybrid search fusion. k=60 is the conventional default.
S
Semantic chunking
RAG chunking strategy that splits documents at semantic boundaries (topic changes) rather than fixed sizes. Detected by embedding consecutive sentences and splitting where embedding similarity drops. Produces semantically coherent chunks. Better quality than fixed-size, higher cost to produce.
Semantic memory
Agent memory storing facts, user preferences, and domain knowledge. Persistent across sessions. "User prefers TypeScript," "Company uses Kubernetes on AWS." Stored as key-value pairs or in vector DB for semantic retrieval. Distinct from episodic memory (past events).
Sparse embedding
High-dimensional vector (30K+ dims, vocabulary-sized) where most values are zero. Non-zero values indicate important words and their weight. Captures keyword information rather than semantic meaning. Used alongside dense embeddings in hybrid search. SPLADE is the main model.
State (LangGraph)
A TypedDict that flows through the entire graph, shared by all nodes. Each node reads current state and returns updates. The agent's shared memory for the entire workflow — tracks messages, decisions, intermediate results, and final outputs.
Streaming
Returning LLM output token-by-token as it generates rather than waiting for completion. Dramatically reduces perceived latency. In agents: stream tokens to user while the agent is still generating. LangGraph supports streaming via astream_events().
Subgraph (LangGraph)
A LangGraph graph used as a node within another (parent) graph. Enables composable, reusable agent workflows. A "research workflow" subgraph can be embedded in multiple parent graphs without code duplication.
Supervisor pattern
Multi-agent architecture with a supervisor/orchestrator agent that receives high-level tasks, breaks them into subtasks, routes each to a specialist worker agent, and aggregates results. The standard pattern for multi-agent systems in both LangGraph and CrewAI.
T
Temperature
LLM parameter (0.0–2.0) controlling output randomness. 0.0 = always pick highest-probability token (deterministic). 1.0 = sample proportionally. Agents should use 0.0–0.2 for tool calls (need consistency). Use 0.7–1.0 only for creative tasks.
Token
The basic unit of LLM processing. ~3-4 characters or ~0.75 English words. All LLM costs and limits (context window, pricing) are measured in tokens. Code is token-dense; natural English is efficient. "Hello world" = 2 tokens.
Tool calling
The mechanism by which LLMs request execution of external code. You define tools with JSON Schema; the model returns tool_use blocks; you execute them and return results. Enables agents to search, query databases, write files, and call any API.
Tool schema
JSON Schema definition of a tool: name, description, and input_schema (properties + required fields). The description is the model's API contract — it determines when the model uses the tool and how it fills arguments. Poor descriptions are the #1 cause of tool misuse.
Top-p sampling
Nucleus sampling — only sample from tokens whose cumulative probability exceeds p. Cuts off unlikely tokens (the "long tail"). top_p=0.95 means "only consider plausible tokens." Combines with low temperature for focused, stable agent outputs.
Transformer
Neural network architecture underlying all modern LLMs. Key components: multi-head attention, feed-forward layers, layer normalisation, positional encoding. Introduced in "Attention Is All You Need" (Vaswani et al., 2017). Scales predictably with data and parameters.
V
Vector database
Database optimised for storing and querying high-dimensional vectors (embeddings). Enables semantic similarity search — finding conceptually similar content. Key players: Qdrant, Pinecone, Weaviate, Chroma, pgvector, Milvus, LanceDB.
VectorLess retrieval
Retrieval without embedding vectors — using BM25, full-text search (Postgres tsvector), or LLM reranking. Appropriate when: keyword matching is sufficient, corpus is small, latency requirements exceed embedding overhead, or privacy prohibits sending data to embedding APIs.
W
Working memory
The agent's active context window — everything currently visible to the LLM. Unlike human working memory, it is large (100K-200K tokens) but hard-bounded and completely reset between API calls. All episodic and semantic memory must be retrieved into working memory to be usable.
Working set compression
Technique for managing long-running agent context: when approaching context limit, old tool results are summarised and replaced with shorter summaries. Preserves key findings while freeing context for new information. Critical for agents running 20+ steps.
· · ·
AI Engineering Track — Prem's Dev Adda
9 Parts · 33 Chapters · 60 Projects · 150+ Terms
Built for engineers designing production AI systems. Start at Part I if you're new. Jump to Part VII for projects. Use Part VIII as your daily reference.