The most important question about agents is not what can they do?
It is what should people still want to do?
The usual automation conversation begins with capability. We inventory tasks, compare human and machine performance, and push anything technically feasible toward the machine. That can create efficiency. It can also create an organization where people are left supervising work they no longer understand, approving decisions they did not shape, and spending their days handling the edge cases no system wants.
That is not a future of better work. It is a future of residual work.
I think we need a different goal: maximize the work people want to own, minimize the work they merely endure, and keep human accountability visible even when agents execute most of the steps.
Move the toil outward. Keep meaning, judgment, relationships, and accountability close to people.
The diagram is not a taxonomy of fixed tasks. It is a way to negotiate the boundary. The same work can move between regions as people develop expertise, tools improve, risks change, or someone decides that a craft matters to them.
The human circle is more than a list of limitations
People are good at work involving judgment, relationships, taste, care, responsibility, and meaning. We notice when the stated goal is not the real goal. We understand why a technically correct answer can still be wrong for a customer, a team, or a community. We take pride in making something well.
More importantly, people care about different things. One person finds energy in interviewing customers. Another loves debugging a system no one else understands. Someone else wants to teach, negotiate, design, build, or make the final call when the evidence is incomplete.
That passion is not an inefficiency to remove. It is part of the value.
The work people should keep includes:
- Decisions where values and tradeoffs matter
- Relationships that depend on trust and presence
- Creative work where taste is the point, not a defect to standardize
- Craft people want to practice and improve
- Ambiguous situations that require context, empathy, or courage
- Accountability for outcomes that affect other people
An agent may participate in all of these. It can gather evidence before a decision, prepare for a difficult conversation, generate alternatives, or critique a draft. But participation is different from ownership. The person should still be able to say, “I chose this, and I can explain why.”
The agent circle should absorb toil
Agents are strong where work is repetitive, high-volume, easy to verify, or scattered across too many systems for a person to follow efficiently. They can monitor continuously, transform information between formats, draft routine material, reconcile records, execute known procedures, and keep a process moving while people focus elsewhere.
This is where we should be ambitious.
People should not spend their limited attention copying data between systems, reconstructing status from six tools, producing the same report every week, scheduling around a dozen calendars, or searching for context an agent could assemble in seconds. Mundane work is not morally valuable because it is familiar.
The strongest candidates for delegation are tasks that are:
- Repetitive without being developmental
- Time-consuming but straightforward to verify
- High-volume or continuous
- Mostly coordination, formatting, routing, or retrieval
- Unwanted by the people currently doing them
- Reversible when the agent gets them wrong
The goal is not to keep a human “in the loop” as a ceremonial approver. If every agent action produces another notification for someone to clear, we have converted physical toil into attention toil. The system should escalate exceptions that deserve judgment and resolve the rest within explicit boundaries.
The overlaps are where the design work happens
The edges of the circles are more useful than the circles themselves.
Humans plus work is meaningful human work: the places where judgment, craft, relationships, or purpose make the outcome better and make the work worth doing.
Agents plus work is delegable toil: execution that can move faster and more reliably without consuming a person’s day.
Humans plus agents is augmented practice: a designer exploring more directions, a leader seeing patterns across hundreds of conversations, an engineer investigating a system with an agent that never tires of tracing dependencies. The agent expands reach without taking ownership of the result.
At the center is designed collaboration. People define intent, constraints, and what good looks like. Agents execute, monitor, and assemble evidence. The work itself determines where judgment is needed. Handoffs are visible. Authority is bounded. A person remains accountable for the consequences.
This center is not “human does 50 percent, agent does 50 percent.” In some workflows the agent may perform almost every mechanical step. The human contribution can be small in volume and decisive in value.
Do not automate away apprenticeship
There is an important exception to the rule about removing mundane work: some repetition is how people learn.
Junior engineers build intuition by reading imperfect code. Designers develop taste by making many versions. Analysts learn a business by cleaning messy data and noticing what does not fit. A task can be tedious and still be developmental.
If agents take all of that work, we may make today’s experts faster while preventing tomorrow’s experts from forming. The organization gets short-term output and a long-term capability gap.
So the question is not simply, “Does a person enjoy this task?” It is also:
- Does doing this build judgment they will need later?
- Will automation hide the evidence required to understand the system?
- Can the agent teach, explain, and progressively hand over responsibility?
- Are we preserving a path from novice to expert?
Good human-agent design removes empty repetition while preserving useful practice. Sometimes the agent should do the work. Sometimes it should coach. Sometimes it should watch and intervene only when asked.
A practical test for every workflow
Before automating a process, I would ask five questions.
1. Who wants to own this?
Ask the people doing the work. Which parts give them energy, develop mastery, or feel inseparable from the quality of the outcome? Which parts do they dread? A workflow diagram cannot answer that on their behalf.
2. Where does judgment change the result?
Find the moments where context, values, taste, or relationships matter. Put people there early enough to shape the work, not only at the end to approve it.
3. What is toil rather than craft?
Look for copying, chasing, summarizing, monitoring, formatting, routing, and routine execution. Give agents as much of that work as they can safely own.
4. What evidence makes delegation trustworthy?
Define the boundaries, tests, audit trail, escalation conditions, and rollback path. Autonomy should grow with evidence, not enthusiasm.
5. Can a person reclaim the work?
People need the ability to inspect, interrupt, correct, and take back control. A process no one understands well enough to reclaim is not autonomous. It is abandoned.
The measure is better human work
Productivity will matter. Cost will matter. Speed will matter. But they are incomplete measures of whether the human-agent organization is working.
We should also ask:
- Are people spending more time on work they are proud to own?
- Has unwanted coordination and repetition actually declined?
- Do people understand the systems acting on their behalf?
- Are new practitioners still developing judgment and craft?
- Is accountability clearer, or has it dissolved into the machine?
The future I want is not one where agents do everything they can and people inherit whatever remains. It is one where we intentionally divide the work: machines take on the scale and the toil, people keep the meaning and the responsibility, and both meet in systems designed around better outcomes.
The point of agents should not be less humanity at work.
It should be less work that asks people to behave like machines.
I work with companies on AI-native delivery, agent governance, and the operating systems around them.
Start a conversation ↗