The Case for One Developer and Nine Agents

The backlog keeps growing, and the developers you already have are busy. Hiring looks like the obvious answer. It also means taking on a recurring cost before you know how much of that backlog needs another person's judgment and how much could be delegated with a clear brief.

For a small software team, that distinction is worth money. A good developer can take responsibility for the work while agents handle several independent tasks. Before hiring a large team to work through the queue, it is worth testing how far one experienced person can get with more execution capacity.

We use Task Machine for coding tasks within a larger workspace that also handles marketing, sales, and other company work. Over a fixed 30-day period, the workspace recorded $8,757.76 in model usage across roughly 1,513 hours of agent runs. That works out to $5.79 per run-hour, including unsuccessful attempts.

At that price, the question is how much useful work the agents can deliver and how much of the developer's day it takes to get it accepted.

An execution hour for less than six dollars

For a concrete human comparison, the US Bureau of Labor Statistics reports a 2025 median software-developer wage of $65.38 per hour. That is wages alone, before employer benefits and other overhead. Rates vary by country and experience, but this gives us a published reference instead of an invented salary.

Hourly cost	Amount	What it covers
Our coding agents	$5.79	Recorded model usage per hour of agent runs
US software developer, median wage	$65.38	Employee wages, before employer overhead

The gap is substantial. At this wage benchmark, $5.79 would buy a little over five minutes of a developer's time.

An agent hour and a developer hour do not promise the same result. The developer brings judgment, responsibility, and knowledge of the business. The agent can still need several attempts, and some work is faster to do yourself. Our figure includes unsuccessful attempts, but it does not include human supervision, platform access, or execution infrastructure.

Those additional costs belong in the comparison. Even so, an execution cost this far below the wage benchmark gives a team room to try delegated work without making another full-time hire first.

Pay for the review, too

Our experience with routine, well-scoped work is five to ten minutes of human attention for about an hour of agent execution. That attention includes explaining the task, answering questions, and reviewing the result.

At the developer wage above, five minutes costs $5.45 and ten minutes costs $10.90. Add the agent's $5.79, and the combined allowance is $11.24 to $16.69 per agent-hour, before the other costs described above.

Human attention per agent-hour	Cost of that attention	Agent usage plus human attention
5 minutes	$5.45	$11.24
10 minutes	$10.90	$16.69
20 minutes	$21.79	$27.58

Five to ten minutes is guidance from experience, not a measured average from these records. Longer tasks need more attention. Coding changes that require detailed manual review can take substantially more, which is why the table also shows a twenty-minute allowance.

You might be comfortable quickly checking a small, well-tested change. A permissions change or a difficult integration deserves a different review budget. Choose the task before choosing the ratio of people to agents.

Model selection is a major part of the cost. For coding, we have had good results using GPT-5.6 Luna at maximum reasoning for execution, with GPT-5.6 Sol for planning and review. Luna is the basis for our rough $5-per-hour execution estimate. The $5.79 above is the recorded monthly workspace average, rather than a fixed price for that model combination.

Using the more expensive frontier models for more of the execution costs more. We prefer to spend that extra model budget where planning or review benefits from it, while letting Luna do the implementation. A cheaper model only helps if the work it produces is worth the time you spend checking and correcting it.

What happens when that developer has nine agents?

Suppose nine agents each work for an hour. At our observed rate, their model usage would cost $52.11. Pay one developer $65.38 for the whole hour, and the combined amount is $117.49. Ten developers at the same wage benchmark would cost $653.80 in wages for that hour.

That makes one developer with agents an attractive experiment. It does not make the two teams interchangeable. Ten people offer far more human judgment and can own different parts of the business. The smaller setup depends on work that one person can competently direct and review.

The attention budget sets a practical limit. Nine agent-hours need 45 minutes of human attention at the five-minute allowance, or 90 minutes at the ten-minute allowance.

At the low end, one person can fit the supervision into an hour, with fifteen minutes left. At the high end, the review queue grows faster than that person can clear it. A difficult task or several questions arriving together makes the problem worse.

Start with two or three agents rather than nine. Increase the number as you learn which work needs little intervention. Some agents can wait while the developer handles a demanding review. Having nine available does not mean keeping all nine busy every minute, and actual concurrency still depends on available execution capacity.

The $117.49 example already pays for the developer's whole hour. Their supervision is included there, so do not add the review allowance a second time.

Give the developer work they can review efficiently

A developer managing several agents should spend their attention on the change, rather than finding the instructions or reconstructing what happened.

Before execution, agree on the outcome and the checks that make it ready for review. Include what must remain unchanged. Name any action that requires permission, such as publishing, spending money, or changing production data.

In Task Machine, you can discuss the work and create the tasks in Chat. The task's Work Spec records the agreed direction. Questions, clarifications, review comments, corrections, and retries stay with that task, so the next attempt follows the current decision.

When the agent needs an answer or approval, the Inbox puts the request and its context together with the response actions. You can resolve the decision there. Task detail provides the deeper history when a change needs investigation, along with its Time and Usage cards.

This helps reduce the effort of managing the work. It does not remove the need to understand and inspect it. The developer remains responsible for deciding whether the result is good enough to ship.

Run a month of work before making the hire

Choose a recurring class of coding work your team already understands. Give a developer a small agent budget and room in the week to review the results. Keep track of the cost, the person's time, and what was accepted.

Compare complete tasks. If an agent takes three hours on a change a developer could finish in one, use those actual costs. Include the time spent repairing the result. If repeated corrections consume the saving, improve the instructions, change the model, or keep that work with a person.

You may find that one developer can handle much more delivery with agents. You may find that the next hire should focus on architecture, product decisions, or review. Either result gives you better evidence for a hiring decision than the size of the backlog alone.

At $5.79 per run-hour in our own coding work, the cost of trying is small enough to take seriously. Use the developer task-cost checklist to set up that comparison for your next batch of work.

Sources and assumptions

Our workspace figures cover August 6 through September 4, 2026, in UTC. We divided $8,757.76 in recorded task-related model usage by 1,512.99 run-hours, counting overlapping runs separately and including unsuccessful attempts. Run-hours include time within each run, such as tool execution and waiting, but exclude gaps between runs. They measure execution time, not equivalent human output. Some recorded usage may represent estimated model cost rather than a separate cash charge. Human labor, platform access, and execution infrastructure are additional.

The developer wage comes from the BLS software-developer median hourly wage series, retrieved September 6, 2026. The supervision and nine-agent examples use rounded hourly figures and are planning scenarios. We have not measured equal-output productivity or headcount replacement.