Four questions before an agent gets the task
Should AI do this task? Most of the internet answers with a forecast about the future of work. We answer it one task at a time, with four questions: how often it happens, whether there is a right answer, what happens when it goes wrong, and where the input lives. Answered together, they give one of four verdicts. This note walks through the questions, the verdicts and the field notes the arguments lean on.
We put the helper on our own site. The tool, should-ai-do-this, asks the four questions through a stepper and answers in plain language. It is not a demo of what our models can write. It is the decision about handing over work, made into a form people can answer in an afternoon and argue with in public. Agents here take real work on real systems, and most of what makes that safe is deciding what never reaches them.
The tool has been live at kerber.ai since August and runs the verdicts described below, in English, Swedish and fifteen more languages. One thing to be plain about: this note describes a published decision helper. The stepper is not wired into our task flow; what reaches our agents is decided by people, and a person reviews that work again before it counts as done. Nothing in this note was run as a new experiment: the claims about the tool trace to its published copy and verdict model, and the claims about the studio to our earlier field notes. Where the note argues rather than describes, it states a design position, not a product promise. Read on November 16, 2026.
Why decide before, not during
An agent that gets a task is an agent that can act. It runs while you are at lunch, or at 3am, or on a plane, and it keeps its opinions about how to do the work to itself until after. That is fine when the task was picked well and dangerous when it was picked loosely, which is why the delegation decision cannot live in whoever is paying attention that day.
We learned that the expensive way. Our early fallback chain once had all twelve agents trigger at once, drown the local model and collapse into the cloud fallback. The failure was not a model failing at a job. It was us handing jobs out without a gate, and then designing the system's resilience to protect a bad decision.
The four questions
First question: "How often does this happen?" The tool offers Once, Now and then, Every day. This one decides whether delegation is even worth doing. A task that arrives once has nothing to amortize: you pay the full price of teaching it to anyone, human or machine, for a single run. Automating one of those is pleasure and practice, not efficiency. Daily tasks are where the payoff sits, and the tool weights them that way.
Second question: "Is there a right answer?" With three ways to answer: yes, you can check it; sometimes, it depends; no, it is a judgement call. The third option is the decisive one: in the model, choosing it settles the outcome whatever the other answers said, and the verdict can then only go to the person doing the work with AI clearing the desk, or, if the task is also rare and harmless to drop, to the verdict that questions the task itself. A machine can be held to a checkable answer, exactly the argument we made about work traces and history stored well as evidence. Judgement cannot be delegated this way, however clean the input looks.
Third question: "What happens when it goes wrong?" Again three options: nothing much, somebody redoes it, it costs money or trust. Notice the order: the cheap answers are about time, and the expensive one is about money or trust, the two things a small studio cannot make more of. The question scores nothing by design; it gates the verdict instead. When a wrong run would cost money or trust and the answer is still checkable, the verdict becomes "AI drafts it. A person signs every time", the tool's own wording, backed by a single rule in its model. If the task is a judgement call as well, the earlier rule spoke first and the person keeps the whole job.
Fourth question: "Where does the input live?" Written down, in a system. Scattered across files and threads. In people's heads. Written down is what a machine can read without being told the business context in every session. A task whose input lives in heads has no spec to hand over, only narration, and narration does not survive a handoff unharmed. This is the argument the field note about the spec being the job makes: most of delegation happens when somebody writes the task down, not when the agent picks it up.
The four verdicts
The tool returns one of four verdicts, each with a single rule behind it. If the task repeats, the answer can be checked and the input is written down: "A person sets the direction. AI does the work." Set the rules once and review the output weekly, not hourly. If a wrong run would cost money or trust, the verdict reads: "AI drafts it. A person signs every time." The cost of being wrong lands on the person, so nothing leaves without a signature. The titles are printed on the tool exactly this way, because the wording is the argument.
The other two verdicts handle the awkward cases. When too much of the task is judgement, or the input still sits in heads, the verdict is "A person does the work. AI clears the desk." AI gathers the material, writes the notes and chases the follow-ups, and the person spends their time on the decision.
And for a task that happens rarely, harms nothing when it slips and nobody has written it down, the verdict is "First ask whether it should happen at all." That is a task waiting to be dropped, not one waiting for automation.
The tool is deterministic on purpose. The same four answers always get the same verdict, so the argument can be handed to somebody else. A score you cannot explain back to a colleague is a horoscope, and horoscopes make bad delegation policy.
Where production draws the same line
When Vigil is on call, the same way of thinking arrives in sturdier clothes: a published permission list with three entries. It restarts services, scales capacity and clears queues on its own, and everything else comes back as an alert with the numbers. The note that documents the list gives the reason it stays short: "the cost of being wrong is bounded." The tool's third question asks the same thing, "What happens when it goes wrong?", and the expensive answer changes the verdict. The difference is enforcement. Production binds that line in code. The tool's job is to make the same decision explicit, in public, before anything is handed over.
One thing the four questions will not tell you is what an accepted task ends up costing, which is a separate measurement. That is the subject of our note on measuring the cost of a completed job: once a verdict says yes, count accepted fixes, retries and your own correction time before switching anything, and use the cost tool to run the numbers honestly.
The judgement is the product
The tool carries a sentence we can defend: every vendor will tell you what AI can do, and almost nobody will tell you where it should stop. We have spent a year finding those limits the expensive way, shipping things that worked and things that had to be pulled back. The models are available to everyone. The inventory of what to hand them, and where to keep the person in the loop, is the part that actually carries a studio.
Answer the four questions on a single thing you do this week and you will probably find one verdict you would argue with, or one task sitting in heads that should be written down. Either way the tool has done its work. It is live, takes four answers and asks for nothing in return, and the studio page shows the agents that work behind decisions like these. Look at them from the inside if you want to see what that looks like.
Want more? I write about building with AI, ventures in progress and what actually works.
No spam. Unsubscribe any time.