Hetzel Agent Teams vs Christensen Durable Sessions: Which?
// TL;DR
Use both — they solve completely different problems and are complementary, not competing. If you must pick one to apply first: start with the Hetzel Agent Team Composition Framework if you haven't staffed your agent project yet, because the wrong team will build the wrong product regardless of infrastructure. Apply the Christensen Durable Sessions Framework once your team is in place and you're designing or debugging the real-time delivery layer of your AI chat or agent UX. One is about people, the other is about plumbing.
// HOW DO THEY COMPARE?
| Dimension | Hetzel Agent Team Composition Framework | Christensen Durable Sessions AI UX Framework |
|---|---|---|
| Best for | Deciding who should build, own, and evaluate an agentic AI system | Designing resilient, multi-surface, controllable AI streaming UX |
| Problem domain | Team design and organizational structure | Streaming architecture and real-time infrastructure |
| Complexity to apply | Moderate — requires honest org assessment, cross-functional negotiation | High — requires architectural redesign, transport layer changes, pub/sub infra |
| Time to apply | 1–2 weeks to audit and restructure team roles | 2–6 weeks to implement Durable Sessions layer and migrate streaming |
| Prerequisites | Access to org chart, current team members, agent use case definition | Existing AI chat/agent product with a streaming delivery mechanism |
| Output type | Team composition plan with role assignments and eval pipeline design | Architecture blueprint for Durable Sessions with gap map and migration steps |
| Creator background | Phil Hetzel — agent quality and AI team leadership | Mike Christensen (Ably) — real-time infrastructure and AI UX |
| When it's clearly better | Staffing a new agent initiative or diagnosing why an ML-heavy team is underperforming on agent work | Users losing streams on disconnect, no multi-device continuity, no stop button, orchestrator relay bottleneck |
| Audience | Engineering managers, VPs of AI/ML, product leaders, CTOs | Frontend/infra engineers, architect-level ICs, platform teams |
| Overlap with the other skill | Defines who builds the observability pipeline that Christensen's framework demands | Provides the infrastructure substrate that Hetzel's product engineers implement |
What does the Hetzel Agent Team Composition Framework do?
The Hetzel framework solves a specific organizational problem: most companies hand agentic AI development to their existing ML or data science team by default, because "it has AI in the name." Phil Hetzel argues this is a fundamental staffing error. Because the model is already built by Anthropic, OpenAI, or Mistral, the team's job is to implement, evaluate, and contextualize it — not to train one. This shifts the most valuable skills away from traditional ML engineering toward product engineering, domain expertise, and context engineering.
The framework provides a seven-step workflow: classify your organization type (Traditional Enterprise vs. AI Native), audit your current team for coverage gaps across three personas (data scientists, product engineers, domain experts), assign each persona their agent-specific role, and design a joint eval and observability pipeline. The core diagnostic is the "Proximity to the Problem" principle — the people closest to the problem the agent solves hold disproportionate value, and excluding them is the single most common mistake.
If your agent project is staffed entirely by ML engineers with no domain expert or product engineer in sight, this framework tells you exactly what's wrong and how to fix it.
What does the Christensen Durable Sessions AI UX Framework do?
The Christensen framework solves a specific infrastructure problem: most AI chat products stream responses over a single HTTP connection (typically SSE), and when that connection drops, the stream is gone. Mike Christensen identifies three foundational capabilities that separate a fragile demo from a production-grade AI product experience: Resilient Delivery (streams survive disconnections), Continuity Across Surfaces (session follows the user across tabs and devices), and Live Control (users can steer, interrupt, or cancel an agent mid-generation).
The solution is to introduce a Durable Sessions layer — a persistent, stateful, shared resource sitting between the agent layer and the client layer. Agents write events to the session; clients subscribe to the session. Neither holds a direct pipe to the other. This architectural inversion eliminates the Single-Connection Trap, resolves the SSE Resume-Cancel Conflict (where closing a connection is ambiguous between "resume" and "cancel"), and flattens multi-agent architectures by letting sub-agents write directly to the session instead of relaying through an orchestrator.
If your users lose AI responses when switching networks, can't see a live response on a second device, or your stop button is unreliable, this framework diagnoses exactly why and provides a concrete migration path.
How do they compare?
These two frameworks operate at entirely different layers of the stack and do not compete. The Hetzel framework is about people: who should be on the team, what each person's role is, and how to structure evaluation so it reflects functional performance rather than narrow ML metrics. The Christensen framework is about plumbing: how to architect the real-time delivery layer so the AI experience is resilient, multi-surface, and controllable.
There is, however, a meaningful connection. Hetzel's framework explicitly calls for product and systems engineers to "manage the systems and infrastructure where agents execute" and to "build the eval and observability pipelines." The Durable Sessions architecture is precisely the kind of infrastructure those product engineers would implement. Conversely, Christensen's framework assumes you have competent engineers who understand both the agent layer and the client layer — exactly the cross-functional team that Hetzel's framework produces.
Neither framework addresses what the other solves. Hetzel will not fix your broken SSE streaming. Christensen will not fix your team staffed entirely by data scientists who are optimizing for F1 scores on an agent that should be solving customer problems.
Which should you choose?
Apply both, sequentially. Start with Hetzel if you are early in the project lifecycle — before or during staffing. A well-composed team will naturally identify the streaming architecture problems that Christensen's framework solves. Apply Christensen once you have a working agent product that needs to survive real-world conditions: network drops, multi-device usage, user-initiated control, or multi-agent concurrency.
If you are a leader or manager deciding who should own your agent initiative, Hetzel is your framework. If you are an engineer or architect debugging why your AI chat UX breaks under real usage, Christensen is your framework.
If you are forced to pick only one: the Hetzel framework comes first, because the wrong team will build the wrong infrastructure. Getting the team right is prerequisite to getting the architecture right.
Can you use both frameworks on the same project?
Yes, and you should. The Hetzel framework produces the cross-functional team — including the product and systems engineers — who are the natural owners of the Durable Sessions architecture that Christensen's framework prescribes. Use Hetzel in weeks 1–2 to staff and align the team. Use Christensen in weeks 3–8 to audit and redesign the streaming infrastructure. The domain experts identified by Hetzel will also inform what "Live Control" interactions users actually need, which directly shapes the Christensen implementation.
// FREQUENTLY ASKED QUESTIONS
Do I need both the Hetzel and Christensen frameworks for my AI agent project?
Yes, they solve completely different problems. Hetzel tells you who should be on the team and what each person's role is. Christensen tells you how to architect the real-time delivery layer so your AI UX doesn't break under real-world conditions. Use Hetzel first to staff the team, then Christensen to fix the streaming infrastructure.
Which framework should I use first when building an AI agent product?
Start with the Hetzel Agent Team Composition Framework. The wrong team will build the wrong infrastructure regardless of how good the architecture blueprint is. Get your cross-functional team in place — data scientists, product engineers, and domain experts — then apply Christensen's Durable Sessions framework to design the delivery layer.
Is the Hetzel framework only for large enterprises?
No. Hetzel explicitly covers two organization types: Traditional Enterprises (existing ML teams handed the agent mandate) and AI Natives (small startups built around agents). AI Natives typically have proximity to the problem but lack eval rigor and statistical guardrails. The framework diagnoses gaps for both types.
Does the Christensen Durable Sessions framework require WebSockets?
Not always, but if you need Live Control — stop buttons, steering messages, or user-initiated cancellation mid-generation — then yes. SSE is strictly one-way, creating an irresolvable ambiguity between resume and cancel on connection close. Bidirectional transport like WebSockets is necessary for live control. For resilience and multi-surface continuity alone, the transport is more flexible.
Can I apply the Christensen framework if I'm using the Vercel AI SDK?
Yes, but the framework will likely reveal that your current Vercel AI SDK SSE streaming is inside the Single-Connection Trap. You would need to introduce a Durable Sessions layer between your agent and client, redirect agent output to write to that session, and have clients subscribe to it — rather than relying on the default direct SSE pipe.
What's the biggest mistake the Hetzel framework prevents?
Handing agentic AI development entirely to your ML or data science team because 'it has AI in the name.' The model is already built by OpenAI, Anthropic, etc. The team's job is to implement, evaluate, and contextualize it — which requires product engineers and domain experts, not just ML engineers optimizing precision and recall.
What's the biggest mistake the Christensen framework prevents?
Building resume and reconnect logic inside the agent itself. This creates per-client replay complexity that scales poorly and couples agent code to connection management. The fix is to move all delivery complexity into a Durable Sessions layer so the agent only writes events to a persistent channel and never manages client connections.
Are these frameworks about choosing an LLM or AI model?
No. Neither framework addresses model selection. Hetzel explicitly states 'the model is already built' and focuses on team composition and evaluation. Christensen focuses on the streaming and delivery infrastructure layer, not the model layer. Both assume you have already chosen your LLM provider.