The question I get asked most about AI at work is some version of "what can it do now?" It is the wrong question, and I think it is the wrong question in a way that gets companies into real trouble. The capability frontier moves every few months, and chasing it is a way to stay perpetually anxious and perpetually behind. The question that actually matters, the one that will separate the teams that build a durable advantage from the teams that get burned, is narrower and harder: what should an AI be allowed to decide?
I want to be precise, because the distinction I am drawing is easy to blur and expensive to get wrong. You can delegate a task to AI. You cannot delegate accountability for the outcome of that task. Tasks transfer cleanly. Accountability does not transfer at all. When an AI agent drafts a contract clause that exposes you to a lawsuit, the AI is not in the room when the lawyer calls. You are. The accountability stayed exactly where it always was, with a human who is answerable for the result, and any system that pretends otherwise is setting that human up.
Tasks transfer. Accountability does not.
Start with the cleanest version of the idea. A task is a unit of work with a checkable result. Summarize this thread. Draft a first-pass reply. Pull these numbers into a table. Find the three contracts expiring next month. These are wonderful things to hand to an AI, because the output is verifiable and the cost of an error is bounded. If the summary misses a point, you notice and fix it in seconds. The work moved; the responsibility for checking it stayed with you, which is exactly right.
Now contrast that with a decision. A decision is a commitment made under uncertainty, where the cost of being wrong is borne by someone who has to answer for it. Approve this refund. Send this message to the customer. Sign this. Decide which candidate moves forward. These are not tasks even when they look like one button. They are judgments, and judgment is the thing you cannot actually hand off, no matter how confidently the software offers to take it.
The reason this matters is that AI is very good at producing outputs that look like decisions. It will write the refund approval, the customer message, the hiring recommendation, in fluent, confident prose. The fluency is the trap. It makes the output feel decided, when all that has happened is that a probability distribution has been sampled and dressed in the grammar of certainty. Confidence in language is not the same as accountability for consequences, and the gap between them is exactly where teams get hurt.
The line I actually draw
Here is the rule worth running by, and it holds up under real pressure. AI can do anything where a human reviews the result before it has a consequence, and AI must not be the last step before a consequence that a human is accountable for. The whole question of where to draw the line on AI judgment reduces, for me, to one test: is there a consequence on the other side of this action, and who answers for it?
That test sorts the world quickly. Drafting is upstream of consequence, so AI drafts freely. Sending is the consequence, so a human sends. Researching candidates is upstream; the rejection email is the consequence. Proposing a budget reallocation is upstream; committing the spend is the consequence. The pattern is not "AI does small things and humans do big things." Plenty of small actions cross the consequence line, and plenty of large analyses sit safely upstream of it. The pattern is about where the irreversible step is.
Example: take support as the model case. Imagine an AI assistant that drafts replies to every incoming ticket, including refunds and account changes. It reads the history, proposes the action, and writes the message. It might resolve the substance of most tickets correctly on the first try. And it sends nothing. A human reads the proposed reply and clicks send. That one click is not a formality. It is the entire safety architecture. The AI carries the load; the human carries the accountability, and the click is where the second one lives.
Why "human in the loop" is not enough
"Keep a human in the loop" has become the comfortable answer, and I have grown suspicious of it, because a human in the loop who rubber-stamps is worse than no human at all. They add latency and a false sense of safety without adding any actual judgment. If your reviewer approves ninety-nine of a hundred AI outputs without changing anything, you do not have a human in the loop. You have a human pretending to be one, and the first time the AI is confidently wrong, they will approve that too, because approving has become a reflex.
Real human-in-the-loop requires three things that are easy to skip and expensive to skip. The human has to have enough context to actually evaluate the decision, not just the AI's output but the situation behind it. The human has to have the time to evaluate it, which means you cannot pair an AI that produces a thousand decisions an hour with a reviewer who can meaningfully consider ten. And the human has to face a real cost for waving through a bad one, because accountability without consequence is theater. If any of those three is missing, the loop is decorative.
This is why I am wary of designs that maximize throughput of AI decisions and treat review as a thin gate. They are optimizing for the wrong number. The goal is not the most AI actions per hour. The goal is the most output per unit of human judgment, and that means keeping the human's attention on the decisions that actually need it and clearing everything else off their plate. A good system makes the human review fewer things more carefully, not more things more carelessly.
Building systems that protect judgment
If you take accountability seriously, it changes how you build and buy AI tools. You stop asking "can it act autonomously?" as if autonomy were the prize, and you start asking "where does it stop, and is that stopping point in the right place?" The most important feature of an AI agent at work is not what it can do. It is where it is designed to hand control back, and how clearly it tells you what it is about to do before it does it.
We have a few principles we hold ourselves to when we build agents into our own product. Make the consequence step explicit and human, always. Show the reasoning, not just the conclusion, so the reviewer can evaluate the path and not only the answer. Log every action an AI takes so accountability has a paper trail. And make it trivial to set the boundary per situation, because the right line for a two-hundred-dollar refund is not the right line for a fifty-thousand-dollar contract. When we built agents and the assistant into Atlas, the hardest and most valuable design work was not teaching them to act. It was deciding, carefully, where they should stop, and making that boundary visible and adjustable rather than hidden in a config file nobody reads.
There is a tempting shortcut here that I want to warn against. It is very easy to ship an agent that does the whole thing end to end, because the demo is electric and the applause is real. Autonomous demos sell. They are also where the accountability quietly disappears, because in the demo nothing has a consequence and everything works. The discipline is to resist building the thing that demos best and build the thing that fails safest, even though one of those gets the standing ovation and the other gets a shrug. The shrug ages much better.
The cost of getting the line wrong
I have watched the two failure modes, and they are not symmetric. Draw the line too conservatively and you pay in lost speed. Your people spend their judgment on summaries and drafts that the AI could have handled, and you fall behind teams that delegated those tasks freely. This is a real cost, but it is a slow, recoverable one. You notice you are slow and you loosen up.
Draw the line too aggressively and you pay in trust, often all at once. An AI sends a wrong message to your biggest customer, or approves something it should not have, or makes a hiring decision that turns out to be discriminatory, and there is no human who can honestly say "I reviewed that." The damage is not the single bad output. It is that your team and your customers learn they cannot trust the system, and trust, once spent that way, takes years to rebuild. The conservative error costs you speed. The aggressive error costs you the thing speed is supposed to be building toward.
So I would rather err conservative and loosen deliberately than err aggressive and apologize. We have moved our own line outward steadily over two years, expanding what AI does as we earn the right to trust it in each new place, always keeping the consequence step human until the evidence says we can move it. That is not timidity. It is the only way I know to get the gain without the blowup.
The question to keep asking
The teams that trust AI and the teams burned by it are not divided by how advanced their tools are. They are divided by whether they ever asked, clearly and out loud, what the AI is allowed to decide and who answers when it is wrong. That conversation is not a one-time policy. It is a standing question you revisit every time the capability improves, because every improvement tempts you to move the line, and some of those temptations are right and some will hurt you.
Delegate the tasks. Delegate aggressively, more than feels comfortable, because that is where the real gain is. But hold the judgment, keep the human at every consequence, and never let the fluency of a machine's output convince you that the accountability has gone anywhere. It has not. It is still yours. The whole art of AI at work is building systems that make that fact a feature instead of a liability.