Durable Sessions vs Agent Team Composition: Which Do You Need?
// TL;DR
These two frameworks solve completely different problems and are complementary, not competing. Use the Christensen Durable Sessions Framework when your AI product's streaming architecture breaks under real-world conditions — disconnections, multi-device use, or lack of live agent control. Use the Hetzel Agent Team Composition Framework when you need to staff and structure the cross-functional team that builds production-grade agents. Most teams building agentic products will eventually need both: the right people (Hetzel) building the right infrastructure (Christensen).
// HOW DO THEY COMPARE?
| Dimension | Christensen Durable Sessions AI UX Framework | Hetzel Agent Team Composition Framework |
|---|---|---|
| Best for | Fixing broken AI streaming UX and real-time delivery infrastructure | Designing the right cross-functional team to build production AI agents |
| Problem domain | Technical architecture — streaming, connectivity, multi-device sync | Organisational design — roles, ownership, team composition |
| Complexity | High — requires rearchitecting streaming layer, transport protocols, pub/sub infrastructure | Medium — requires org-level conversations, role reassignment, and process change |
| Time to apply | Days to weeks for architecture audit; weeks to months for full implementation | Hours to days for team audit; days to weeks for restructuring |
| Prerequisites | Existing AI product with a streaming architecture (SSE, WebSockets, etc.) | An organisation deciding who should build or own an agentic AI initiative |
| Output type | Architecture redesign — Durable Sessions layer, transport migration, multi-agent delivery topology | Team structure blueprint — role assignments, responsibility maps, eval/observability ownership |
| Primary audience | Systems architects, frontend/backend engineers, infra teams | Engineering managers, CTOs, VP of AI, product leaders |
| Creator background | Mike Christensen (Ably) — real-time infrastructure and streaming delivery | Phil Hetzel (Braintrust) — agent quality platforms, evals, and observability |
| Key innovation | Agent-client decoupling via persistent, resumable session channels | Domain experts — not data scientists — should own context engineering for agents |
| Failure mode addressed | Fragile demo syndrome: streams that break on disconnect, can't span devices, lack live control | The Isolation Mistake: handing agents to ML teams because 'AI' is in the name |
What does the Christensen Durable Sessions AI UX Framework do?
The Christensen Durable Sessions Framework diagnoses and fixes the most common architectural failure in AI chat and agent-driven products: the Single-Connection Trap. In the default streaming model (typically SSE via Vercel AI SDK or similar), the health of the AI response stream is coupled to a single client's network connection. If that connection drops, the stream is gone. If the user switches tabs or devices, they lose context. If they press a stop button, the system can't distinguish that from a network disconnect.
The framework introduces Durable Sessions — persistent, stateful, shared channels that sit between the agent layer and the client layer. Agents write events to the session; clients subscribe to the session. Neither holds a private pipe to the other. This single architectural inversion unlocks three foundational capabilities simultaneously: Resilient Delivery (streams survive disconnections), Continuity Across Surfaces (sessions follow users across tabs and devices), and Live Control (clients can steer, interrupt, or cancel agents mid-generation).
The framework provides a 10-step workflow that moves from auditing your current streaming model, through designing the Durable Sessions layer on a pub/sub substrate, to flattening multi-agent architectures so sub-agents write directly to sessions instead of relaying through an orchestrator bottleneck.
What does the Hetzel Agent Team Composition Framework do?
The Hetzel Agent Team Composition Framework solves an organisational problem: who should build, own, and govern agentic AI products? Its core insight is that traditional enterprises default to handing agent development to their ML or data science platform team because generative AI has 'AI' in the name. This is the Isolation Mistake, and it reliably produces teams that struggle to reach production quality.
The framework argues that the foundational model has already been built and deployed by providers like Anthropic and OpenAI. The highest-leverage work is now downstream of the API: context engineering (prompts, instructions, and context fed to the model), systems engineering (API integration, distributed orchestration, eval pipelines), and guardrails (risk assessment, LLM-as-judge validation, labelled datasets). These map to three distinct role types that must all be present on an agent team:
1. Data scientists / ML engineers — guardrails, eval validation, fine-tuning when truly needed
2. Product / systems engineers — distributed infrastructure, API integration, eval and observability pipelines
3. Domain experts / PMs — context engineering, human annotation, defining what 'good' looks like
The framework provides a 9-step workflow from classifying the organisation type (Traditional Enterprise vs AI Native) through auditing the team, mapping responsibilities, and designing the evals-plus-observability feedback loop.
How do the Durable Sessions and Agent Team Composition frameworks compare?
These frameworks operate on entirely different layers of the AI product stack, making them complementary rather than competing.
The Christensen framework is a technical architecture framework. It tells you what to build — specifically, how to rearchitect your streaming and delivery layer so your AI product doesn't break under real-world conditions. It assumes you have engineers capable of implementing pub/sub infrastructure, WebSocket transports, and session-layer abstractions.
The Hetzel framework is an organisational design framework. It tells you who should build it — specifically, how to compose and structure the team so that the right people own the right responsibilities. It assumes you have an agentic AI initiative underway but may have the wrong people assigned to the wrong roles.
Where they overlap is in the recognition that production-grade AI products require far more than model quality. Christensen emphasises that the gap between a fragile demo and a great product is in the infrastructure, not the model. Hetzel makes the parallel argument that the gap is in team composition, not model sophistication. Both are correct, and both problems must be solved.
If your AI product streams are breaking on disconnect and you can't support multi-device usage, the Christensen framework is the direct solution. If your agent team is staffed entirely with data scientists who are struggling with systems engineering challenges they weren't hired for, the Hetzel framework is the direct solution.
Which should you choose?
Use both — but in the right order for your situation.
Start with Hetzel if you are forming or restructuring a team for a new agentic initiative. Getting team composition wrong will slow down every subsequent technical decision, including any Durable Sessions implementation. You need systems engineers, domain experts, and data scientists in the right seats before you can execute an architecture migration.
Start with Christensen if you already have a functioning team but your AI product is exhibiting the classic symptoms of the Single-Connection Trap: streams lost on mobile, no multi-device continuity, ambiguous stop-button behaviour, or orchestrator bottlenecks in multi-agent setups. Your team is fine; your architecture needs the fix.
Use both together if you are a Traditional Enterprise standing up a production agent program from scratch. Apply Hetzel first to compose the team correctly, then apply Christensen to ensure the team builds a resilient, multi-surface delivery architecture from day one rather than accumulating technical debt in the streaming layer.
Neither framework replaces the other. They address orthogonal failure modes that both reliably prevent AI products from reaching production quality.
// FREQUENTLY ASKED QUESTIONS
Can I use the Durable Sessions framework and the Agent Team Composition framework together?
Yes, and most production teams should. The Hetzel framework tells you who should be on the team and what each role owns. The Christensen framework tells the systems engineers on that team how to architect the streaming and delivery layer. Apply Hetzel first to staff correctly, then Christensen to build the right infrastructure.
Which framework should I use if my AI chat keeps dropping responses on mobile?
The Christensen Durable Sessions Framework. Dropped responses on mobile are a textbook symptom of the Single-Connection Trap — your stream health is coupled to a single client's network connection. The framework walks you through introducing a persistent session layer that lets clients reconnect and resume automatically without agent-side replay logic.
My company assigned our ML team to build an AI agent and they're struggling. Which framework helps?
The Hetzel Agent Team Composition Framework directly addresses this. It calls this the Isolation Mistake — handing agent development to data scientists because 'AI' is in the name. The framework shows you how to restructure the team to include systems engineers for infrastructure and domain experts for context engineering.
Do I need the Durable Sessions framework if I'm using the Vercel AI SDK?
Likely yes. The Vercel AI SDK typically uses SSE for streaming, which creates the Single-Connection Trap by default. If your users experience any disconnection-related issues, need multi-device continuity, or need a working stop button that doesn't conflict with resume logic, the Christensen framework identifies exactly what to change.
Is the Hetzel framework only for large enterprises?
No. It covers both Traditional Enterprises and AI Native startups. For startups, the common gap is the absence of a guardrails role — no one stress-testing the LLM's limitations or validating eval quality. The framework recommends bringing in a fractional data scientist or assigning an engineer to own that function explicitly.
What's the difference between context engineering and building Durable Sessions?
Context engineering (Hetzel) is about crafting the prompts, instructions, and context fed to the model to control agent behaviour — an activity best owned by domain experts. Durable Sessions (Christensen) are about the infrastructure that delivers agent outputs to clients reliably across devices and connections. They operate on completely different layers of the stack.
Which framework helps with multi-agent architectures?
Both, in different ways. Christensen solves the Orchestrator Dual-Purpose Problem by having sub-agents write directly to Durable Sessions, eliminating the relay bottleneck. Hetzel ensures you have systems engineers — not just data scientists — owning the distributed infrastructure that sub-agent orchestration requires.
Do either of these frameworks help me choose which LLM to use?
No. Both frameworks explicitly assume the foundational model is already chosen and available via API. Christensen focuses on the delivery layer between the model and the user. Hetzel focuses on the team structure that builds around the model. Neither addresses model selection or benchmarking.