Search for agentic AI architecture and you get a hundred diagrams. They are mostly the same diagram. Box at the top labeled "LLM." Boxes underneath labeled "tools," "memory," "planner." Arrows. Sometimes a robot icon.
The diagrams are not wrong. They are just where the architecture conversation ends, when the interesting part of the conversation is what is missing from them.
Every agentic AI stack has five layers, not three. The top three are the parts everyone is shipping right now. The bottom two are the parts a small number of teams are quietly building and the rest will need within a year.
Here are all five, in the order things actually depend on each other.
┌─────────────────────────────────────────┐
│ 5. Substrate where the work lives │
├─────────────────────────────────────────┤
│ 4. Memory what the agent knows │
├─────────────────────────────────────────┤
│ 3. Orchestration how steps chain │
├─────────────────────────────────────────┤
│ 2. Tools what the agent can do │
├─────────────────────────────────────────┤
│ 1. Model what reasons │
└─────────────────────────────────────────┘
Layer 1: Model
The model is the reasoning engine. Claude, GPT, Gemini, Llama, take your pick. It takes a prompt and a tool spec and returns either text or a tool call.
This is the most visible layer because it is what every product launch announces. It is also the most rapidly commoditizing. Two years ago there was one model that was clearly best at agent work. Today there are five. In a year there will be twelve. Picking a model is no longer a strategic decision; it is a pricing decision.
If your agentic architecture is just this layer with some glue, you are building on shifting ground. Every six months a smarter, cheaper, faster model lands and you rebuild your prompts.
Layer 2: Tools
Tools are what the agent can actually do. Read a file. Hit an API. Send a message. Update a row. Schedule a job.
The Model Context Protocol (MCP) is in the middle of standardizing this layer the way HTTP standardized network calls. Tools become discoverable, callable, and self-describing across any model that speaks MCP. A year ago every framework had its own tool schema; today there is one schema that most of them agree on.
Like the model layer, tools are commoditizing fast. The agent loops, the schemas, the auth flows are all converging. By 2027, picking a tool layer will be a pricing and breadth decision.
Layer 3: Orchestration
Orchestration is how steps chain together. The agent loop. The planner. The multi-agent coordinator. The retry policy. The reflection step.
This is the layer the frameworks own: LangChain, LangGraph, CrewAI, Mastra, Autogen, the OpenAI Agents SDK. Each framework has a different opinion on how to chain steps, but they are all converging on a small set of patterns: ReAct loops, plan-then-execute, multi-agent supervisor-worker, hierarchical task decomposition.
Most engineering teams roll their own orchestration in their first six months and end up with something that looks like one of the framework patterns by month nine. By 2027 this layer is also commoditized.
Layer 4: Memory
Memory is what the agent knows about the task, the user, and the past. There are three sub-layers here:
- Working memory. The context window. Whatever fits in the prompt right now.
- Episodic memory. What happened in past sessions. Usually a vector database with embeddings.
- Semantic memory. What is true about the world. Documents, knowledge bases, structured records.
Working memory is a feature of the model. Episodic memory is a feature of your stack. Semantic memory is the thing you have been building inside your company for ten years, just usually without naming it that.
Memory is the first layer that does not commoditize, because the contents are yours. Two companies running the same model with the same tools and the same orchestration will produce wildly different agent behavior based on what their agents know. The model is fungible. The memory is not.
But memory still has a problem. Vector databases hold embeddings. Knowledge graphs hold triples. Document stores hold text. None of these hold work in progress the way a real workspace does. None of them are designed for two agents and a human to write to in the same minute and have the result be coherent.
That is the gap layer 5 fills.
Layer 5: Substrate
The substrate is the place agent work lives.
Not the prompt the agent reads. Not the document it cites. Not the database it queries. The place where its actual output, its in-progress drafts, its decisions, its handoffs, its mistakes and its corrections accumulate over time. The place a human teammate reads to see what the agent did Tuesday morning. The place another agent reads on Wednesday to pick up where the first one left off.
In a chat world, the substrate is the chat scroll. Lossy, single-player, no attribution, no surface for review. It works for one human asking for one output. It breaks the moment work is multi-step and durable.
A real substrate has the same primitives a human team has been using to coordinate for decades:
- Typed state. Tables with typed columns. Docs with formatted prose. Row-level updates are atomic and observable.
- Identity per principal. Every edit is signed by a specific agent or human, not delegated through a shared token.
- Audit, not just logs. Append-only event ledger. Every change is queryable, streamable, exportable.
- Real-time presence. Cursors, status, presence flags. When the agent is mid-action, the workspace shows it.
- Comments and mentions. Threads on any row, any cell, any range. Mentions notify the right principal, agent or human.
The substrate is the layer nobody draws on agentic-architecture diagrams because, historically, there has not been one. Teams used wikis (built for humans, no agent identity). Project tools (built for humans, no real audit). Chat threads (no state at all). The substrate has been bodged together from whatever was nearby.
Why the substrate is the layer that compounds
The layers commoditize from the top down. Models commoditize fastest. Tools next. Orchestration after that. Memory is slower because the contents are proprietary, but the infrastructure of memory is becoming a commodity too.
The substrate is the only layer where the asset is the surface itself, not the contents on it. Like a database is a long-lived asset whether or not the schema changes. Like GitHub is a long-lived asset whether or not the languages on it change. The substrate is where the agent work lives, and the longer it lives there, the more valuable the substrate is.
This is why we built Dock at the substrate layer instead of higher up the stack. Models commoditize. Frameworks commoditize. The shared, persistent, auditable surface where mixed teams of humans and AI agents do their actual work does not. It compounds.
Where you should pay attention in your own stack
If you are designing an agentic architecture today, three questions are worth more than the others:
-
Where does the work land? Not where the prompt goes. Where the output, the partial drafts, the decisions, the trail end up. If your answer is "the chat scroll" or "a JSON blob in S3," that is your substrate gap.
-
Who signed each edit? When five agents have written to your state over a week, can you reconstruct who did what and when? If not, your substrate has no identity layer.
-
Can a human step in mid-task? Or does the agent finish, dump output, and only then can a human review? The first answer is collaboration. The second is a queue.
Get the substrate right and the other four layers slot in around it. Get the substrate wrong and every layer above it inherits the gap.
What we are building
Dock is the substrate layer. A shared cloud workspace where humans and AI agents read and write the same state in real time. Typed tables for structured work, docs for prose, comments for review, identity per principal, full audit. Agents have their own accounts. Humans have theirs. Both first-class.
If you are designing an agentic architecture and feeling the gap at the bottom of your diagram, that gap has a name.