Most organizations talk about “AI” as if it were one thing.
It isn't. A pricing rule, a demand model, a copy-drafting assistant, and an agent that coworks on a quarterly business review are fundamentally different systems — different failure modes, different governance needs, different demands on the humans around them. Plot two axes and four quadrants fall out, each mapping almost exactly to a generation of AI.
X-Axis
Complexity of Execution
How many steps, systems, and dependencies must be coordinated for the task to complete? Low is a single contained action. High is multi-step, multi-tool work that unfolds over time.
Y-Axis
Ambiguity of Judgment
How much does the “right answer” depend on interpretation, context, and values? Low ambiguity means the correct output is knowable and checkable. High ambiguity means reasonable people could land in different, still-defensible places.
HighAmbiguity of Judgment ↑Low
Low exec · High ambiguityQ3ComposeDraft · summarize · generateOne simple inference call, but no single correct output — tone and appropriateness are judgment calls.✦ GenAI
High exec · High ambiguityQ4 · The FrontierOrchestratePlan · call tools · coworkAgents that coordinate multi-step workflows and make sequential decisions with no ground truth to check in the moment.✦ AI Agents
Low exec · Low ambiguityQ1CodifyIf-this-then-thatDeterministic logic: one contained action, one correct answer. Cheap, auditable, fast.✦ Rules / RPA
High exec · Low ambiguityQ2ComputeForecast · predict · rankComplex to build, but the objective is clear and the output is checkable against ground truth.✦ ML Models
LowComplexity of Execution →High
Each quadrant maps almost exactly to a generation of AI technology — and to a distinct human role.
The four quadrants in depth
Four systems, four human roles
Each quadrant carries its own failure modes and its own demand on the people around it. The technology it maps to is only half the story — the other half is what the human is there to do.
Q1 · Codify
Deterministic logic
Rules engines · RPA bots · validation checks
Low execution · Low ambiguity
The oldest form of “AI” in the enterprise and often the most under-appreciated — not exciting, but cheap, auditable, and fast. One contained action, one correct answer.
◆ Use-case scenario
A pricing rule automatically blocks any price change that would push an item's margin below a set floor, and routes it for review. The logic is fixed and the outcome checkable — the rule either fired correctly or it didn't.
◆ Human's role — Designer of the rule
Judgment is front-loaded into writing the rule correctly; after that, oversight is mostly exception handling. This quadrant needs the least ongoing human judgment of the four.
Q2 · Compute
Classic ML / AI
Forecasting · elasticity · churn · recommenders
High execution · Low ambiguity
Execution is genuinely complex — feature engineering, training, tuning, serving at scale — but the objective function is clear and the output is checkable against ground truth.
◆ Use-case scenario
A demand-forecasting model predicts next week's unit sales per SKU per store to drive replenishment. Building it is hard, but “was the forecast accurate?” has a factual answer once the week closes — so it can be measured, retrained, and trusted on merit.
◆ Human's role — Validator & model owner
Humans define the objective, choose features and constraints, and judge whether accuracy and behavior are fit for purpose. The judgment is technical — “is this good enough and safe enough to trust” — not interpretive.
Q3 · Compose
GenAI in its common form
Drafting · summarizing · creative variants
Low execution · High ambiguity
The execution itself is simple — one inference call — but there's no single correct output. Tone, framing, and appropriateness are all judgment calls.
◆ Use-case scenario
GenAI drafts product descriptions and marketing copy for thousands of catalog items. Any one draft returns in seconds, but whether it's on-brand, accurate, and compelling is a judgment no metric fully settles — so a human has to shape and approve it.
◆ Human's role — Editor & curator
The job shifts from writing the answer to evaluating and shaping it — prompting well, reviewing critically, deciding what “good” looks like in context. Genuinely new work; prompt design and evaluation are becoming real job functions.
Q4 · OrchestrateThe Frontier
AI agents that cowork
Plan · call tools · coordinate multi-step workflows
High execution · High ambiguity
Both axes maxed out: execution spans systems and time, and there's no ground truth to check each judgment call against in the moment.
◆ Use-case scenario
An analyst partners with an agent to build a quarterly business review. The agent pulls numbers from the BI platform, gathers context from documents and prior decks, drafts the narrative, flags anomalies, and iterates over several rounds. Genuine cowork — the analyst steers, challenges, and owns the final narrative.
◆ Human's role — Supervisor & accountability holder
Humans can no longer review every action. The job moves to designing guardrails, defining escalation thresholds, auditing outcomes in aggregate, and remaining accountable. “Human-on-the-loop,” not “human-in-the-loop” — and it needs logging, escalation paths, and kill switches most orgs haven't built.
The pattern across the quadrant
The human arc
The human doesn't disappear as you move up and to the right — the nature of their judgment changes.
1
Q1 · Codify
Designer of the rule
Judgment front-loaded and technical.
2
Q2 · Compute
Validator of the model
Judgment technical, on merit.
3
Q3 · Compose
Editor of the output
Judgment ongoing and interpretive.
4
Q4 · Orchestrate
Supervisor of the system
Judgment at the level of behavior.
In Q1 and Q2, human judgment is front-loaded and technical. In Q3 and Q4, it becomes ongoing and interpretive — eventually exercised at the level of the system's behavior rather than any single output. That's a genuinely different skill set, and usually not the one already sitting in an organization's rules-engine or data-science teams.
The adoption cost of each quadrant
Change management underneath each quadrant
The quadrant is also a map of how much an organization must change to adopt each type well — and the change gets harder as you move up and to the right.
Q1
Displacement & trust in automation
Mostly operational. Redeploy the people whose manual checks the rule now performs — don't just tell them the bot has their job. The trap is quiet resistance (shadow manual processes “just in case”). The fix: transparency and involving process owners in writing the rule.
Q2
From intuition to model-driven decisions
The hard change is cultural, not technical: getting experts to trust a forecast over their gut. Position the model as a decision aid the expert owns — able to see why it said what it said and to override with a reason. Explainability isn't a nice-to-have; it's the adoption strategy.
Q3
The new skill of editing & evaluating
Writing content becomes reviewing and directing it — a different skill. People need training and permission to reject AI output, plus clear quality bars. Watch two failure modes: over-trust (shipping unreviewed output) and over-rejection (quietly not using the tool).
Q4
Supervising a system you don't control step-by-step
The deepest change, because it touches accountability. It works only with trust built incrementally, clear ownership of the agent's output, and visible guardrails. Rush it and you get rejection (“not putting my name on it”) or abdication (“not my problem”) — both dangerous.
The cross-cutting theme
Change management shifts from retraining tasks (Q1–Q2) to rebuilding trust and redefining roles (Q3–Q4). The adoption bottleneck is almost always human — so the change effort should scale with the quadrant, not with the size of the model.
For the C-suite
What AI leadership should take from this
Five moves that follow directly from knowing which quadrant a piece of work belongs in.
1
Match governance to ambiguity, not hype
A high-complexity forecast (Q2) and a low-complexity GenAI draft (Q3) can carry very different risk profiles. Governance should scale with how much interpretation is involved — not with how impressive the technology sounds.
2
Don't govern every quadrant the same way
Q4-level scrutiny on a Q1 rule kills velocity for no safety benefit; Q1-level scrutiny on a Q4 agent is how orgs get surprised. Most governance failures are a mismatch of this kind — not a lack of governance overall.
3
Build the muscle you're missing
Most enterprises are well-staffed for Q1 and Q2. Few have invested in Q3 evaluation design or Q4 agent-guardrail design as disciplines. If agentic AI is on your roadmap, the gap is usually not the model — it's the muscle to supervise it.
4
Change what you measure as you move right
Q1 and Q2 are measured on accuracy and throughput. Q3 and Q4 need judgment-quality measures — escalation rates, override rates, outcome audits — because “did it execute” stops being the interesting question once ambiguity is high.
5
Expect a portfolio, not a single answer
Most real functions need all four quadrants working together: rules for guardrails, ML for forecasts, GenAI for content, and agents to orchestrate across the whole. The leadership job is knowing which quadrant each piece belongs in — and resourcing the human role it demands.
From map to build
Now the concrete part: how each quadrant actually works
The framework is the easy half. The hard half is what it takes to build in each quadrant — and what specific engineering you add to move up (more ambiguity) or right (more execution, toward true co-work). Below: an engineering spec per quadrant, then the two moves broken down to the component level, then a real agent decomposed end-to-end.
The engineering underneath
A spec sheet for each quadrant
Same four quadrants — but now the stack, the data, how you prove it's “good,” the dominant failure mode, and the infrastructure each one demands. The pattern to notice: as you move up-and-right, verification is replaced by evaluation, and a single call is replaced by a governed loop.
Two moves — and they're different engineering problems
You don't drift diagonally. You make two distinct investments: moving up means engineering for ambiguity; moving right means engineering for execution and, ultimately, co-work. Most teams underestimate the first and rush the second.
Q3 ComposeGenAI
Q4 OrchestrateAgents
Q1 CodifyRules
Q2 ComputeML
↑ Ambiguity
Execution →
Move up ↑
Engineering for ambiguity
Q1→Q3 and Q2→Q4. The right answer stops being checkable, so you can no longer assert correctness — you have to evaluate quality.
The core shift: from verification (a test that passes) to evaluation (a judgment of quality across a distribution).
Move right →
Engineering for co-work
Q1→Q2 and Q3→Q4. One contained action becomes a multi-step process that spans systems and time, and takes actions on your behalf.
The core shift: from a single call to a governed loop of planning, tool use, memory, and human checkpoints.
The upward move, concretely
What you build to survive more ambiguity
In Q1/Q2 you write a test and it passes. In Q3/Q4 there is no single correct output to test against — so you replace the test suite with an evaluation system and constrain the space so the model can't wander. Six concrete additions:
1
Grounding
Constrain the answer space with retrieval: RAG, citations, structured context. Less room to invent = less ambiguity to manage.
2
An eval harness
Golden datasets + rubric scoring + LLM-as-judge (calibrated against human labels). You measure a distribution of quality, not pass/fail.
3
Human preference signal
Capture edits, approvals, and rejections as labeled data. Pairwise comparison and preference data become your ground-truth proxy.
4
Guardrails
Input/output filters, policy & PII checks, prompt-injection defense — because you can't pre-verify every generation.
5
Calibration & abstention
Let the system say “I'm not sure” and escalate. Confidence thresholds turn ambiguity into a routing decision, not a silent guess.
6
Feedback loop
Route human corrections back into prompts, few-shot examples, or fine-tuning. The system improves on the exact judgments it gets wrong.
The rightward move, concretely
From Compose to co-work: the capability ladder
Getting from a GenAI draft (Q3) to an agent that coworks on a QBR (Q4) is not one leap — it's a stack of capabilities, each adding real power and a new class of risk you have to control. This is the concrete path from “one inference” to “governed loop.”
Start · Q3 ComposeEnd · Q4 Orchestrate
1
Single inference Q3 baseline
One prompt in, one output out. Stateless. The human triggers it and edits the result — classic Compose.
Adds: nothing new. Ceiling: can't act, can't use fresh data, can't take more than one step.
2
+ Retrieval (RAG) grounding
Pull real, current context from your systems (vector search, BI, docs) into the prompt so the output is grounded in truth, not the model's memory.
Adds: accuracy & freshness. New risk: retrieval quality — wrong context in, confident wrong answer out.
3
+ Tool / function calling it can now act
The model calls typed functions with validated arguments — run a SQL query, fetch a report, generate a chart. This is the line where it stops talking and starts doing.
Adds: real actions across systems. New risk: tool misuse & side effects — every tool needs scoped, sandboxed permissions.
4
+ Planning & reflection loop multi-step
Decompose a goal into steps and iterate — ReAct or plan-and-execute: reason → act → observe → re-plan. The agent now chains many calls toward an objective.
Adds: autonomy over sequences. New risk: compounding errors & runaway loops — needs step limits and checks.
5
+ Memory & state continuity
Working memory across steps and durable memory across sessions, so the agent carries context, prior decisions, and the analyst's earlier steering into later rounds.
Adds: coherent multi-round cowork. New risk: stale or poisoned memory quietly corrupting later decisions.
6
+ Orchestration control flow
A supervising layer (state graph / controller, e.g. LangGraph-style) coordinates tools and sub-agents with branching, retries, and error handling — turning a loose loop into a reliable workflow.
Adds: reliability at scale. New risk: emergent behavior across components that no single step reveals.
7
+ Guardrails, HITL & observability Q4 co-work
The controls that make supervision real: human-on-the-loop checkpoints, escalation thresholds, action-scoped guardrails, budget/rate caps, full trace/observability, and a kill switch. This is the rung that makes co-work safe enough to trust.
Adds: accountable autonomy — the analyst steers and owns; the agent does the legwork. Without it: you have autonomy no one can supervise.
A real Q4 system, decomposed
Worked example: the QBR co-work agent
The article's quarterly-business-review agent, drawn as an actual architecture. The analyst sets the goal and owns the narrative; the agent runs the loop below — retrieving, acting, drafting, and pausing at human checkpoints — inside a cage of guardrails.
🧠
1 · Plan
Decompose the QBR goal into steps & data needs.
🔧
2 · Retrieve & act
Query BI, pull prior decks & docs via scoped tools.
✍
3 · Draft & flag
Write the performance narrative; surface anomalies.
👤
4 · Human checkpoint
Analyst reviews, challenges, steers the story.
✅
5 · Iterate & own
Refine over rounds; analyst owns the final QBR.
↻ Steps 2–4 loop across several rounds — the agent re-plans as the analyst reacts. No human scripts each step; no single correct QBR exists.
🛡 Guardrails
Data-access scoped to the analyst's permissions; no external send; policy & PII filters on every draft.
⏱ Escalation
Low-confidence numbers or unexplained anomalies are flagged up, not silently included.
🔍 Observability
Every tool call, prompt, and decision is traced — so outcomes can be audited in aggregate.
🛑 Kill switch
The analyst can stop or override the run at any checkpoint and remains the accountable party.
Underneath the ambiguity axis
Not all uncertainty is the same
The Y-axis quietly blends two fundamentally different kinds of uncertainty. Telling them apart is the difference between a problem you can solve and one you can only manage — and it's the single most useful idea for anyone building non-deterministic systems.
Epistemic
Reducible uncertainty
You can shrink it — so reduce it
You're unsure because you lack knowledge: not enough data, features, or model capacity. There is a right answer; you just can't see it clearly yet. More and better data collapses it toward that answer. This is the uncertainty of Q1→Q2 — a fuzzy forecast sharpens with more history.
How you attack it: collect more data, better features, retraining, ensembles, active learning, RAG grounding, confidence intervals. Effort converges on truth.
Aleatoric
Irreducible uncertainty
You can't shrink it — so manage it
The task itself is genuinely non-deterministic: inherent noise, or many equally-defensible “right” answers. No amount of data collapses it, because there is nothing to collapse to. This is the uncertainty of Q3→Q4 — “the best on-brand tone,” “the right QBR narrative.”
How you manage it: human ownership, present a range or options not a point answer, calibrated abstention, guardrails on the acceptable band, preference learning to encode taste (shrinks perceived ambiguity, never to zero).
⚠ The cardinal mistake
Teams treat aleatoric ambiguity as if it were epistemic — pouring more data, bigger models, and stricter evals at Q3/Q4 expecting the output to converge on one “correct” answer. The residual is irreducible, so it never converges. That is precisely why the top of the quadrant needs a human owner and a defined “good-enough range,” not a hunt for a ground truth that doesn't exist.
Human curation isn't a single moment. There are three distinct windows to inject judgment — and most teams only use one. The higher the quadrant, the more you need all three working as a flywheel, because you can't front-load every decision into code the way Q1 does.
Clock 1 · before it runs
Design-time
Humans as architects of the envelope
Bake judgment into the system up front: system prompts & policies, the tool / action allow-list, guardrail rules, eval suites, few-shot exemplars, fine-tuning & RLHF, the “constitution.”
Q1 lives entirely here — write the rule once. In Q4 it sets the boundaries the agent may never cross.
Clock 2 · while it runs
Runtime
Humans as pilots
Steer in the moment: approval checkpoints (human-on-the-loop), live interventions and overrides, answering the agent's escalations, correcting mid-task before errors compound.
The heart of Q4 co-work — barely exists in Q1. This is where the analyst steers the QBR agent round by round.
Clock 3 · after it runs
Learning-time
Humans as editors of its future
Curate outcomes to improve the next run: audit trajectories, label good/bad, update evals & prompts, capture overrides as preference data, widen or tighten the action scope on track record.
Closes the loop back to design-time — learning-time evidence is what earns an agent a wider envelope.
Design-time → Runtime → Learning-time ↻ a flywheel: each run's outcomes reshape the next run's envelope.
How the mix shifts across the quadrant
In Q1, judgment is almost entirely design-time — you write the rule and walk away. As you climb toward Q4, judgment spreads across all three clocks: set the envelope, steer inside it, and reshape it from outcomes. Supervising an agent means owning all three, not just the code review.
The quadrant tells you what kind of system you have. These four sharpen how you actually govern the hard corner — and each one cuts across all four quadrants rather than sitting in one.
🎟
Graduated (earned) autonomy
Autonomy isn't binary — it's a dial the agent earns. Move it one notch at a time: assist → draft-with-approval → act-within-scope → act-and-report. Calibrated confidence and track record (from learning-time) unlock a wider action scope.
Trust is granted incrementally, never by default.
🚪
Reversibility & blast radius
The hidden third axis. Two-way doors (reversible, cheap to undo) can run with light gating even in Q4. One-way doors (money moved, message sent, data deleted) need a hard human gate regardless of quadrant. Govern by consequence, not just ambiguity.
Ask not only “how ambiguous?” but “how reversible?”
📊
The oversight budget
Human attention is finite and does not scale with agent throughput. You can't review every action, so spend oversight where marginal value is highest: low-confidence, high-impact, irreversible, or novel cases. Sampling plus escalation — not blanket review.
Attention economics: supervise the exceptions, audit the rest.
⚖
Trust calibration
The goal isn't maximum trust — it's calibrated trust: reliance that tracks real reliability. Over-trust ships unreviewed errors; under-trust means shadow manual work and wasted capability. Confidence signals, transparency, and audit history keep the two aligned.
Match the trust to the track record — both directions are failures.
The next time an initiative gets pitched to you as “AI,” ask one thing first: which quadrant is this really in?
The answer tells you what kind of human oversight it needs — and whether you currently have it.