Frameworks, Runtimes, and Harnesses

The three tiers of the agent-building stack — framework, runtime, harness — explained for a developer new to the space. This is the vocabulary note the other agent notes lean on: LangGraph vs CrewAI Research compares two frameworks, Deep-Agents walks a harness in detail, and NAT-Lesson-0-Getting-Started shows a framework-tier wrapper in practice. Terminology follows LangChain’s product-concepts docs (see source), but the tiers are industry-wide, not a LangChain invention.

1. Why the vocabulary matters

Everything in this space gets called a “framework,” which makes tool selection conversations useless. “Should we use LangGraph or Claude Agent SDK?” is a malformed question — they don’t compete; they sit at different tiers of a stack, and real systems routinely use one of each. This note’s job is to make the tiers crisp enough that you can place any new tool you meet in about ten seconds.

2. The ladder, via a stack you already know

The cleanest anchor is the Python web stack, which has the same three-tier shape (and which the vault already documents — WSGI Reference, Gunicorn Reference, Werkzeug Reference):

Reading it bottom-up: nobody serves a website with raw WSGI unless they need that control; most build with Flask; and if the job is “I need a working blog today,” you install WordPress and customize. Same logic, tier for tier, with agents.

3. The three tiers in detail

3.1 Runtimes — durable execution infrastructure

A runtime answers the unglamorous production questions: what happens when the process dies mid-task? How does a workflow pause for three days awaiting a human decision? Where does state live? Its signature features are durable execution (checkpoint everything; resume after any failure), persistence (thread-level and cross-session state), human-in-the-loop interrupts, streaming, and low-level control over orchestration.

Two things worth noticing. First, LangGraph vs CrewAI Research treats LangGraph as a framework you write graphs in — also true; it straddles the line, offering low-level orchestration and the production runtime underneath. Second, Temporal and Inngest predate the AI wave entirely: durable execution is a general infrastructure category (workflow engines for payments, provisioning, ETL) that agents happen to need badly. That’s a useful sanity check — the runtime tier is real engineering, not AI hype.

Reach for the runtime tier directly when: the workflow mixes deterministic and agentic steps, must survive failures, runs long, or needs auditable state transitions.

3.2 Frameworks — abstractions for building

A framework is a library that gives you the standard parts as clean interfaces so you write application logic, not plumbing: model abstraction (swap providers without rewriting), tool definitions generated from function signatures (recall the schema anatomy from LLM Tool Calling — frameworks automate exactly that), a prebuilt agent loop, and middleware hooks. LangChain is the canonical example and is itself built on LangGraph — a framework running on a runtime, exactly like Flask on a WSGI server — but you can use it without ever touching graph primitives.

Reach for the framework tier when: building a standard agent application quickly, with orchestration needs that stay simple. This is the right default tier for most projects, most of the time.

3.3 Harnesses — the finished agent, ready to configure

A harness ships a working agent with the hard-won capabilities already engineered in: planning via to-do lists, a filesystem for offloading large results, subagent delegation, automatic context compression, persistent memory — the five capabilities Deep-Agents unpacks one by one, each a context-management strategy for long-horizon work. You supply tools, prompts, and configuration; the harness supplies the agent architecture. Claude Code is the harness you (and the reader) already use daily, which makes the tier easy to demo: watch a session write todos, spill research to scratchpad files, and spawn subagents.

Reach for the harness tier when: the task is long-running and multi-step (research, coding, operations), and the harness’s opinions fit. Building these capabilities yourself is weeks of subtle engineering — that’s the tier’s entire value proposition, and also its cost: when your process disagrees with the opinions, you fight them or drop a tier.

4. Choosing: start high, drop down on friction

The practical algorithm:

1. Can a harness do it? If the task fits the long-horizon shape and the defaults suit you, this is the least code and the most capability. Done.
2. Harness opinions in the way? Drop to a framework and build the agent yourself from clean parts.
3. Framework abstractions in the way — you need exact control over every transition, durable state, approval gates with audit trails? Drop to the runtime and design the graph (LangGraph vs CrewAI Research §2 shows what that buys).

And the escape hatch from LangGraph vs CrewAI Research §5 generalizes across tiers: compose them. A runtime-tier graph can contain a framework-built agent inside one node; a harness can be one step of a larger deterministic pipeline. The tiers nest — that’s the point of them being tiers.

One deliberate omission from the ladder: wrapper/integration layers like the NVIDIA NeMo Agent Toolkit don’t slot cleanly into any tier. NAT wraps agents from multiple frameworks behind one YAML/config/observability surface (NAT-Lesson-0-Getting-Started) — it’s plumbing across the stack rather than a rung of it, and its value case is precisely that framework choice becomes swappable.

5. Quick feature comparison (LangChain ecosystem)

How the same concern surfaces at each tier, using the one ecosystem that spans all three:

Same capabilities, different altitude: the runtime gives you the primitive, the framework gives you the abstraction, the harness gives you the default.

6. Related

• The-AI-Agents-Stack-Summary — the broader 2026 stack this three-tier slice lives inside.
• LLM Tool Calling → Model-Context-Protocol-MCP → A2A-Protocol — the protocol sequence underneath and alongside all three tiers.
• LangChain product concepts — the source taxonomy.