The CAR Framework: Why Agentic AI Breaks Without Structure (And How to Fix It)
Designing the experience layer that agent reasoning frameworks leave out.
I’ve shipped nine production agentic AI systems. The hardest problem wasn’t reasoning, tool orchestration, or model selection. It was the experience layer—the part users actually see.
I asked two AI browser agents to fill out a form, and both failed in ways that expose this gap perfectly.
Agent 1 (Comet) filled every field correctly. Then submitted the form—without asking. I told it to fill the form, not submit it. It couldn’t distinguish between a routine action and an irreversible one that required my consent.
Agent 2 (Atlas) took over five minutes with no visible progress. It eventually failed with “unknown error.” I had no idea what it was attempting, what was blocking it, or whether it was still running.
These aren’t edge cases. They’re the norm. And they reveal a structural gap in how we build agentic AI today.
The Missing Layer
Frameworks like ReAct (Reason + Act) and OODA (Observe-Orient-Decide-Act) are excellent at structuring how agents think. They power the reasoning loop—when to gather information, when to act, when to reassess. But they say nothing about what the user experiences during that loop.
That’s the gap. Every agent team reinvents answers to the same three questions:
Context strategy: What information is missing? Do we ask the user, search for it, infer from history, or pull from profile data?
Action logic: Which actions align with the task? Which ones are reversible? Which require explicit human approval before execution?
Response design: After acting, do we proceed to the next step, present options, gather more context, or pause for confirmation?
Comet’s failure was an action logic gap—it treated form submission the same as filling a text field, with no distinction between low-stakes and high-stakes actions. Atlas’s failure was a response design gap—no progress signal, no fallback, no transparency about what was happening.
Traditional UX design doesn’t solve this. Traditional software is deterministic: users click A and reliably see B. Every path is pre-scripted. Agentic AI is probabilistic: the agent decides what to do next based on context, and the path changes dynamically. We need structure that accounts for this shift—structure that works for both the builders planning these experiences and the AI executing them.
CAR: Context, Action, Response
CAR is a systematic loop that moves users from intent to task completion. Each cycle sharpens the next: responses feed back into context, actions become more precise, and the agent converges on what the user actually needs.
CONTEXT — Does the agent have everything it needs to act? Identify the delta—what’s missing—and determine the acquisition strategy: ask, search, reference history, or infer from profile. When context grows noisy, fall back to discovery mode and ask one decisive question to reset clarity.
ACTION — Rank possible actions by alignment with task success and user risk. Continuously evaluate: are we progressing toward completion? Does this action require human confirmation? Irreversible steps—payments, deletions, submissions—always require explicit consent.
RESPONSE — Decide the next move: proceed to the next segment, acquire additional context, or pause for human approval. Each response enriches the context for the next cycle, creating compounding momentum toward task success.
The key insight: CAR is not linear. It’s a feedback loop. Every response refines context, which sharpens the next action, which produces a better response. This compounding effect is what drives both task completion and user trust.
How CAR Complements Existing Frameworks
CAR doesn’t replace ReAct or OODA—it layers on top of them.
ReAct provides the reasoning loop (Thought → Action → Observation). CAR structures what users see during each cycle: what context is visible, when to automate versus ask, and how to present results.
OODA provides speed and adaptability. CAR operationalizes it for the experience layer by making response design a first-class outcome—one that feeds back into context and creates compounding trust.
Planner-executor patterns define agent architecture. CAR defines the UX boundaries—when to enforce human-in-the-loop checkpoints, where to surface progress, and how to handle failures gracefully.
Put simply: agent frameworks make agents intelligent. CAR makes them trustworthy.
CAR in Practice: A Shopping Agent
Here’s how CAR structures a simple shopping task. The goal isn’t to optimize a metric—it’s to ensure predictable reasoning, visible progress, and human-in-the-loop trust at every step.
User prompt: “Buy a white loose-fit, size M t-shirt under $40.”
Loop 1 — Discover (Context)
The agent parses explicit requirements (white, loose-fit, M, under $40) and identifies one ambiguity: priority. Does the user optimize for price, delivery speed, or quality?
It asks one clarifying question—not three. The user responds: “Budget.”
Context is now complete. The agent proceeds.
Loop 2 — Search (Action)
The agent normalizes terms, runs parallel searches across multiple stores, and scores results against the constraint set. It surfaces 5–7 options, each tagged with price, fit, and availability.
The user sees progress: a scored list, not a loading spinner.
Loop 3 — Evaluate (Response → Context)
The response from Loop 2 feeds back into context. The agent compares shortlisted options, validates size and color stock, and narrows to the best match.
It nudges: “This option matches all your criteria. Add to cart?”
Loop 4 — Checkout (Action → HITL Gate)
The agent prefills the checkout form, verifies the total, and stops. It does not submit. It presents a confirmation checkpoint: item, price, shipping, total.
The user confirms. The agent completes the purchase.
What CAR prevented: The agent reaching checkout and submitting payment without consent—which is exactly what happened in my baseline test run. The payment gateway demanded credentials before the agent halted, but that was luck, not design.
What success looks like: Item in cart. User saw progress at every step. Zero surprise actions.
The CAR Trace: Making Agent Behavior Auditable
One of the practical benefits of CAR is that it produces a structured trace—a log of what the agent knew, what it did, and what the user saw at each step. This makes agent sessions legible across product, design, and engineering.
Event types: context_gather, clarify, search, navigate, decision, response_display, hitl_check, halt.
[
{
"segment": "Discover",
"context": ["intent=tshirt", "color=white", "fit=loose", "size=M"],
"action": ["clarify"],
"response": ["priority=budget"]
},
{
"segment": "Search",
"context": ["priority=budget", "price_ceiling=40"],
"action": ["multi-site search", "filter", "score"],
"response": ["5 options displayed"]
},
{
"segment": "Checkout",
"context": ["selected_sku=ABC123"],
"action": ["prefill", "verify_totals"],
"response": ["hitl_confirm"],
"status": "awaiting_consent"
}
]
You can debug failures purely from this trace—without instrumenting metrics. When an agent misbehaves, you can pinpoint whether the breakdown was in context (wrong or incomplete information), action (wrong decision or missing guardrail), or response (poor communication to the user).
Implementation Playbook
For teams adopting CAR, the operationalization breaks down into six areas:
Journey-first roadmap. Map end-to-end segments (e.g., “Shop Product”) with clear entry and exit conditions. Define CAR requirements at each node—what context is needed, what actions are allowed, and what responses are expected.
Context capture by design. Use conversational questions, smart defaults from history, and progressive disclosure. Capture only what drives decisions. When context bloats, ask one decisive question to reset.
Action policies and guardrails. Define allowed tools per segment, escalation logic, HITL gates for irreversible steps, and fallback behaviors when the agent is stuck or timing out.
Response patterns. Standardize option cards, clarifying question formats, progress indicators, and error handling. Consistency builds trust across sessions.
Instrumentation. Log available context, actions attempted (with success/failure), responses shown, and user reactions. This becomes the dataset for improving the loop.
Operating cadence. Weekly reviews of segment drop-offs. Ship one CAR improvement per week. A/B test response patterns against task completion and user satisfaction.
How CAR Works with ReAct and OODA
CAR doesn’t replace existing agent frameworks—it complements them by adding the user-experience layer:
ReAct (Reason+Act) provides the reasoning loop: Thought → Action → Observation. CAR structures what users see during each cycle—what context is visible, when to automate vs. ask, how to present results and gather feedback.
OODA (Observe-Orient-Decide-Act) provides speed and adaptability. CAR operationalizes it for UX by making response design a first-class outcome that feeds back into context, creating compounding trust.
Why this matters: Agent frameworks make agents intelligent. CAR makes them trustworthy, transparent, and delightful. Together, they create agents that work and feel great.
Structure Creates Freedom
There’s an irony in agentic AI: more autonomy requires more structure. Agents have freedom to reason, navigate, and act—but without structure, that freedom becomes chaos. Users can’t trust what they can’t predict, and agents can’t build trust without consistent behavior at critical moments.
CAR provides that structure. It’s a loop—responses feed back into context, context sharpens actions, actions produce better responses—and that compounding dynamic is what drives both task success and user trust.
This isn’t just a framework for better agent experiences. It’s the layer that makes human-AI collaboration actually work.
I built CAR from shipping production agentic systems. If you’re building agents and hitting similar gaps—trust failures, invisible progress, consent violations—I’d like to hear how your team is solving them.
The future of AI isn’t just smarter models. It’s better structured experiences. CAR is how we get there.
Wow, the part about the agent experience layer being so ad hoc is so true! How do you think we'll ever get to a truly consistent UX for agents across different platforms, based on your brillant CAR framework?