Every "state of the stack" post ages badly, so this one is dated on purpose and carries a source for each layer. This is the agentic stack as it actually looks in mid-2026, built from the bottom up: model, protocol, orchestration, memory, observability, and deployment. The pattern has held even as the names changed. Treat every capability line as something to verify on your own workload, not a spec to quote.
Layer 1: the model
The base layer is the model you route work to, and in mid-2026 the practical default for most builders is Anthropic's Claude 5 family. The lineup has a clear shape: Haiku 4.5 for cheap, fast, high-volume calls; Sonnet 5 as the daily driver for most coding and agent work; Opus 4.8 for hard reasoning; and Claude Fable 5, the first model in the Claude 5 family, in a new Mythos-class tier above the Opus line. Anthropic lays out the Fable 5 and Mythos 5 split in its announcement, and the model IDs (claude-fable-5, claude-opus-4-8, claude-sonnet-5, claude-haiku-4-5-20251001) are in the Claude Code docs.
The one rule that survives every model release: do not route everything to the smartest model. That is how you light money on fire. Send classification and glue to Haiku, most work to Sonnet, hard problems to Opus, and reserve Fable 5 for the genuinely gnarly cases. We wrote the economics of that up in the cheapest model is the most expensive mistake.
Layer 2: the protocol
Models are useful only when they can reach your tools and data, and the connective tissue in mid-2026 is two open standards. The Model Context Protocol is how agents connect to live systems, databases, and services through a common interface, so you write a server once and many agents can use it. Alongside it, the SKILL.md Agent Skills standard packages reusable procedural workflows that load on demand.
The division of labor is worth internalizing: MCP for live data and system connections, skills for repeatable how-to knowledge. Reaching for an MCP server when a skill would do is a common source of needless overhead, which is the whole argument in stop building MCP servers for everything.
Layer 3: orchestration
This is the harness that turns a model plus tools into an agent that reads a repo, edits files, runs commands, and checks its own work. In mid-2026 the two mainstream harnesses are Claude Code and OpenAI Codex, both spanning terminal, IDE, and cloud, and both supporting subagents for parallel workstreams.
The honest note on orchestration: more agents is not automatically better. Fanning a task out to twenty subagents multiplies both your token bill and your failure surface, and the coordination overhead often eats the speedup. The decision of when a single agent beats a swarm is covered in multi-agent orchestration overhead.
Layer 4: memory
An agent with no memory re-learns your project every session. In mid-2026 the memory layer has three tiers, and most real setups use more than one. Plain files, CLAUDE.md and AGENTS.md, hold always-on project rules the agent reads on every task. Retrieval over your codebase or docs pulls in only the relevant slice at query time. And MCP-backed stores hold structured, updatable facts.
Each tier fails differently: files go stale, retrieval returns the wrong slice, and shared stores can be poisoned by bad writes. The tradeoffs, with real paths and failure modes, are in coding agent memory: files, vectors, and MCP, and the retrieval-versus-long-context decision is in retrieval vs long context for codebases.
Layer 5: observability
Once agents run unattended, you cannot debug what you cannot see. The observability layer in mid-2026 is built on OpenTelemetry, with agent traces recording each tool call, its inputs, and its token cost, so you can answer two questions after a run: what did it actually do, and what did it cost. Token accounting is not a nicety here; a single looping agent can quietly re-process its whole context on every turn.
The practical build, including the OTel attribute names and a working way to account tokens per run, is in agent observability and token accounting.
Layer 6: deployment and safety
The top layer is where the agent's actions meet the real world, and it is the one people skip until it burns them. Two pieces matter most in mid-2026. Sandboxing: when an autonomous agent runs code, it should run in an isolated environment, not on your host, an isolation ladder covered in sandboxing untrusted agent code execution. And a merge gate: an agent that opens pull requests or fixes failing tests still needs a human approval and a cost cap, the setup in CI auto-fix for failing tests.
Prompt injection lives here too. Any agent that reads external content, web pages, issues, or news, is reading untrusted text that may try to hijack it, which is why the prompt injection rules are a release gate, not an afterthought.
How the layers fit
Read bottom to top, the stack is one sentence: a model you route by cost, connected through open protocols, driven by a harness, grounded by memory, watched through traces, and fenced by sandboxes and merge gates. Every layer has a boring default and a way it fails, and the builders who ship are the ones who pick the default and respect the failure mode. Nothing in this list is exotic. That is the point. A boring, legible stack is what lets the interesting part, your product, get the attention.
Keep your stack legible
The fastest way to lose a stack is to add a tool per week without recording why. Pressure-test yours with Rank My Stack, so each layer earns its place against a setup that already ships.
Sources and further reading
- Anthropic: Claude Fable 5 and Mythos 5
- Anthropic: Claude Code documentation
- Model Context Protocol
- OpenAI Codex documentation
- OpenTelemetry
FAQ
Which model should anchor my stack in mid-2026? For most builders, Sonnet 5 as the daily driver, with Haiku 4.5 for cheap high-volume calls, Opus 4.8 for hard reasoning, and Fable 5 for the genuinely hard cases. Route by the task, not by habit.
Do I need every layer to start? No. Start with a model and a harness, add memory when the agent keeps re-learning your project, and add observability and sandboxing before you let anything run unattended.
Why is this post dated so precisely? Because stack posts age fast. The layer structure is durable; the specific names in it are not. Check the linked sources for the current details before you commit.