Assigning Work: Task Design for AI Agents

The four properties of a good agent task

After deploying hundreds of AI agents across dozens of companies, a pattern emerges. The tasks that succeed have four properties. The tasks that fail are missing at least one.

1. Clear inputs

The agent knows exactly what data it's working with. A URL list. A CSV file. A PR number. A vendor portal login. If the agent has to guess what to work on, it will guess wrong. "Analyze our competitor landscape" is a bad task description. "Visit these 30 URLs, extract pricing and features, save as JSON" is a good one.

2. Verifiable outputs

You can tell whether the agent succeeded by looking at the output. The test suite passed or failed. The report has 30 company entries or it doesn't. The invoice amounts match the PO or they don't. If success requires subjective judgment ("is this report good enough?"), the task needs a human checkpoint, not full autonomy.

3. Bounded scope

The task has a clear end. "Process these 20 invoices" ends when the 20th invoice is done. "Improve the codebase" never ends. Unbounded tasks cause agents to loop, pursue tangents, or optimize for the wrong thing. Every agent task should have a definition of done that both you and the agent agree on.

4. Safe to fail

If the agent gets it wrong, the damage is containable. A bad code review comment is ignored. A missed invoice is caught in the manual reconciliation. A wrong data extraction is flagged by the downstream validation. If a single agent failure causes a production outage, a financial loss, or a compliance violation, the task needs a human approval gate before the agent's output is acted on.

The automation spectrum: five levels

Not every task is fully autonomous or fully manual. There's a spectrum, and placing each task at the right level is the key management skill for AI employees.

Most tasks start at Level 3 or 4 (human reviews everything) and graduate to Level 1 or 2 as trust builds. The competitive intel agent started with daily human review (Level 3). After two weeks of perfect output, it moved to Level 2 (alerts on changes only). After a month, it's Level 1 (fully autonomous, human reads the weekly summary).

The three work assignment patterns

A good AI employee combines all three, just like a good human employee.

1. Prompt-driven (ad-hoc)

A human types a task description. "Research these 10 companies." "Process this spreadsheet." "Review this PR." This is the simplest pattern and the one most people start with. The limitation: it only runs when someone remembers to type the prompt.

Best for: one-off analysis, exploratory work, tasks that change every time.

2. Event-driven (reactive)

A webhook, queue message, or API call triggers the task automatically. PR opened → review agent runs. Deploy completes → QA agent runs. Payment fails → investigation agent runs. The human never types a prompt. The agent reacts to the world.

Best for: tasks that should run every time an event occurs. Guide #12 covers this in depth.

3. Calendar-driven (scheduled)

A cron schedule or calendar trigger runs the task on a rhythm. Every morning at 6am. Every Monday at 7am. Every 28th of the month. The agent has recurring responsibilities, like a human employee with a calendar.

Best for: recurring tasks with fixed schedules. Competitive intel, AP runs, monthly reports, weekly summaries.

The best AI employees combine all three: they have a calendar of recurring work, react to events as they arrive, and accept ad-hoc assignments from their human manager.

Writing good task descriptions

The task description is the agent's job description. A vague description produces vague work. A precise description produces precise work.

The template

1. Context: what you're working with and why. "You have a CSV of 10,000 customer reviews from Q1."
2. Task: what to do, step by step. "Clean duplicates, run sentiment analysis, find the 20 most negative reviews."
3. Output: what to deliver, in what format, where. "Save enriched CSV to /workspace/output/reviews_enriched.csv, save the 20 worst as negative_reviews.json, create a sentiment distribution chart as sentiment_chart.png."
4. Constraints: what NOT to do. "Don't modify the original CSV. Don't call any external APIs. Don't send data outside the sandbox."
5. Success criteria: how to know you're done. "The enriched CSV has a sentiment column for every row. The chart shows positive/negative/neutral distribution."

What to assign: department by department

Five assignment anti-patterns

1. "Improve things"

Open-ended improvement goals don't work. "Improve the codebase" becomes an infinite refactoring loop. "Improve the report" never converges. Be specific: "Fix the 3 failing tests." "Add a chart showing monthly trend." "Reduce the report from 20 pages to 5."

2. "Use your judgment"

In 2026, AI judgment is good for pattern matching and bad for novel situations. Don't assign tasks where the agent needs to make a judgment call you'd want to make yourself. "Decide whether to approve this $50K purchase order" is a human task. "Check whether this PO matches the invoice within 2% tolerance" is an agent task.

3. "Do what I would do"

The agent doesn't know your preferences, your relationships, or your context unless you tell it. "Handle this the way I would" is meaningless. "Follow this procedure document" is actionable. Write the procedure once, assign it forever.

4. "Just keep going until it's perfect"

Agents will loop indefinitely if there's no stopping criterion. "Keep refactoring until the code is clean" never terminates. "Refactor the authentication module. Stop when all tests pass and you've committed no more than 10 changes" has a clear end.

5. Assigning tasks that require real-time human interaction

If the task requires back-and-forth conversation with a person mid-execution ("ask the customer what they prefer"), the agent will either guess (bad) or block waiting for a response (wasteful). Split the task: the agent prepares options, the human decides, the agent executes the decision.

Iterating on task descriptions

Task descriptions are code. They need iteration, testing, and version control.

1. Start with a draft. Write the task description based on how you'd explain it to a new hire.
2. Run it once and review. Did the agent produce the right output? Where did it go wrong?
3. Refine the description. Add specificity where the agent went off track. Remove ambiguity. Add constraints.
4. Run 5 more times. Is the output consistent? Are there edge cases?
5. Commit to version control. The task description is now a production artifact. Changes go through review.
6. Graduate to automation. Wire the task to an event trigger or cron schedule.

A task description that took 3 iterations to get right on Day 1 will run perfectly for months. The investment is front-loaded; the return is ongoing.

What's next