AI agent primitives are the foundational building blocks every agent needs to perceive, reason, act, and remember. Most frameworks — including LangChain, OpenAI Agents SDK, and AutoGen — define 4 or 5 primitives. Enterprise deployments need 6: the standard set plus a shared context layer and a control plane, the two primitives that no framework ships by default.
| Field | Content |
|---|---|
| What they are | The minimum set of architectural components required for an AI agent to function |
| Standard model | 4–5 primitives: reasoning model, tools/actions, memory, orchestration, and optionally perception |
| Enterprise model | 6 primitives — adds shared context layer and control plane |
| Where frameworks agree | Reasoning/model, tools/actions, per-agent memory, orchestration |
| Where frameworks diverge | Shared organizational context, governance, audit trails |
| Why it matters | Agents built on 4 primitives show a 60% PoC abandonment rate; 6-primitive architectures reach production (research suggests; Gartner) |
Build Your AI Context Stack
Get the blueprint for implementing context graphs across your enterprise. This guide walks through the four-layer architecture — from metadata foundation to agent orchestration — with practical implementation steps for 2026.
Get the Stack GuideThe standard 4 AI agent primitives (what most frameworks cover)
Permalink to “The standard 4 AI agent primitives (what most frameworks cover)”LangChain, OpenAI Agents SDK, AutoGen, and CrewAI each define agents around 4–5 shared primitives: the reasoning model that interprets goals, tools and actions that extend the agent’s reach, memory that persists context across steps, and orchestration that sequences tasks and coordinates agent handoffs.
Primitive 1: reasoning and model selection
Permalink to “Primitive 1: reasoning and model selection”The LLM is the agent’s reasoning engine. It interprets instructions, selects tools, parses outputs, and generates responses. Model choice affects capability and cost, but is increasingly commodity. The more consequential design decision is how the model reasons: chain-of-thought, ReAct pattern, or reflection loops. The system prompt defines the agent’s operating context, constraints, and personality. For a deeper treatment of reasoning patterns, see agent engineering fundamentals.
Primitive 2: tools and actions
Permalink to “Primitive 2: tools and actions”Tools extend the agent beyond text: search, code execution, API calls, database queries, file writes. In OpenAI’s model, this is function calling. In LangChain, tool objects. In CrewAI, task assignments. The breadth of available tools determines what the agent can do. What determines whether it does the right thing is context quality — which is where the standard model starts to crack.
Primitive 3: agent memory
Permalink to “Primitive 3: agent memory”Memory lets agents accumulate context across steps and sessions. The taxonomy spans in-context memory (the current window), episodic memory (past conversations), semantic memory (facts and definitions), and procedural memory (how-to knowledge). LangChain, mem0, and Zep all address agent memory types at the per-agent level. The key limitation: all of these are per-agent and per-session. They capture episodic, semantic, and procedural memory for one agent in one context. When agents multiply, memory silos multiply with them.
Primitive 4: orchestration and coordination
Permalink to “Primitive 4: orchestration and coordination”Orchestration defines how multi-step tasks are sequenced and how multiple agents coordinate. LangGraph uses graph-based state machines. AutoGen uses group chat patterns. OpenAI SDK uses Handoffs. CrewAI uses sequential and hierarchical Crew processes. Orchestration answers: who does what, in what order. It does not answer: what shared knowledge should all agents draw from when they do it. For the full treatment of multi-agent orchestration, the distinction between coordination and shared context is where enterprise deployments diverge from demos.
Why 4 primitives aren’t enough for enterprise AI agents
Permalink to “Why 4 primitives aren’t enough for enterprise AI agents”The 4-primitive model works for demos and isolated tasks. In enterprise deployments — multiple agents, shared data, compliance requirements — it breaks down. Agents disagree on definitions. Governance is absent. Audit trails don’t exist. Research suggests 60% of enterprise AI projects are abandoned before production; enterprise context silos are the leading architectural cause.
When Agent A and Agent B both query revenue data but use different definitions of recognized_revenue_q4, their outputs conflict. Not because the model is wrong. Because no shared definition existed. This is the shared context failure. No framework addresses it because frameworks define primitives from the perspective of one agent in one session. The cross-agent consistency problem is outside their scope by design — but it’s squarely inside the scope of enterprise agent governance.
Enterprise agents need to know not just how to do something, but whether they are allowed to. Which datasets can this agent query? On whose authority? For which user? These are access control questions, and they require a governance primitive, not just a guardrails hook. McKinsey’s State of AI 2025 found that 56% of CEOs report zero financial benefit from AI deployments. That is not a model problem. It is a missing-primitives problem.
The 6 AI agent primitives: the complete model
Permalink to “The 6 AI agent primitives: the complete model”The 6-primitive model extends the standard framework to cover what enterprise agents actually require. Primitives 1–4 are what every agent needs to function. Primitives 5–6 are what every fleet needs to stay coherent, accurate, and governed at scale.
| Primitive | Type | One-line description |
|---|---|---|
| 1. Reasoning / Model | Standard | LLM that interprets goals and generates responses |
| 2. Tools / Actions | Standard | External capabilities the agent can invoke |
| 3. Agent Memory | Standard | Per-agent, per-session context persistence |
| 4. Orchestration | Standard | Multi-step task sequencing and agent coordination |
| 5. Shared Context Layer | Enterprise addition | Governed definitions, lineage, policies, entity resolution shared across all agents |
| 6. Control Plane / Governance | Enterprise addition | Auth, access control, audit trail, policy enforcement |
Primitive 1: reasoning and model selection
Permalink to “Primitive 1: reasoning and model selection”The foundation layer. The LLM processes instructions, selects tools, and reasons through steps. Context quality matters more than model choice: the same model with richer organizational context consistently outperforms a stronger model with stale or absent context.
Primitive 2: tools and actions
Permalink to “Primitive 2: tools and actions”The agent’s execution reach. An agent with a shared context layer makes better tool calls because it knows which table is authoritative and which definition is approved. Context-aware tool selection is the difference between querying the right source and the loudest one.
Primitive 3: agent memory
Permalink to “Primitive 3: agent memory”Necessary but insufficient for enterprise. The per-agent memory layer captures what one agent learned in one session — it doesn’t resolve conflicting entity definitions across agents or provide organizational-level semantic knowledge.
Primitive 4: orchestration and coordination
Permalink to “Primitive 4: orchestration and coordination”The coordination logic for multi-step tasks and multi-agent systems. LangGraph, A2A protocol, and AutoGen are orchestration mechanisms — they move work between agents but do not define the shared knowledge those agents draw from.
Primitive 5: the shared context layer (the missing enterprise primitive)
Permalink to “Primitive 5: the shared context layer (the missing enterprise primitive)”The agent context layer is organizational context memory: governed definitions, data lineage, business policies, and entity resolution shared across all agents. This is not per-agent memory — it is infrastructure all agents read from and contribute back to.
The accuracy impact is documented: a 38% AI accuracy uplift across 522 queries from governed context (Atlan AI Labs, 2026). Joe DosSantos at Workday: “All of the work that we did to get a shared language at Workday can be leveraged by AI via Atlan’s MCP server.”
Primitive 6: control plane and governance
Permalink to “Primitive 6: control plane and governance”The control plane covers agent identity and authentication, dataset-level access control, policy enforcement at runtime, and an immutable audit trail. Unlike guardrails (which validate at the edges), the control plane is the enforcement layer that makes agents auditable and compliant for regulated industries.
Inside Atlan AI Labs & The 5x Accuracy Factor
Learn how context engineering drove 5x AI accuracy in real customer systems. Explore real experiments, quantifiable results, and a repeatable playbook for closing the gap between AI demos and production-ready systems.
Download E-BookAI agent primitives by framework: LangChain, AutoGen, CrewAI, OpenAI Agents SDK
Permalink to “AI agent primitives by framework: LangChain, AutoGen, CrewAI, OpenAI Agents SDK”LangChain, AutoGen, CrewAI, and OpenAI Agents SDK each define 4–5 primitives from a single-agent, single-session perspective. They converge on model, tools, and orchestration. They diverge on memory and governance. None defines a shared context layer or a control plane as a first-class primitive.
| Framework | Reasoning | Tools | Memory | Orchestration | Shared Context | Control Plane |
|---|---|---|---|---|---|---|
| LangChain / LangGraph | Model | Tool objects | In-context, vector store | LangGraph state machine | Not a primitive | Callbacks only |
| OpenAI Agents SDK | Agent (instructions + model) | Function tools | Session state | Handoffs | Not a primitive | Guardrails (partial) |
| AutoGen | Conversable agent | Code executor | Conversation history | Group chat / nested | Not a primitive | Not addressed |
| CrewAI | Agent role | Task tools | Prompt context | Crew / Process | Not a primitive | Not addressed |
| Atlan 6-primitive model | Reasoning layer | Tools + context-aware calls | Per-agent + shared | Orchestration + A2A | Shared context layer | AI Control Plane |
This is not a criticism of these frameworks. LangChain’s documented architecture centers the agent loop on model, tools, memory, and instructions — organizational context is intentionally left to the application layer. The same applies to OpenAI SDK, AutoGen, and CrewAI. The gap becomes a production problem at enterprise scale: when 10 agents need to agree on what “revenue” means and no framework-native primitive provides the answer, context engineering discipline becomes an architectural requirement, not a deployment-time consideration. AI agent context is where enterprise deployments win or lose.
How AI agent primitives map to enterprise requirements
Permalink to “How AI agent primitives map to enterprise requirements”Enterprise AI agents face requirements that single-agent frameworks were not designed for: multi-team consistency, regulatory auditability, cross-domain entity resolution, and governed data access. The 6-primitive model maps directly to these. Primitives 5 and 6 are not optional features. They are architectural prerequisites for regulated, multi-agent deployments. Why enterprises need a context layer is not a philosophical question — it is a production prerequisite.
| Enterprise requirement | Which primitive addresses it |
|---|---|
| Consistent definitions across 10 agents | Primitive 5: Shared context layer (entity resolution) |
| Audit trail for compliance | Primitive 6: Control plane (immutable action log) |
| Data access governance | Primitive 6: Control plane (dataset-level access control) |
| Context that improves over time | Primitive 5: Cross-agent decision memory |
| Reproducibility across runs | Primitive 5: Versioned context (lineage-aware) |
| Agent actions on behalf of authorized users | Primitive 6: Agent identity and policy enforcement |
The context infrastructure that supports Primitives 5 and 6 is also what makes agent observability and auditability tractable at scale. You cannot audit what you cannot trace. And you cannot trace agent decisions without knowing which version of organizational context they drew from. The context layer ROI compounds over time: every improvement to the shared context layer benefits every agent in the fleet simultaneously.
Common mistakes when designing AI agent architecture
Permalink to “Common mistakes when designing AI agent architecture”The most common agent architecture mistakes are not model failures. They are context failures. Teams skip Primitives 5 and 6, then wonder why agents hallucinate business logic, contradict each other, or cannot pass a compliance audit.
1. Treating per-agent memory as sufficient for multi-agent systems
Per-agent memory is local. When Agent B needs what Agent A learned last week, there is no mechanism for that transfer without Primitive 5 as shared infrastructure. The result: duplicate work, contradictory outputs, and stale definitions that degrade accuracy as the agent fleet grows.
2. Adding governance as a post-launch step
Governance retrofitted onto an agent architecture is fragile. Audit trails and access controls added to a system not designed for them fail under compliance scrutiny. Primitive 6 must be architecture-time, not deployment-time. Context management across multi-agent systems from the start is the prerequisite for enterprise deployment, not a best practice to defer.
3. Confusing guardrails with a control plane
Guardrails validate inputs and outputs. A control plane enforces who can access what data and records what happened. Both are necessary; they are not the same. OpenAI’s guardrails are a quality gate. A governance primitive is an enforcement layer with an immutable record.
4. Building the context layer separately for each agent
Every team rebuilds the same glossary definitions, lineage references, and policy rules per agent. This is the most expensive form of the missing-primitive problem. The shared enterprise context layer should be built once, governed centrally, and consumed by every agent via a standard protocol like MCP.
Real stories from real customers: when the shared context layer is the missing primitive
Permalink to “Real stories from real customers: when the shared context layer is the missing primitive”Workday
"All of the work that we did to get a shared language at Workday can be leveraged by AI via Atlan's MCP server. As part of Atlan's AI labs, we're co-building the semantic layer that AI needs."
Joe DosSantos — VP Enterprise Data and Analytics, Workday
Result: 5x accuracy improvement using Atlan context products. The model did not change. The context did.
DigiKey
"Atlan enabled us to easily activate metadata for everything from discovery in the marketplace to AI governance to data quality to an MCP server delivering context to AI models."
Sridher Arumugham — CDAO, DigiKey
One shared context layer across every workload, every model, and every agent DigiKey runs.
The “shared language” Workday built is not stored in any single agent’s memory. It is Primitive 5: organizational context memory that all agents access via the Atlan MCP server. DigiKey’s result tells the same story: one governed organizational knowledge layer delivers consistency across every workload. That is the production reality of the 6-primitive model.
The 6-primitive model is what enterprise agents need
Permalink to “The 6-primitive model is what enterprise agents need”The standard framework debate — LangChain vs. AutoGen vs. CrewAI vs. OpenAI SDK — is a single-agent debate. Enterprise agents are a fleet problem, and fleets need shared infrastructure.
The 4-primitive model is the minimum for one agent to work. The 6-primitive model is the minimum for many agents to work together without contradicting each other, leaking data, or becoming unauditable. The difference is not philosophical; it is architectural.
The shared context layer (Primitive 5) is the organizational memory that makes every agent in the fleet start smarter than the last. It inherits the corrections, edge cases, and validated entity definitions that all prior agents generated. The control plane (Primitive 6) is what makes that fleet safe to run in a production environment where data governance, compliance, and access control are non-negotiable.
Prukalpa Sankar, Co-founder at Atlan, said at Atlan Activate 2026: “There is no intelligence without it being contextual. It’s purely an academic construct.” [CITE-NEEDED: verify verbatim against Activate 2026 keynote transcript] Model intelligence is one primitive. Context is the primitive that makes intelligence useful at scale.
Enterprises that build on 4 primitives stay in PoC. Enterprises that build on 6 — with a governed context layer and a real agent context layer — reach production.
Frequently asked questions
Permalink to “Frequently asked questions”1. What are AI agent primitives?
Permalink to “1. What are AI agent primitives?”AI agent primitives are the minimum architectural components required for an agent to function: a reasoning model, tools and actions, memory, and orchestration logic. Enterprise-grade agents require two more: a shared context layer (governed organizational definitions and lineage) and a control plane (access control, policy enforcement, audit trail). Most frameworks define 4–5 primitives; the complete enterprise model requires 6.
2. What is the difference between agent memory and a shared context layer?
Permalink to “2. What is the difference between agent memory and a shared context layer?”Per-agent memory stores what one agent learned in one session: its conversation history, retrieved facts, and session state. A shared context layer stores what the organization knows: governed entity definitions, certified business rules, data lineage, and cross-agent decision history. When a session ends, per-agent memory is lost or isolated; the shared context layer persists and improves with every agent run.
3. How does LangChain define agent primitives?
Permalink to “3. How does LangChain define agent primitives?”LangChain defines agents as a combination of a model (LLM), tools (callable functions), memory (in-context and external stores), and a system prompt (instructions). LangGraph extends this with graph-based orchestration for multi-agent workflows. LangChain does not define a shared organizational context layer or a governance control plane as primitives. These are intentionally left to the application layer by design.
4. Why do enterprise AI agents fail in production?
Permalink to “4. Why do enterprise AI agents fail in production?”Enterprise AI agents most commonly fail in production because of missing context infrastructure, not model limitations. Agents disagree on entity definitions, operate on stale or uncertified data, cannot pass compliance audits, and produce contradictory outputs across a multi-agent system. Research suggests 60% of enterprise AI projects are abandoned before production; context gaps are the leading architectural cause.
5. What is a control plane for AI agents?
Permalink to “5. What is a control plane for AI agents?”A control plane for AI agents is the governance primitive that enforces what agents are allowed to do, with which data, on whose authority. It covers agent identity verification, dataset-level access control, policy enforcement at runtime, and an immutable audit trail of every agent action and the context used. It is distinct from guardrails: guardrails validate inputs and outputs; a control plane enforces authorization and records every decision.
6. How do you share context between multiple AI agents?
Permalink to “6. How do you share context between multiple AI agents?”Sharing context across multiple AI agents requires a shared context layer as a first-class architectural primitive, not ad hoc solutions like shared Redis instances or copy-pasted glossaries. A governed shared context layer provides certified entity definitions, data lineage, and cross-agent decision memory that all agents read from at runtime via a standard protocol like MCP. Without this, every new agent rebuilds organizational context from scratch.
7. What is the PoC-to-production gap for enterprise AI agents?
Permalink to “7. What is the PoC-to-production gap for enterprise AI agents?”The PoC-to-production gap is the failure pattern where enterprise AI agents perform well in demos but break down in production deployments. The cause is almost always missing Primitives 5 and 6: no shared organizational context means agents contradict each other at scale; no control plane means the deployment cannot meet compliance or auditability requirements. Fixing the gap requires treating both as architecture-time requirements, not deployment-time add-ons.
Sources
Permalink to “Sources”- LangChain - Agent Architecture documentation (LangChain, 2025) - https://python.langchain.com/docs/concepts/agents/
- OpenAI Agents SDK - Agents key concepts (OpenAI, 2025) - https://openai.github.io/openai-agents-python/agents/
- Andrej Karpathy - Context Engineering definition (X/Twitter, June 2025) - https://x.com/karpathy/status/1937902205765607951
- Tobi Lütke - Context Engineering naming post (X/Twitter, June 2025) - https://x.com/tobi/status/1935533248663908573
- McKinsey - The State of AI 2025 - https://www.mckinsey.com/capabilities/quantumblack/our-insights/the-state-of-ai
- Gartner Data and Analytics Summit, Orlando, 2026 - “context is king” keynote
- AWS - What is an AI agent? (AWS, 2025) - https://aws.amazon.com/what-is/ai-agents/
- Atlan AI Labs - Context Quality Testing (Atlan, 2026) - https://atlan.com/resources/atlan-ai-labs-ebook/
