Glossary

Agent / Agentic AI

An AI system that uses a foundation model as its cognitive core to actively reason, autonomously create plans, make decisions, and execute actions in its environment, rather than just passively generating text.

Multi-Agent System (MAS)

A system in which multiple autonomous agents jointly solve a task by communicating, cooperating, and coordinating with one another.

LaMAS (LLM-based Multi-Agent System)

A framework of interconnected LLM agents capable of dynamic task decomposition, organic specialization, and autonomous operation. Offers inherent fault tolerance through agent redundancy and enables complex problem solving.

Foundation Model (LLM)

The pretrained language model that supplies an agent's reasoning capacity. The model is one component of the agent, not the whole agent.

Prompt Engineering

The original paradigm of iteratively refining natural-language prose to coax desired behavior from an LLM. Non-deterministic and weakly specified.

Agentic Engineering

The modern paradigm: control logic lives in code (state, edges, validators), not in prose. The LLM becomes a tool inside a deterministic framework, not the framework itself.

Recursive Composability

The property that complex systems can be assembled from verifiable modules with reproducible behavior. The main reason logic is pushed out of prose and into the runtime.

The 3Cs Principle

Communication, Cooperation, Coordination. The three behavioral pillars that distinguish a multi-agent system from a parallel ensemble of independent agents.

Determinism (structure vs. output)

Structure-deterministic systems fix the control flow in code while letting the LLM fill content slots; output-deterministic systems would also fix the content, which is generally unattainable with LLMs.

Encapsulation

Architectural principle of hiding specialist agents behind a tool-like interface so callers see a uniform surface.

Decoupling

Architectural principle of separating communication topology from work topology so neither becomes a hard dependency of the other.

Emergent Topology

The runtime property where the actual agent graph materializes during execution (e.g., via handoffs) rather than being declared statically.

Composability

Design principle that patterns combine cleanly. For example, Human-in-the-Loop composes with all six coordination patterns.

Batch-invariance

The (unrealized) property that an LLM produces identical outputs across batch sizes at temperature 0. Empirically violated even in production inference stacks.

StateGraph

An architecture where nodes control execution flow and every node reads from and writes to an explicit, shared state object. Supports conditional branches, parallel execution, and cycles.

Directed Acyclic Graph (DAG)

A directed graph with no cycles. Used to define deterministic workflows where steps execute in fixed sequence without looping back.

Star Architecture

A topology where a central orchestrator coordinates communication with all other specialized agents.

Decentralized Star Architecture

A star variant in which the orchestrator delegates tasks but does not process sensitive data directly; specialists handle their work inside their own secure data domains to preserve privacy.

Ring Architecture

A topology that passes tasks sequentially from one agent to the next.

Graph Architecture

A fully interconnected peer-to-peer topology among agents.

Bus Architecture

A topology using a fixed workflow distributed via a shared bus to the appropriate processes.

Hierarchical Architecture

Agents organized into multiple layers, with supervisors at each level managing subordinate teams.

Workflow DAG

A control structure with explicit nodes and edges, used as the foundation beneath agentic workflows.

Single-agent reasoning patterns (Ladder Rung L1).

ReAct (Reason + Act)L1 ↗︎

Foundational paradigm in which the agent iteratively alternates between a reasoning step (a thought) and a tool invocation (an act), observing the outcome and deriving the next step. Aliases: Thought–Action–Observation Loop.

Chain of Thought (CoT)L1 ↗︎

Reasoning method in which the LLM articulates intermediate logical steps before generating the final answer.

Inner Monologue (IM)L1 ↗︎

A reasoning style that injects external feedback from the environment directly into the agent as internal thoughts.

Plan-and-ExecuteL1 ↗︎

The agent first generates a complete plan, then executes the steps sequentially. Aliases: Planner-Executor, Plan then Act, Task Planning.

ReWOO (Reasoning Without Observation)L1 ↗︎

The agent plans all required tool calls upfront, executes them in a batch, and aggregates the results. Saves LLM calls and tokens compared to ReAct. Aliases: Planner-Solver.

Reflexion (Self-Reflection)L1 ↗︎

An iterative process in which the agent critically evaluates its own intermediate results and uses the feedback to improve subsequent steps. Aliases: Self-Critique, Reflection Loop.

Tree of Thoughts (ToT)L1 ↗︎

The agent simultaneously explores multiple reasoning paths formatted as a tree, evaluates intermediate steps, and pursues the most promising branches. Aliases: Branching Reasoning, Search over Thoughts.

Self-Consistency (CoT-SC)L1 ↗︎

The system generates multiple independent reasoning paths and selects the final answer through consensus or majority voting. Aliases: Majority Reasoning, Sample-and-Vote.

CodeActL1 ↗︎

The agent uses executable code as its primary medium for actions and reasoning, ensuring precision and reproducibility. Aliases: Code-as-Action, Programmatic Action.

Workflow patterns where structure lives in code and the LLM fills the slots (Ladder Rung L2).

Sequential Pipeline (Prompt Chaining)L2 ↗︎

Steps execute deterministically in a fixed order; the output of one step is the input of the next. Aliases: Linear Workflow, Sequential Process.

RoutingL2 ↗︎

A classification module dynamically dispatches a request to a specific execution path, agent, or tool based on intent. Aliases: Classifier Router, Intent Routing, Conditional Branching.

Parallelization (Sectioning / Voting)L2 ↗︎

Independent subtasks are processed simultaneously and either semantically merged (sectioning) or aggregated to select the best outcome (voting). Aliases: Fan-out, Divide and Process.

Evaluator-OptimizerL2 ↗︎

A generator agent produces a result, an evaluator agent scores it, and the generator optimizes it based on feedback. Aliases: Generator-Critic, Critique and Revise.

Iterative RefinementL2 ↗︎

A controlled multi-pass loop that improves a single artifact across revisions. Aliases: Revise Loop, Draft-Improve.

Orchestrator-WorkersL2 ↗︎

A central orchestrator dynamically decomposes a task and delegates execution to specialized worker agents. Aliases: Coordinator-Workers, Manager-Worker, Dynamic Task Decomposition.

Map-ReduceL2 ↗︎

A large task is decomposed into independent chunks, processed in parallel, and aggregated into a single result. Aliases: Fan-out/Fan-in, Map Aggregate.

LoopL2 ↗︎

One or more steps are repeated until a specific budget, quality bound, or exit condition is reached. Aliases: Control Loop, Retry Loop, Agent Loop.

Multi-agent coordination patterns (Ladder Rung L3).

SupervisorL3 ↗︎

A central manager agent decides which subordinate agent should act next. Aliases: Manager Agent, Coordinator Agent.

Hierarchical SupervisorL3 ↗︎

Supervisor pattern organized into multiple layers for larger teams. Aliases: Multi-Level Supervisor, Manager Hierarchy.

HandoffL3 ↗︎

An agent completely transfers control and relevant context to another specialist agent. Aliases: Transfer of Control, Delegated Turn.

SwarmL3 ↗︎

A decentralized multi-agent system where specialized agents self-organize autonomously via local rules and handoffs without a central supervisor. Aliases: Peer Agent Swarm, Emergent Coordination.

Group ChatL3 ↗︎

Agents communicate in a shared conversational space. Aliases: Multi-Agent Chat, Round-Robin Conversation.

Multi-Agent DebateL3 ↗︎

A group-chat variant in which agents deliberately adopt different positions to expose logical flaws before reaching a decision. Aliases: Debate, Adversarial Agents, Deliberation.

BlackboardL3 ↗︎

A coordination pattern in which agents interact indirectly by reading from and writing to a shared, persistent state surface. Classical: knowledge sources read the blackboard, react when relevant, and write back. Aliases: Shared Workspace, Blackboard Architecture.

Magentic (Magentic-One)L3 ↗︎

A composite orchestration pattern combining a planning ledger, delegation, and replanning for long-running goals. Originates in Microsoft Research’s Magentic-One generalist multi-agent system.

Agents-as-ToolsL3 ↗︎

One orchestrating agent calls other agents exactly like tools, hiding their internal logic behind a standard interface. Aliases: Agent Tools, Callable Agents, Specialist-as-Tool.

Contract Net (Market-based)L3 ↗︎

Tasks are distributed dynamically by having agents bid on them based on capability, utility, or price signals. Classical formulation by Reid Smith (1980). Aliases: Task Bidding, Auction-based Agents.

Graph-based OrchestrationL3 ↗︎

Agent coordination modeled as an explicit state graph (the foundation for most of the patterns above).

Knowledge SourcesL3 ↗︎

The classical Blackboard term (Hayes-Roth, 1985) for the participating agents.

QuiescenceL3 ↗︎

A Blackboard termination state: no agent has a relevant action; the task is either complete or stalled.

A system-theoretic decomposition of an agent's internal architecture used in the Agentic Brain Cycle framing.

Reasoning & World Model (RWM)

The core cognitive subsystem acting as the decision-making nucleus; maintains the world model and directs strategic behavior. See also World Model (RWM state) under Memory and State.

Perception & Grounding (PG)

The agent’s senses: processes and grounds raw inputs into structured percepts.

Action Execution (AE)

The agent’s effectors: executes actions in the external environment.

Learning & Adaptation (LA)

The encapsulating subsystem that observes performance, learns from experience, and drives continuous improvement.

Inter-Agent Communication (IAC)

The social interface subsystem for structured peer-to-peer interactions in multi-agent environments.

Twelve canonical ADPs grouped into four phases that map to the system-theoretic subsystems. These are the project's foundational catalog.

Integrator

Validates incoming observations before they enter the world model; prevents hallucinated or malformed inputs from corrupting downstream reasoning.

Retriever

Context-sensitive interface to long-term memory; pulls only what the current step needs.

Recorder

Saves and restores Reasoning & World Model (RWM) states for durability, resumability, and replay.

Selector

Dynamic prioritization of competing goals.

Planner

Strategic decomposition of complex goals into sub-goals.

Deliberator

Selection of the optimal action at each planning step.

Executor

Reliable execution with systematic feedback collection.

Tool Use

Proxy / adapter interface for safe external function calls.

Coordinator

Management of structured multi-agent communication.

Reflector

Causal failure analysis that produces actionable insights for adaptation.

Skill Build

Extraction of reusable procedures from past experience.

Controller

Continuous monitoring of ethical and operational guardrails.

Conversational MemoryL4 ↗︎

Preserves chat history to maintain user context across multiple turns.

Episodic MemoryL4 ↗︎

Stores completed interactions as discrete episodes so the agent can reuse successful strategies. Aliases: Experience Memory, Task Episode Store.

Semantic MemoryL4 ↗︎

Stores long-term factual knowledge in a structured form.

Vector MemoryL4 ↗︎

Stores knowledge as vector embeddings for similarity-based retrieval.

Graph MemoryL4 ↗︎

Stores knowledge as entities and relations in a knowledge graph.

RAG vs. Agent MemoryL4 ↗︎

RAG is read-only, stateless retrieval of universal knowledge (relevance is a property of the content); agent memory is read-write, user-specific context that persists across sessions (relevance is a property of the user). Related but distinct; production agents often use both.

Corrective RAG (CRAG)L4 ↗︎

A RAG variant where a lightweight evaluator scores retrieved evidence and triggers correction (reranking, re-retrieval, or web-search fallback) when relevance is low.

GraphRAGL4 ↗︎

Builds a hierarchical knowledge graph from the corpus to answer multi-hop questions that span multiple documents.

RAPTORL4 ↗︎

Recursively clusters and summarises chunks into a multi-level tree, preserving context across abstraction levels for long, structured material.

Working Memory (Scratchpad)L4 ↗︎

Temporary short-term state holding intermediate steps, variables, and open tasks during a single agent run.

Virtual Context ManagementL4 ↗︎

Treating the finite context window like RAM and an external store like disk: the agent pages information between the tiers under its own control, operating over histories far larger than the window. Aliases: MemGPT, OS-Style Memory Paging, Tiered Context Management, Self-Editing Memory. Memory-layer products: Letta, Mem0, Zep, Cognee.

World Model (RWM state)L4 ↗︎

The agent’s internal representation of the task and environment that drives decision-making; the state maintained by the Reasoning & World Model (RWM) subsystem.

State Schema (TypedDict / Pydantic)L4 ↗︎

The explicit data structure passed through the graph at every node boundary.

Reducer FunctionL4 ↗︎

A custom or built-in function that defines how to merge parallel state modifications back into the main state object to prevent data overwriting (e.g., add_messages, operator.add).

NodeL4 ↗︎

A work step or specialized agent in the graph.

EdgeL4 ↗︎

A connection between steps; encodes fixed control flow.

Conditional EdgeL4 ↗︎

A forwarding decision made at runtime by an LLM or by a rule.

Fan-outL4 ↗︎

Dispatch from one node to multiple parallel branches.

Fan-inL4 ↗︎

Collection of results from multiple branches into one downstream node.

CheckpointingL4 ↗︎

Periodic persistence of execution state at node boundaries so runs can be resumed after errors, restarts, or human interruptions.

Durable ExecutionL4 ↗︎

A runtime property: the process survives failures and resumes from the last checkpoint instead of restarting.

Thread IDL4 ↗︎

A composite key (typically UserID × SessionID) used by checkpointers to isolate state history for multiple concurrent users or sessions.

Interrupt / ResumeL4 ↗︎

A first-class halt point at which the graph pauses for human intervention, then continues from the same state via a resume signal.

Recursion LimitL4 ↗︎

A hard upper bound on graph cycles that prevents unbounded loops.

Max HandoffsL4 ↗︎

A hard upper bound on the number of transfers in a Swarm.

MemorySaverL4 ↗︎

In-process memory checkpointer; suitable for testing only (state lost on restart).

SqliteSaverL4 ↗︎

Single-writer SQLite-backed checkpointer; an anti-pattern under concurrency due to write-lock serialization.

PostgresSaver / AsyncPostgresSaverL4 ↗︎

Production checkpointers with row-level locking; the async variant is preferred for high-concurrency systems.

Function Calling / Tool CallingL4 ↗︎

The mechanism by which an LLM generates structured arguments to invoke an external API.

Tool RegistryL4 ↗︎

A central catalog of available tools with metadata describing arguments, side-effects, and access scopes.

Capability Routing (Tool Selection)L4 ↗︎

Dynamic dispatch from a large tool surface to the appropriate capability based on context and metadata, avoiding tool explosion.

Sandbox ExecutionL4 ↗︎

Isolated execution environment (code, shell, browser) used to confine side-effects from tool calls.

Least-Privilege AgentL4 ↗︎

An agent granted only the minimum capabilities needed for its role.

Human-in-the-Loop (HITL) / Approval GateL4 ↗︎

A system design with explicit intervention points where the workflow pauses to gather human feedback or approval before continuing.

Graduated / Bounded AutonomyL4 ↗︎

Oversight set per action class by stakes (full automation for low-stakes, supervised for moderate, human-led for high-stakes) rather than a single on/off gate. Bounded autonomy gives an agent explicit operational limits, escalation paths, and an audit trail.

Governance Agent / Security AgentL4 ↗︎

A supervisory agent that monitors other agents for policy violations or anomalous behaviour and escalates to a human only on a trip; the multi-agent realisation of the Controller pattern.

Kill SwitchL4 ↗︎

A hard token/cost ceiling that terminates a runaway run before a retry storm multiplies the bill; the safeguard backing recursion limits.

Output Validation / Schema EnforcementL4 ↗︎

Ensuring model outputs strictly follow predefined structures using tools such as Pydantic v2.

Multimodal GuardrailsL4 ↗︎

Extension of validation to non-text inputs and outputs (images, audio, files).

Statistical GuardrailsL4 ↗︎

Quantitative, model-agnostic output checks: semantic-drift detection (cosine-distance z-score from a safe baseline) and confidence gating (Shannon entropy of token probabilities). The statistical counterpart to schema-based Output Validation. Aliases: Semantic Guardrails, Confidence Gating.

Audit TrailL4 ↗︎

A persistent record of agent decisions, tool calls, and state transitions for post-hoc analysis.

Distributed TracingL4 ↗︎

Making agent runs, tool calls, and subprocesses visible as connected end-to-end traces to analyze latencies and errors.

SpanL4 ↗︎

A single unit in a trace; contains inputs, outputs, tool calls, token counts, and latencies.

LangSmithL4 ↗︎

Managed tracing and evaluation platform (LangChain ecosystem).

LangfuseL4 ↗︎

Open-source tracing platform; self-hostable or managed.

OpenTelemetry (OTel) GenAI ConventionsL4 ↗︎

Open observability standard with specific conventions for LLM and agent spans.

Token / Cost TrackingL4 ↗︎

Continuous monitoring of token usage and spend to surface runaway loops before they cause billing incidents.

LLM-as-JudgeL4 ↗︎

Using a model to evaluate outputs against criteria, rubrics, or comparative examples; scales subjective evaluation.

Integration TestsL4 ↗︎

Deterministic baseline tests retained at the boundaries of an otherwise non-deterministic system.

Trust BoundaryL4 ↗︎

A point at which incoming messages (especially agent-to-agent) must be sanitized and validated.

Model Context Protocol (MCP)L4 ↗︎

Open standard providing a uniform tool surface between agents and external tools/data sources. Originated at Anthropic (2024).

Agent-to-Agent Protocol (A2A)L4 ↗︎

Open messaging standard enabling communication between AI agents across frameworks; identifying metadata is carried in Agent Cards. Initiated by Google in April 2025 and donated to the Linux Foundation.

Agent Communication Protocol (ACP)L4 ↗︎

A REST-native agent-to-agent messaging standard (IBM · BeeAI) that has since merged into A2A under the Linux Foundation; no longer maintained as a separate protocol.

Agent CardL4 ↗︎

JSON metadata document used in A2A: lists capabilities, endpoint, and authentication.

Task (A2A)L4 ↗︎

An ID-based unit of work with a defined lifecycle exchanged between agents.

Artifact (A2A)L4 ↗︎

A result (document, dataset, image) that crosses an A2A boundary.

LangGraph

Graph-based, state-driven runtime with first-class checkpointing, interrupts, and reducers. The reference runtime used in this project’s code phases.

LangChain

Higher-level abstractions for LLM applications; sits above LangGraph.

CrewAI

Role-based “crew” metaphor; optimized for rapid prototyping of small multi-agent teams.

AutoGen / AG2

Event-driven group chat with asynchronous messaging between agents.

OpenAI Agents SDK

Lightweight, handoff-based agent flows from OpenAI; successor in spirit to Swarm.

OpenAI Swarm

OpenAI’s earlier educational reference implementation of decentralized handoffs (predecessor to the Agents SDK).

Google ADK (Agent Development Kit)

Modular hierarchical agents for Vertex AI.

AWS Strands SDK

Model-driven minimal SDK with native Bedrock integration.

Microsoft Agent Framework

Event-driven framework that includes the Magentic-One successor.

Semantic Kernel

Microsoft’s SDK for orchestrating LLM functions and plugins.

LlamaIndex

Framework for RAG pipelines and document processing.

Temporal

Long-running workflow engine built for minutes-to-hours processes.

Inngest

Event-driven durable execution platform.

Restate

Durable execution for distributed workflows.

Deep Agents SDK

Opinionated, batteries-included LangGraph-based harness.

Claude Agent SDK

Anthropic’s agentic harness (the runtime behind Claude Code).

Vercel AI SDK

AI utilities for JavaScript/TypeScript applications.

AWS Bedrock

Managed model hosting on AWS.

Bedrock AgentCore

Bedrock’s A2A integration point.

Google Vertex AI

Google Cloud’s ML and model platform.

Small Language Model (SLM)

A model small enough to be specialised and cheaply served — typically under ~10B parameters (often 1–7B). Suited to the repetitive, well-defined sub-tasks that dominate production traffic; reaches usable quality via distillation, quantization, and curated data.

Model Tiering

A heterogeneous model architecture that assigns each workflow node a model by need: a frontier model for open-ended reasoning, a mid-tier model for standard steps, and an SLM for high-frequency narrow calls. The production-cost architecture that Resource-Aware Optimization routing serves.

Quantization

Compressing model weights to 4–8-bit integers (~75% size reduction), a core efficiency method behind locally-served SLMs.

Knowledge Distillation

Training a smaller “student” model to mimic a larger “teacher”, a primary way SLMs reach comparable quality on narrow tasks.

Pydantic (v2)

Schema validation library used at state boundaries.

MemGPT

Long-context state management system for LLM agents.

Agent-as-a-Service (AaaS)

A licensing and deployment approach enabling dynamic agent usage based on computational needs with usage-based pricing.

Traffic Monetization

Generating commercial value by using agents to manage user flows, optimize advertisements through CPC/CPA models, and increase conversion rates.

Intelligence Monetization

Revenue from selling data-driven insights and reports generated by specialized multi-agent collaborations.

Shapley Value

A game-theoretic attribution method used to allocate profits fairly based on each agent’s specific contribution to a successful task.

God OrchestratorL3 ↗︎

A single central supervisor that controls too many tasks and tools, becoming a coordination bottleneck and severe privacy risk. Push work and authority to specialists.

Over-AgentificationL3 ↗︎

Attempting to solve a trivial task with a complex multi-agent swarm when a script or single-agent pipeline would suffice. High token cost, hard to debug.

Hidden State in PromptsL1 ↗︎

Concealing state logic and context inside natural-language prompts instead of managing it explicitly in code. State belongs in Pydantic schemas, not prose.

Hallucinated RoutingL2 ↗︎

A router invents transitions because the LLM’s choice is probabilistic. Mitigated by schema validation at every edge and bounds such as recursion_limit.

Tool ExplosionL1 ↗︎

Granting an agent access to so many tools at once that selection accuracy collapses. Resolved with a Tool Registry plus capability routing.

Unbounded LoopL1 ↗︎

An agent stuck in unproductive infinite cycles due to flawed reasoning without a programmed recursion limit.

SQLite Under ConcurrencyL4 ↗︎

Using a single-writer SQLite checkpointer in production; writes serialize and timeouts cascade. Use an async PostgreSQL checkpointer instead.

Cascading Security FailuresL3 ↗︎

A poisoned document in a shared index contaminates every consumer that retrieves it. Mitigated by partitioning indexes by trust level.

Prompt Injection

Malicious inputs that hijack agent instructions through the model’s natural-language interface.

Memory Poisoning

Malicious content that contaminates retrieval-augmented databases, causing cascading errors across the agent network.

Model Inversion

Attacks that attempt to reconstruct training data or proprietary model logic through targeted queries.

Three failure modes that emerge when a system is run on prose alone (no architectural guarantees).

Babysitter

A human must remain in the loop permanently to catch non-deterministic model mistakes by hand.

Auditor

Results require exhaustive manual post-processing review because the process itself does not guarantee reliability.

Prayer

Blind acceptance of agent outputs without verification; inevitably leads to unpredictable production failures.

Project-specific scaffolding used to teach the catalog.

The Six Coordination Patterns

Six multi-agent coordination patterns positioned as the conceptual spine of the platform: (1) Orchestrator / Agent-as-Tool — encapsulation; specialists as typed callables. (2) Pipeline / Workflow (DAG) — structure-deterministic; control flow in code. (3) Graph (Fan-out / Fan-in) — bounded variability; conditional edges and cycles. (4) Blackboard (Shared State) — decoupled topology; coordination via shared state. (5) Swarm (Self-Organizing Handoffs) — emergent topology; runtime-materialized graph. (6) Human-in-the-Loop (HITL) — the temporal dimension; suspend and resume across unbounded gaps.

The Ladder Rungs

Four-level learning progression used to sequence the catalog. L1 — Single Agent. ReAct, Plan-and-Execute, ReWOO, Reflexion, Tree of Thoughts, Self-Consistency, CodeAct. L2 — Workflow. Sequential, Routing, Parallelization, Loop, Evaluator-Optimizer, Orchestrator-Workers, Map-Reduce, Iterative Refinement. L3 — Multi-Agent. Supervisor, Hierarchical, Handoff, Swarm, Group Chat, Debate, Magentic, Blackboard, Contract Net, Agents-as-Tools. L4 — Production. Memory Architecture, Tool Registry, MCP, A2A, Checkpointing, Workflow DAG, HITL Gate, Sandbox Execution, Audit Trail, LLM-as-Judge, Distributed Tracing.

Pattern Lookup Schema

The fixed entry format used in the knowledge base: Domain, Subdomain (System Operation only), Aliases, Core idea, Use when, Don’t use when, Trade-off, Frameworks, Related to.

Code Variant Contract

Each variant under code/variants/backend/variants/<NN>_<name>/ exports run_stream(user_input) (a streamed trace) and run_graph_with_trace(user_input). A FastAPI backend loads any variant dynamically and streams its trace over SSE to a Next.js frontend.