Human, agent, or automation? Assign work with this matrix

Score every task on four dimensions

The matrix starts with four scores, not one. Before you decide who owns a task, rate it on each:

• Repetition: how often the work happens. Rare work rarely repays the setup.
• Variation: how different each case is from the last.
• Consequence: what a wrong result costs.
• Reversibility: how quickly a mistake can be undone.

How the scores route the work: the first two dimensions pick the worker, and the last two set the guardrail. Low variation means a fixed rule fits, so the step is automation; high but checkable variation is an agent’s job; and wherever consequence and low reversibility climb together, a person keeps the decision no matter how repetitive the task is. That last rule is the point of the whole grid: a job can be highly repetitive and still be yours if a mistake is expensive and permanent.

How to judge your scoring: write the four numbers beside the task, then ask someone else to score it blind. If you land far apart, the task is not defined tightly enough to hand off yet—and that gap, not the average, is the real finding.

The common failure is scoring only one dimension: “Can the agent do this?” Almost anything can be drafted by an agent, so that question quietly green-lights work that should have failed on consequence. The trade-off is honest—four scores take a few minutes longer than a gut call, but the gut call is exactly how high-stakes work ends up on autopilot.

Assign predictable repetition to automation

High repetition with low variation belongs in a fixed workflow: moving data between the same two places, sending a standard receipt, applying an exact rule that never bends. Here “automation” means the step follows instructions you could hand a new hire on a sticky note—no interpretation required.

Why it matters: judgment is the expensive ingredient. Spending an agent’s interpretation on work that has one correct answer adds cost and invites creativity exactly where you did not want any.

How to judge it: if you can write the whole task as an if this, then exactly that a coworker could follow without calling you, it is automation-ready. If your rule needs three “it depends” clauses, the variation is higher than you scored it.

The failure case is brittleness. A fixed rule breaks the moment the input shifts—a renamed field, a new message format—and it breaks quietly, doing the wrong thing confidently until you happen to notice. The trade-off: automation is the cheapest worker to run and the least forgiving when the world changes, so pair every fixed rule with a simple check that the output still looks normal.

Assign bounded variation to agents

Agents fit repeated work where the wording or context changes every time but the result can still be checked: summaries, first-draft research, sorting messages, preparing a document. The variation is real, so a rigid rule fails—but the answer is verifiable, so a person can catch a bad one fast.

Why it matters: this is the band a fixed workflow cannot reach and a founder should not spend a whole afternoon on. An agent turns “read forty messages and sort them” into “review forty sorted messages,” which is a different-sized job.

How to judge it: can you check one output in about five minutes against a named source? If yes, the task fits. If checking the work takes as long as doing it, the leverage is not there and the task is miscast.

The failure case is unbounded scope. “Handle support” gives the agent no edge to fail against, so you cannot tell a good run from a bad one. Narrow it to “draft replies to shipping questions using the approved policy” and every output becomes reviewable. The trade-off is review time: an agent only saves you time when reading its output is genuinely faster than doing the task yourself, so keep the scope tight enough that it is.

Keep high-consequence judgment human

People should keep negotiations, legal commitments, sensitive personnel calls, and any exception whose cost is hard to reverse. The agent can gather the evidence and lay out the options; it should not make the call. Google’s People + AI research finds that people prefer to stay accountable for exactly these stakes—physical, emotional, and financial—so an agent designed to decide them anyway works against the instinct of the person who has to live with the result.

Why it matters: high consequence plus low reversibility is the one square where a confident, well-worded wrong answer costs the most. An agent’s fluency becomes a liability here—it makes a poor decision read like a considered one.

How to judge it: ask, “if this goes wrong, how long and how costly is the undo?” If the answer is more than a minute and reaches someone outside your dashboard, keep the decision human and let the agent prepare it.

The failure case is subtle: the draft looks right, so the agent is allowed to send it, and the damage lands on tone or a relationship rather than on data—the kind of mistake no log flags. The trade-off is plainly slower work, but slowness is the point precisely where being wrong is expensive to unwind.

Use a hybrid by default

Most real tasks are not one worker’s job—they split. Let automation gather the facts, let the agent interpret them into a proposed action, and let a person approve when the consequence rises. Pure-human is slow everywhere; pure-agent is risky everywhere; the split spends speed where it is safe and judgment where it counts.

Why it matters: the value is in the seams. A task that felt “too risky to automate” is usually only risky in its final step; the gather-and-draft work in front of it was safe all along, and hiding that safe part behind the risky one throws away most of the time saved.

How to judge the handoff: a good one carries its own evidence. The reviewer should be able to decide from the message itself—what the agent found, what it proposes, and what becomes true if they say yes—without opening another system.

The failure case is a handoff that shows only a verdict: “I recommend approving this.” With no evidence attached, the person either rubber-stamps it or rebuilds the reasoning by hand, which erases the time the agent saved. The trade-off is real—designing the split and the handoff takes thought upfront, while “let the agent do the whole thing” is faster to switch on and far more expensive to unwind later.