Kurt FischmanFounder, Marshal
Kurt is the CEO of Marshal, the Managed Agent Operations company.
The software invoice is the smallest of five numbers. One job run by an AI agent costs usage, plus review time, plus the rework a wrong output creates, plus monthly upkeep, plus setup spread across the months the job stays stable. Add all five, then compare the total against what that job costs you today.
Almost every quote you'll see for an AI agent prices one line: the subscription, or the model usage per task. An agent, in the sense that matters here, is software that carries out a multi-step job inside your systems rather than a chat window that answers questions. The job is the unit worth costing, and the arithmetic for one job has five terms:
- Usage and license: what the vendor and the model provider bill you each month.
- Supervision: review minutes per output, times monthly volume, times your reviewer's loaded hourly rate.
- Rework: error rate, times volume, times the cost of finding and fixing one error.
- Maintenance: hours a month spent adjusting the agent when your business or its connections change.
- Setup, spread: the one-off hours to specify, connect and test the job, divided by the months you expect it to run before a rebuild.
Add those, then set the result beside the loaded cost of the same job done by a person today. Two of the five terms are the ones that quietly decide the outcome, and neither of them appears on an invoice.
Setup is specification, not installation
The setup cost people budget for is technical: connections, credentials, a test run. The setup cost that actually consumes hours is writing the job down. What counts as a duplicate invoice. Which customers get the net-45 terms. What happens when the address on the order doesn't match the address on file. Which of the eight exceptions your bookkeeper handles by instinct need to become a written rule, and which ones stay with her.
That work is expensive because only a few people in your business can do it, and they're the people whose time you were trying to protect. You can't delegate the specification of a job to a vendor who has never run it, and an agent can't infer the rule your team never wrote down. Gartner's July 2024 forecast that at least 30% of generative AI projects would be abandoned before reaching production named poor data quality, inadequate risk controls, escalating costs and unclear business value as the causes (Gartner press release on the business value of generative AI, 29 July 2024). Those are forecast causes rather than an audit of finished projects, and the dollar figures in that release describe enterprise deployments in the $5 million to $20 million range, which isn't your world. What transfers is the shape: the expensive part sits in the messy human definition of the work, not in the model.
Supervision is the term that decides the deal
Somebody has to look at what the agent produced. That person is the real cost of automation, and the number that matters is not the accuracy percentage but the minutes of attention each output needs before you'd let it leave the building.
The uncomfortable finding here comes from software, where the measurement is best. In a randomized controlled experiment run between February and June 2025, 16 experienced open-source developers worked through 246 real tasks in their own large repositories, with AI tools allowed on a random half. Tasks took 19% longer when the tools were allowed, and after the experience the developers still estimated that AI had sped them up by 20% (METR, 10 July 2025). METR is explicit that it studied a narrow setting and doesn't claim most developers are slowed down, and its February 2026 follow-up saw signs of genuine speedup while calling its own new data weak evidence because the developers most enthusiastic about AI increasingly declined to participate (METR, 24 February 2026).
So this isn't evidence that agents make your team slower. It's something narrower and more useful: in the one setting where somebody bothered to run a controlled measurement, the gap between felt speedup and measured speedup was wide, and it pointed the same direction. If your evidence that the agent saves eleven hours a week is that the person using it says so, you don't have evidence yet. You have a mood. Review minutes are countable, and counting them for two weeks costs almost nothing.
The same job, two supervision regimes
One hypothetical job: 200 supplier invoices a month, coded and entered. Done by a person at 4 minutes each and a $40 loaded hourly rate, the manual baseline is about $533 a month. Both agent columns describe the same tool at two points in its life, using invented but internally consistent assumptions. Replace every number with your own.
| Line item | Full review, 8% error rate | Sampled review at 1 in 5, 2% error rate |
|---|---|---|
| Software and model usage | $60 a month | $60 a month |
| Supervision | 200 outputs at 1 minute each, about $133 | 40 outputs at 1 minute each, about $27 |
| Rework | 16 errors at 12 minutes each, about $128 | 4 errors at 12 minutes each, about $32 |
| Maintenance | 2 hours a month, about $80 | 2 hours a month, about $80 |
| Setup spread over 12 months | 30 hours at $40, about $100 a month | 30 hours at $40, about $100 a month |
| Total monthly cost | About $501 | About $299 |
| Saving against the $533 manual baseline | About $32, or 6% | About $234, or 44% |
The software and usage line is identical in both columns. What moves the total is how much attention each output needs and how often a wrong output has to be undone.
Sampled review is what makes the arithmetic move, and you can't start there. Sampling is a claim about error rate, and a claim about error rate needs weeks of your own outputs behind it. So the first stretch of any deployment carries full review by design, which means the honest business case is a curve rather than a monthly number: expensive while you're learning what the agent gets wrong, cheaper once you know, and never cheaper if nobody is measuring.
This also explains a pattern that looks like vendor dishonesty and usually isn't. A demonstration shows you the output. It can't show you the review, because in a demonstration there's nothing at stake in being wrong, and the person watching has no way to price attention they didn't have to pay.
Rework is the error that got out
Error rate is a property of the agent. Rework cost is a property of your business, and it varies by a factor of a hundred across jobs that look similar on an org chart.
A miscoded invoice caught by the person reviewing it costs a few minutes. The same miscoded invoice discovered by your accountant in March costs an afternoon of reconstruction. A scheduling agent that books a job outside your service area costs a truck roll, an apology and a customer who tells three people. A quote sent with the wrong discount is a commitment you may have to honor.
Which gives you a cheap screening question for any job you're considering handing over: if this goes wrong, does it get caught inside the workflow or in front of a customer? Jobs where mistakes surface immediately and cost minutes are where the arithmetic works first. Jobs where mistakes surface late and cost relationships need a person in the loop for longer than any vendor will suggest, and that supervision is part of the price, not a transition phase.
The pattern is worth stating in general terms because the failure mode is systematic: the jobs with the most visible manual drudgery are often the ones with the most expensive errors, which is exactly why they never got automated by ordinary software either.
Maintenance is the world moving under a fixed instruction
An agent follows the job as you specified it, and your business stops matching that specification almost immediately. You change service areas. A supplier changes an invoice layout. Your CRM renames a field. Your terms change and the old ones live on in the agent's rules. A model version is retired and the replacement behaves differently on the edge case that mattered.
None of that announces itself. Consider a booking agent still scheduling work in a postcode you dropped last quarter. Its calendar connection is healthy, so a monitor that only watches for failed connections reports nothing. Finding that error requires somebody to compare the bookings against your changed service area, which is a job nobody has been assigned. That's the difference between a support contract that starts when you report a problem and an arrangement where somebody else is responsible for noticing.
Budget maintenance as a recurring line, not a contingency. Two to four hours a month per job is a reasonable planning assumption to test against your own experience, and if the true number turns out to be zero you'll have the pleasant kind of variance.
What this means for the decision in front of you
The reported industry numbers are grim in a way that's easy to misread. MIT's NANDA report, as covered in August 2025, found that roughly 95% of the organizations in its sample saw no measurable profit-and-loss impact from their generative AI initiatives (reported by Fortune, 18 August 2025, covering MIT Project NANDA's State of AI in Business 2025 report). That figure has been contested, and it measures absence of measurable P&L impact in large organizations rather than technical failure. Read at its actual scope, it says something a founder can use: most of these efforts never got costed as operations, so nobody could tell afterwards whether they paid.
You can avoid that with three questions and a spreadsheet.
First, what's the baseline? Pick one job, count how many times a month it happens, how long it takes, and what the person doing it costs you loaded. Without that number, no agent proposal can be evaluated, only admired.
Second, who owns the run? A build hands you all five terms. Setup, supervision, rework and maintenance become yours the day the invoice is paid, and the price you compared was only the first term. A managed arrangement moves some of that work to the provider, and the question to ask is which parts, in writing, and who notices when the agent is quietly wrong.
Third, what does the price track? Pricing per seat or per task rewards volume of output. What you actually want is verified work, which is why we structure our own commercial terms that way: Marshal designs, deploys and operates AI agents as a service for small businesses, with a 14-day free trial and payment after real verified work. That's our bias, stated plainly, and you should discount it accordingly. The underlying point stands whoever you buy from. If the vendor's revenue is indifferent to whether the output was right, supervision and rework are entirely your problem.
The condition that would change my recommendation is measurement. If you can show a job where review has settled into sampling, error rate is known from your own data, and maintenance is somebody's named responsibility, then the agent case is strong and the invoice really is most of the cost. Until then, assume the invoice is the cheapest thing about the agent, and spend two weeks counting review minutes before you spend anything else.