GUIDE

How to decide what work should be delegated to AI agents

Working out what is worth handing over once you count what handing over costs

By
David DanielHow to decide what work should be delegated to AI agents
QUICK ANSWER

The question people ask is what an agent can do. Almost anything, is the unhelpful answer, and it leads to building things that technically work and are not worth having.

The better question is what is worth delegating once you count what delegating costs. Every agent carries setup, supervision, and the risk of being wrong in a way you do not immediately see. Work is worth handing over when the value of it running without you clearly exceeds all three.

That sorts the list faster than any capability assessment, and it usually produces a shorter list than people expect.

IN THIS GUIDE

What you are actually trading against

Three costs.

Setup. Real hours, front-loaded. Higher than the demo implies, because the demo did not include working out what it needs to know about your business.

Supervision. The recurring one. Anything producing work you have to verify has a running cost that does not go away, and it is highest exactly when the agent is new and you trust it least.

Undetected error. The distinctive one. An agent can be wrong in a way that produces perfectly reasonable output, which means the cost is not the mistake but the time before you notice.

Against those you are buying persistence. The thing runs whether or not you remembered, which is the entire value.

So the trade is clear: work is worth delegating when it needs doing repeatedly and reliably, and you are currently the only reason it happens.

What makes work good to delegate

It recurs often enough to matter. Setup is fixed, value is per run. Weekly is usually fine. Twice a year is not.

The outcome is checkable. You could look at the result and say whether it went right. This is the one most people skip, and without it you cannot tell a working agent from a broken one.

The steps vary but the goal does not. If the steps never vary you want an automation.

Mistakes are recoverable. You would be irritated rather than exposed.

It currently depends on you remembering. The strongest signal, because that is exactly what persistence buys.

What makes work bad to delegate

You cannot say what good looks like. Anything vague produces output you have to judge case by case, which is the supervision cost at its worst.

The consequence is asymmetric. Being right saves ten minutes, being wrong costs a client. Prepare, do not delegate.

Judgment is the actual work. If deciding is the thing you are paid for, handing it over removes the part that matters.

It is rare. Set up an agent for something that happens twice a year and you will have forgotten how it works by the second time.

The process is undefined. Automating a mess multiplies exceptions. So does delegating one.

The test that sorts things quickly

Could you brief a competent stranger to do this, in writing, without a conversation?

If yes, it is a candidate. You can express the goal, the boundaries, and what good looks like, which are the same things an agent needs.

If no, find out why, because the reason tells you what to do next.

If you could not brief them because the goal is vague, define the goal. The work is not ready.

If you could not because it needs judgment only you have, keep it and let AI prepare instead.

If you could not because it needs context they would not have, that is the useful case. The work is delegable, and only once the context is available. That is a system problem rather than a reason not to.

Prepare before you delegate

A pattern worth applying broadly, because it front-loads the value and delays the risk.

For almost any responsibility, there is a version where the agent does everything up to the irreversible step and stops. Drafts the chase, does not send. Assembles the proposal, does not issue. Prepares the answer, does not reply.

That gets you most of the benefit, since preparation is the expensive part, at a fraction of the exposure. It also gives you something the full version does not: a month of watching its output before anything it produces reaches another human.

Most delegation that goes wrong went straight to full autonomy because approvals felt like friction.

What good looks like when you get this right

The picture is undramatic and worth aiming at.

You have three or four standing responsibilities that genuinely run without you. You see them in a summary rather than by checking. The exceptions come to you with the history attached, so handling one takes two minutes rather than twenty.

And the number of things you are watching has not gone up, which is the part people miss. Good delegation is invisible. If you can feel your agents working, something is wrong.

The measure is not how much they did. It is how much stopped reaching you.

Where people get this wrong

Delegating what is interesting rather than what is heavy. The impressive use case and the valuable one are rarely the same.

Skipping the definition because the agent is capable. Capability does not supply a goal.

Starting with client-facing work. Most visible burden, worst place for a mistake.

Adding rather than replacing. If the old process still runs alongside, you have two.

Never revisiting. Work changes. An agent set up against last year's process is confidently wrong rather than obviously broken.

The order to go in

  1. List what depends on you remembering. That is the candidate pool.
  2. Cross off anything you cannot describe. Come back when you can.
  3. Cross off anything where being wrong is expensive. Prepare instead.
  4. Take the most frequent thing left.
  5. Run it at preparation only for a month.
  6. Widen it once, in one area, if it has earned that.

Why we built EverydayOS this way

Go back to the three costs: setup, supervision, and being wrong without noticing. All three get worse when every agent is its own island. Each one needs telling about your business separately. Each is checked somewhere different. Each can be wrong privately.

EverydayOS is built so agents inherit the context that already exists, escalate through one path, and report into one place. That changes the arithmetic: the cost of delegating the second thing is much lower than the first, because most of what the second one needed was already there.

What that is for is a shorter list of things you are personally responsible for remembering, without a longer list of things you are personally responsible for watching.

Put AI to work around what matters most

Join early access to EverydayOS and help shape an AI operating system that can coordinate the essential things across your work and everyday life, without making you manage another pile of disconnected AI tools.

Join Early Access