How to Calculate ROI for an AI Agent

I use a blunt test for AI-agent business cases: show me the work before the agent, the work after it, and the full cost of making the change stick. If those three views do not line up, the ROI percentage is decoration.

An agent can save time and still lose money. It can increase revenue and still be a poor investment if the revenue would have arrived anyway. It can look cheap at the API layer while consuming expensive human review, monitoring, exception handling, and maintenance.

A positive AI-agent ROI forecast is a hypothesis until production evidence confirms the outcome.

What is the formula for AI agent ROI?

Calculate AI agent ROI as:

ROI % = (risk-adjusted annual benefit - total annual cost)
        / total annual cost × 100

That formula is simple. The work is deciding what belongs in each term.

For an agent, annual benefit can include four different types of value:

1. Cash savings: spend that will actually disappear, such as contractor hours, overtime, avoided hiring, or a retired software process.
2. Capacity value: time released for work that matters more, even when payroll does not fall.
3. Gross-profit revenue impact: incremental gross profit that the agent helps create, not unqualified revenue attributed to a system somewhere in the funnel.
4. Loss avoided: expected rework, refunds, failed transactions, service credits, incidents, or other losses that the agent measurably reduces.

Total annual cost includes one-time and recurring costs. Build, integration, data preparation, model calls, tool calls, hosting, monitoring, evaluation, human review, maintenance, security, compliance, training, and change management all belong in the ledger when they are material.

The phrase “risk-adjusted” does not mean applying a mysterious discount because the number feels optimistic. It means using a conservative scenario, an expected value based on an explicit probability, or a confidence range that makes uncertainty visible. If you cannot explain the adjustment in one sentence, do not hide it inside the formula.

AI agent ROI is only as credible as the counterfactual, the full cost ledger, and the evidence that connects the agent to the outcome.

The formula answers one question: how much return did the investment produce relative to its cost? It does not answer whether the agent is safe, whether it should have been built, or whether the team can operate it. Those are separate decisions. The site's guides on when to use an AI agent and how to evaluate an AI agent cover those neighboring jobs.

Should you calculate ROI, payback, or NPV?

Use all three when the investment is meaningful. They answer different questions.

Measure	Formula or question	Best use	Main limitation
ROI	(benefit - cost) / cost	Compare return across initiatives with similar scope	Can hide timing and cash-flow shape
Payback period	one-time cost / monthly net benefit when monthly net benefit is positive	Ask how quickly the initial investment is recovered	Ignores benefits after payback and time value of money
NPV	Discounted future benefits minus discounted future costs	Compare multi-year investments and timing	Requires an agreed discount rate and forecast discipline
Cost per successful outcome	total cost / verified successful outcomes	Compare agent versions, models, or alternatives	Not a complete investment return measure
Cost-effectiveness	Lowest lifecycle cost for a defined outcome	Compare alternatives when benefits are hard to monetize	Does not prove the outcome is valuable enough

ROI is useful for a compact business case. Payback is useful when cash constraints or executive patience dominate. NPV is useful when a system has a long life, material upfront cost, or benefits that arrive unevenly.

The Office of Management and Budget's Circular A-94 is written for federal programs, not private AI projects, but several habits transfer cleanly. It defines net present value as the discounted monetized value of expected net benefits, calls for explicit assumptions, recommends evaluating alternatives, and says realized benefits and costs should be verified retrospectively. (OMB Circular A-94)

Do not use ROI as a magic pass mark. A 200% ROI on a tiny, low-priority workflow may matter less than a 20% ROI on a critical process with a large base. Rank decisions by value, risk, strategic fit, and capacity to execute. The percentage is one view of the investment, not the investment's entire meaning.

What should you measure before building the agent?

Measure the current workflow before the agent changes it. This is the most important and most skipped step.

Write down the counterfactual: what will happen if the agent is not built? The answer might be “the team keeps doing the work manually,” “we hire one more contractor,” “we buy a deterministic tool,” “we improve the existing process,” or “we accept the current level of delay and error.” ROI is incremental. If the benefit would have happened under the counterfactual, it does not belong to the agent's claim.

Capture a baseline for a complete operating period. For a support workflow, that might be four weeks. For a quarterly finance process, it may be several cycles. The baseline should include enough variation to show normal demand, peak demand, missing data, and common exceptions.

Baseline field	What to record	Why it matters
Work volume	Tasks, cases, transactions, or requests per period	Sets the ceiling for reachable value
Eligibility	Share of work the agent could actually handle	Prevents applying savings to the whole department
Human effort	Median and high-percentile time per unit	Avoids building a case on an average that hides difficult work
Quality	Error, rework, escalation, abandonment, or correction rate	Prevents time savings from hiding quality loss
Outcome	What counts as complete and how it is verified	Separates a plausible answer from a finished task
Cost	Loaded labor, contractor, software, infrastructure, and delay cost	Defines the comparison point
Revenue link	Conversion, retention, margin, or throughput relationship	Prevents unsupported revenue attribution
Risk	Failure modes, affected parties, and loss magnitude	Makes safety and compliance costs visible
Adoption	Who uses the current process and how often	Establishes the behavior the agent must change

Microsoft's use-case blueprints make this baseline discipline concrete. Their examples name contact volume, handle-time distribution, fully loaded representative cost per hour, and baseline customer satisfaction before go-live. Microsoft also says organizations should replace the example inputs with their own numbers. (Microsoft agent value blueprints)

If you have no baseline, you can still run a discovery estimate. Call it a forecast. Do not call it measured ROI.

What is the TRACE framework for calculating AI agent ROI?

I use TRACE as a compact worksheet for keeping an AI-agent ROI case honest. TRACE is my synthesis of the primary guidance in this article. It is not an industry standard, benchmark, or certification.

Letter	Question	Evidence to collect
T: Task baseline	What does the work cost now, and what happens without the agent?	Volume, effort, quality, outcome, cost, alternatives, and counterfactual
R: Realized outcome	What changed in the business, not just in the agent trace?	Completed task, saved spend, redirected capacity, margin, or avoided loss
A: All-in cost	What resources are consumed across the agent's life?	Build, model, tools, infrastructure, review, evaluation, maintenance, risk, and change
C: Confidence and causality	How much of the result belongs to the agent, and how uncertain is it?	Control comparison, attribution rule, adoption, realization, ranges, and failure data
E: Evaluate over time	Does the case remain positive after launch?	Monthly benefit, cost per success, quality, adoption, payback, and decision threshold

The point is sequence. A team that starts with the percentage tends to find benefits that fit the denominator. A team that starts with the task and counterfactual has a chance to discover that the agent is the wrong solution, the benefit is too small, or the measurement path is missing.

How do you apply TRACE in one working session?

Use this order:

1. Name one workflow and one desired outcome.
2. Write the no-agent counterfactual.
3. Record the current baseline from observed work, not memory.
4. Define the smallest agent scope and the people or systems it can affect.
5. List benefit drivers and label each as cash, capacity, revenue, or loss avoided.
6. Add adoption, eligibility, and realization assumptions.
7. Build the all-in cost ledger for year one and later years.
8. Apply an explicit attribution and uncertainty rule.
9. Calculate ROI, payback, and a conservative scenario.
10. Define the telemetry and review date that will replace the forecast with evidence.

The output is not only a number. It is a decision record that another person can audit.

How do you calculate the value of time saved?

Start with measured time per eligible task, not a broad claim such as “the agent saves the team hours.” Then separate three quantities:

Gross hours freed
= eligible units × (baseline human minutes - post-agent human minutes) / 60

Reachable hours
= gross hours freed × adoption rate × eligible coverage

Realized capacity value
= reachable hours × utilization factor × loaded hourly value

The utilization factor matters when people will remain employed after the agent launches. If an agent frees 100 hours, the business does not automatically receive 100 hours of cash savings. Some of the time may be lost to context switching, some may go to useful work, and some may disappear into slack. You need evidence about what happens next.

Use hard labor savings only when spend will actually fall. Examples include fewer contractor hours purchased, an avoided hire approved in the plan, reduced overtime, or a retired process with a real subscription cost. Use capacity value when people will do more valuable work at the same headcount. Keep both lines in the model.

For a loaded hourly value, use your own finance-approved rate if you have one. As a reference point only, the U.S. Bureau of Labor Statistics reported March 2026 private-industry employer compensation costs of $46.60 per hour, made up of $32.60 in wages and $14.01 in benefits. That is a population benchmark, not the correct rate for your organization. (BLS employer compensation costs)

Do not count an entire task as saved if a person still has to inspect, correct, approve, and re-enter the result. Measure the remaining human path. A fast draft can be valuable, but it is not zero human effort.

What if the agent makes the task faster but not cheaper?

Count the result as capacity value and define the destination of the released time. Good destinations are measurable: more customer cases resolved, more sales conversations held, shorter response times, more experiments shipped, or an avoided hiring plan. If you cannot name the destination, report the time reduction as an operational metric, not as a financial benefit.

That distinction protects the business case from a common mistake: multiplying every minute saved by salary and treating the product as cash. Time is an input. Value is what the organization does with the time.

Time saved becomes financial value only when the organization can show what happened to the released capacity.

How do you calculate revenue impact without overstating it?

Use gross profit and incremental attribution, not total revenue touched by the agent.

The basic structure is:

Gross-profit revenue benefit
= incremental revenue × gross margin × attribution share

Then ask whether the revenue was actually incremental. An agent that drafts sales follow-ups may be associated with closed deals, but the deal could also reflect price, seasonality, the salesperson, a campaign, or a customer need that already existed. The model should not award the agent the full contract value by default.

Choose an attribution method that fits the workflow:

Situation	Safer attribution method
Agent handles a randomized or holdout group	Compare treatment and control outcomes
Agent changes response time for otherwise similar cases	Compare matched cohorts before and after the change
Agent is one step in a long sales funnel	Use a documented fractional share or incremental conversion lift
Agent creates more qualified opportunities	Attribute only the margin from opportunities that pass a defined quality threshold
Agent affects retention	Compare churn or renewal for comparable cohorts and account for other interventions
No credible comparison exists	Report revenue as influenced, not proven, and keep it out of the conservative case

Revenue should usually be expressed as gross profit because the cost of delivering the extra revenue still matters. If you use revenue in a headline ROI model, state the margin and the attribution rule beside it.

Do not use an industry-wide “AI increases conversion by X%” assumption unless you have a source and a reason it applies to your workflow. A sourced benchmark can inform a range. It cannot replace your baseline.

How do you value errors avoided and risk reduced?

Estimate expected loss before and after the agent:

Expected loss
= event frequency × probability of harmful outcome × cost per outcome

Avoided-loss benefit
= baseline expected loss - post-agent expected loss

The cost per outcome may include rework, refunds, service credits, missed revenue, incident response, legal review, regulatory exposure, customer churn, or damage to a relationship. Some impacts are not responsibly monetized. Keep them visible as non-financial risk even when they do not enter ROI.

NIST's AI Risk Management Framework says expected benefits and costs should be compared with appropriate benchmarks. It specifically calls for documenting potential costs, including non-monetary costs that result from errors or system functionality and trustworthiness. It also expects measurement to continue in production and for negative residual risk to remain within the organization's tolerance. (NIST AI RMF Core)

This creates an important rule: risk reduction is not a free bonus. If the agent needs a second model for review, approval gates, red-team testing, audit logging, or a human exception queue, those controls belong in the cost ledger. If the controls are missing, the agent may appear more profitable because the business case has ignored the condition that makes deployment acceptable.

Use three labels for risk-related value:

• Measured reduction: the incident or error rate changed in a controlled comparison.
• Expected reduction: the mechanism and baseline support a probability estimate, but evidence is still limited.
• Unpriced protection: the control matters, but a dollar value would be false precision.

The first can enter a base case. The second belongs in an explicit scenario. The third belongs in the decision record and risk register, even if the ROI spreadsheet leaves it unpriced.

What belongs in the total cost of ownership?

Model the agent as a service with a lifecycle, not as a prompt with an API bill.

What are the one-time costs?

One-time costs commonly include:

• workflow discovery and design;
• data cleaning, labeling, and migration;
• prompt, tool, and policy design;
• application and integration work;
• evaluation-set creation;
• security, privacy, and compliance review;
• launch preparation and change management;
• training and internal documentation; and
• the opportunity cost of people who build the system instead of other work.

If a team member spends three months on the agent, that time is an investment even if payroll does not change. Use the person's loaded cost or a finance-approved project rate. Do not make internal labor invisible because no invoice arrived.

What are the recurring costs?

Recurring costs include:

• model input, output, cached, and reasoning tokens;
• tool and data-provider calls;
• hosting, storage, queues, and network traffic;
• tracing, logging, evaluation, and monitoring;
• human review, approvals, escalations, and corrections;
• support, incident response, and maintenance;
• model, prompt, tool-schema, and integration changes;
• security controls, access reviews, and compliance work;
• retraining or re-indexing where applicable; and
• the cost of failed runs, retries, and abandoned work.

OpenAI explains that API use is priced by token and can vary by model and by input, output, and cached tokens. It also says that cost per successful outcome is more useful than advertised token price alone, and that teams should test on their own use cases. (OpenAI token guide, OpenAI API)

Google Cloud's agent architecture guidance similarly recommends measuring QPS and TPS, testing models iteratively, monitoring after deployment, and treating prompt length and generated output as cost and performance inputs. It documents additional cost and complexity when a system adds coordinators, critics, revision loops, or multiple agents. (Google Cloud agent architecture)

A token bill is one line in an AI agent's total cost of ownership, not the total cost.

Anthropic makes the operational reason clear: agents operate in loops, rely on environmental feedback, and need stopping conditions; their autonomy can bring higher costs and compounding errors. (Anthropic, Building effective agents)

How should you price model and tool costs?

Estimate cost per run from observed traces, not from a model's public price alone.

Model cost per run
= input tokens × input price
  + output tokens × output price
  + cached or reasoning token cost where applicable

Agent cost per run
= model cost
  + tool calls
  + retrieval or data calls
  + infrastructure allocation
  + human review time
  + expected retry and failure cost

Then multiply by actual or forecast run volume. If your agent sometimes calls a search service, database, browser, code executor, or external API, include those calls. If a failed run triggers a human correction, include the expected cost of that path.

Use a trace sample to estimate:

Trace field	Minimum useful measurement
Volume	Runs per day or month, split by workflow type
Model usage	Input, output, cached, and reasoning tokens if exposed
Tool use	Calls, provider charges, and failure rate by tool
Compute	Runtime, memory, queue, storage, and network allocation
Human path	Review minutes, approval rate, rework minutes, escalation rate
Reliability	Retry count, abandoned run, and duplicate work rate
Outcome	Successful completion, partial completion, and failed completion
Unit economics	Cost per run and cost per verified successful outcome

Model pricing pages are high-freshness sources. The current OpenAI API page changes over time, and the token guide notes that different models can tokenize the same text differently. That means a static article should teach the method and link to the current provider rate rather than pretend today's price is permanent.

The most useful unit is often not cost per run. It is cost per successful outcome:

Cost per successful outcome
= total operating cost / verified successful outcomes

An agent with a low cost per attempt but a high failure and review rate may be more expensive than a slower system that completes the work correctly on the first pass.

How do you account for adoption and utilization?

Separate technical capability from business reach.

An agent may handle 80% of a test set but only be used by 30% of eligible people. It may be available for 100% of requests but appropriate for only half. It may save ten minutes when used but return only four minutes of economic value because the rest is lost to review and handoff.

Use this bridge:

Realized benefit
= theoretical benefit
  × eligible coverage
  × adoption
  × completion or success rate
  × realization factor
  × attribution share

The factors are not interchangeable:

• Eligible coverage: what share of the workflow is in scope?
• Adoption: what share of eligible people or events actually use the agent?
• Completion or success rate: how often does the agent produce an accepted result?
• Realization factor: how much of the nominal time or cost benefit becomes real value?
• Attribution share: how much of the outcome can you reasonably connect to the agent?

Do not multiply weak estimates until the result looks precise. If adoption and attribution are unknown, show a range. If the realization factor is disputed, put it in the sensitivity table. A range is more useful than an executive number with hidden assumptions.

Microsoft's metrics reference separates engagement and adoption from outcomes, quality, productivity, and business outcomes. That separation is useful beyond Copilot Studio because it prevents a team from using activity as a substitute for value. (Microsoft agent metrics reference)

An agent's theoretical value is not its realized value until eligible work, adoption, success, and utilization all connect.

What is a worked AI agent ROI example?

The following example is illustrative arithmetic. It is not a Marius Manolachi client result, benchmark, or test.

Imagine a support-triage agent that classifies incoming tickets, retrieves relevant policy, drafts a routing recommendation, and sends uncertain cases to a person. The business wants to know whether the agent is worth building.

What are the assumptions?

Input	Illustrative value	Treatment
Monthly tickets	4,000	Observed baseline for the hypothetical case
Share eligible for the agent	70%	2,800 tickets per month
Baseline human triage time	12 minutes per eligible ticket	Includes reading, lookup, and routing
Human time after the agent	4 minutes per eligible ticket	Review and correction remain required
Adoption	80% of eligible tickets	The rest follows the current process
Successful accepted routing	92% of agent-assisted tickets	The remaining cases escalate or require rework
Realization factor	60%	Only part of freed capacity becomes useful value
Loaded hourly value	$46.60	BLS March 2026 private-industry reference, not a company rate
Avoided rework	40 cases per month at $80 each	Illustrative quality benefit
Build cost	$24,000	One-time illustrative cost
Recurring cost	$2,200 per month	Model, tools, hosting, evaluation, maintenance, and review overhead

How much time value does it create?

The nominal time difference is eight minutes per eligible ticket.

Gross hours freed
= 2,800 eligible tickets × 8 minutes / 60
= 373.33 hours per month

Apply adoption and accepted routing:

Reachable hours
= 373.33 × 80% × 92%
= 274.93 hours per month

Apply the 60% realization factor:

Realized capacity hours
= 274.93 × 60%
= 164.96 hours per month

Convert to capacity value:

Monthly capacity value
= 164.96 × $46.60
= $7,688.96

This is not a claim that the company saves $7,688.96 in payroll. It is an illustrative capacity value using a reference hourly rate. If the business will actually remove contractor spend, replace capacity value with the documented cash reduction and state the timing.

How much quality value does it create?

Monthly avoided-rework value
= 40 cases × $80
= $3,200

Total illustrative monthly benefit is:

$7,688.96 capacity value + $3,200 avoided rework
= $10,888.96

Annual benefit is:

$10,888.96 × 12 = $130,667.52

What is the year-one cost?

Year-one total cost
= $24,000 build + ($2,200 × 12 recurring)
= $50,400

What is the ROI?

Year-one ROI
= ($130,667.52 - $50,400) / $50,400 × 100
= 159.3% approximately

The monthly net benefit after recurring cost is:

$10,888.96 - $2,200 = $8,688.96

The simple payback estimate is:

$24,000 / $8,688.96 = 2.8 months approximately

That looks attractive, but it is only as strong as the assumptions. Change the realization factor from 60% to 30%, reduce adoption, add more review time, or reduce the avoided-rework estimate, and the result moves quickly.

What would a conservative scenario say?

Use a lower, explicit case rather than applying an invisible haircut. Suppose:

• adoption falls from 80% to 55%;
• accepted routing falls from 92% to 85%;
• realization falls from 60% to 30%; and
• avoided rework falls from 40 cases to 20 cases.

The time-value component becomes:

373.33 gross hours × 55% × 85% × 30% × $46.60
= $2,454.76 per month approximately

Add $1,600 of avoided rework, giving $4,054.76 of monthly benefit. Subtract $2,200 of recurring cost, leaving $1,854.76 of monthly net benefit. The payback period becomes about 12.9 months, and the year-one ROI becomes approximately negative 55.8% because the $24,000 build is not recovered within the first year.

The decision is now more interesting than the headline 159.3%. The agent may still be worth a smaller pilot if the team can validate adoption and realization cheaply. It should not be approved as a full rollout on the optimistic case alone.

How should you run sensitivity analysis?

Vary the assumptions that dominate the result. Do not vary every cell equally. The important cells are usually volume, eligibility, adoption, time saved, success rate, realization, attribution, build cost, human review, and recurring usage cost.

Create at least three scenarios:

Scenario	What it answers	Typical assumptions
Conservative	Can the agent survive weak adoption and expensive operation?	Lower volume, adoption, success, and realization; higher review and run cost
Base	What do the observed baseline and pilot data support?	Measured inputs with stated gaps
Upside	What happens if the workflow reaches its intended scale?	Higher adoption or volume, but no unsupported quality jump

Then test one-way sensitivity. Hold everything else constant and move one variable.

Variable	Low case	Base case	High case	Decision signal
Adoption	40%	65%	85%	Does value depend on behavior change?
Realization	25%	50%	75%	Is released time actually used?
Accepted completion	80%	90%	96%	Does review erase the benefit?
Monthly volume	1,500	3,000	5,000	Is the workflow large enough?
Human review minutes	7	4	2	Does the agent shorten or add the human path?
Recurring cost	$1,500	$2,200	$4,000	Does usage growth hurt unit economics?

Report the break-even point for the most important variable. For example: “At the base cost and review path, the agent needs 2,450 eligible completed tasks per month to reach zero year-one ROI.” That statement is more useful than a single ROI percentage because the team can see what must be true.

OMB Circular A-94 recommends varying major assumptions and recomputing outcomes. It also emphasizes that models should be documented so others can review them. (OMB sensitivity analysis guidance)

How do you measure ROI after launch?

Turn the business case into a monthly scorecard. The launch forecast is a hypothesis. Production data is the update.

Track four layers:

Layer	Measures	Why it matters
Adoption	Eligible volume, active users, run rate, repeat use	Shows whether the agent reaches the work
Outcome	Successful completion, resolution, deflection, escalation, rework	Shows whether the work actually finished
Quality and risk	Error, correction, incident, policy breach, appeal, and customer signal	Prevents efficiency from hiding harm
Economics	Cost per run, cost per success, review minutes, realized benefit, payback, ROI	Shows whether the system earns its keep

Microsoft's metrics reference separates engagement, outcome, quality, process, productive-hour value, and business-outcome metrics. That vocabulary is useful even when you are not using Microsoft tooling. It forces the team to ask whether people are using the agent, whether the agent is solving the task, whether the result is trustworthy, and whether the business moved. (Microsoft metrics reference)

The monthly scorecard should include the same definitions every time. If “success” changes from a verified database update to a model-generated answer, the ROI trend is not comparable.

What should the monthly scorecard contain?

Month:
Workflow and scope:
Eligible units:
Agent-assisted units:
Verified successful outcomes:
Human review minutes:
Rework or escalation rate:
Model and tool cost:
Infrastructure and monitoring cost:
Maintenance and evaluation cost:
Realized hard savings:
Realized capacity value:
Realized gross-profit revenue:
Measured avoided loss:
Total benefit:
Total cost:
Monthly ROI:
Cost per successful outcome:
Main assumption that changed:
Decision: expand, hold, reduce scope, or stop

“ROI cannot be treated as a static calculation that is performed at launch.”

AWS Prescriptive Guidance, Production value guidance

AWS recommends connecting financial measures such as cost per interaction and infrastructure spend with business measures such as hours saved, revenue lift, and CSAT. (AWS Prescriptive Guidance)

Set review triggers before launch. For example:

• stop expansion if safety or policy failures exceed the agreed threshold;
• hold scope if cost per successful outcome rises for two review periods;
• reduce autonomy if review or correction time erases the modeled benefit;
• expand only if adoption, quality, and realized value all meet the gate; and
• retire the agent if the counterfactual becomes cheaper or more reliable.

Do not wait for an annual postmortem to discover that the agent has been losing money for six months.

What is the difference between output metrics and ROI?

Output metrics describe activity. ROI describes economic return.

Examples of output metrics include:

• number of runs;
• number of tool calls;
• number of drafts produced;
• number of documents retrieved;
• number of tokens consumed; and
• average response time.

These metrics matter because they explain how the system behaves. They do not prove that the system created value.

Examples of outcome metrics include:

• verified tasks completed;
• resolution or first-contact resolution;
• revenue-qualified opportunities;
• cycle time reduced without quality loss;
• errors or rework avoided; and
• approved decisions made faster.

These metrics are closer to value, but they still do not automatically equal money. A shorter cycle time may matter because it enables more throughput, avoids a service-level penalty, or improves retention. If none of those changes, the faster process may be operationally nicer without having a measurable ROI.

Use a chain:

Activity → outcome → business effect → financial value

For example:

Agent runs → accepted ticket routing → shorter queue → fewer overtime hours

Instrument each link. If you can only observe the first two, keep the financial claim out of the base case and say what measurement is missing.

This is also why a high “automation rate” can be misleading. The agent may classify work but leave the final action to a person. That can still be useful. It is just not the same as end-to-end automation.

When does an AI agent have negative ROI?

An agent has negative ROI when the measurable benefit is smaller than the full cost over the period being evaluated. That can happen even when the model is capable and users like it.

Common causes include:

1. The workflow is too small. There are not enough eligible units to recover build and maintenance cost.
2. The work needs too much judgment. Every output still requires a senior person to inspect it, so the human path does not shrink.
3. Adoption is low. The agent is available but does not enter the workflow where value was expected.
4. The counterfactual is cheaper. A small deterministic change, template, or process fix produces the same benefit.
5. The cost per successful outcome is high. Retries, tool failures, review, and correction consume more than the API estimate suggests.
6. The benefit is not realized. People save time, but the organization does not redirect it or avoid spend.
7. The agent creates new risk. Errors, privacy issues, or policy breaches add expected cost.
8. The scope is too ambitious. A multi-agent or evaluator loop adds latency and cost without enough quality improvement.
9. The business case is based on total revenue. The actual incremental gross profit is much smaller.
10. The baseline was weak. The team compared the agent with an inefficient version of the old process or ignored what would have happened anyway.

Negative ROI is a decision result, not a personal failure. It may tell you to narrow the workflow, reduce autonomy, change the model, improve adoption, or stop the project. A clear negative result can save more money than a positive result built on invented assumptions.

If you are still deciding whether agentic behavior is justified, use the AI agent decision framework before committing to a large ROI model.

How should you compare an agent with simpler alternatives?

Compare the agent with the next-best way to achieve the same outcome. That may be a fixed workflow, a conventional automation, a search or retrieval system, a process redesign, a human hire, or doing nothing.

Use the same outcome definition and time horizon for each option.

Alternative	Include in comparison	Question to ask
Existing manual process	Current loaded labor, quality, delay, and risk	What does the organization pay today?
Deterministic automation	Build, integration, maintenance, exception rate	Can rules handle the real variation?
Fixed LLM workflow	Model, review, and workflow costs	Does the path need model judgment, or only language processing?
AI agent	Full lifecycle cost, autonomy, failure, and review	Does flexible path selection create enough value?
Additional employee or contractor	Compensation, hiring, ramp, and management	Is continuity or capacity the real constraint?
Do nothing	Delay, missed opportunity, and known risk	What is the cost of leaving the process unchanged?

The comparison is especially important because an agent is often sold as a solution to a workflow that is poorly defined. Anthropic recommends starting with simple prompts and adding multi-step agentic systems only when simpler solutions fall short. (Anthropic building effective agents)

Google Cloud's guidance makes a related point in architecture terms: a single agent is often a starting point, while multi-agent patterns add cost, evaluation, security, reliability, and communication overhead. (Google Cloud agentic patterns)

If the simplest alternative produces the same verified outcome at lower lifecycle cost, the agent has not earned its complexity.

How do you calculate ROI for different types of agents?

The formula stays the same. The benefit and cost evidence change by workflow.

How do you calculate ROI for an internal productivity agent?

Measure task volume, time per task, adoption, repeat use, review time, and what people do with released capacity. Be cautious with salary multiplication. If no hiring, contractor, or overtime change follows, the result is capacity value. Pair it with a throughput, cycle-time, or quality outcome.

Useful measures include:

• verified work completed per person;
• time to a decision or deliverable;
• correction and rework rate;
• adoption by eligible employees;
• work redirected to a named priority; and
• cost per accepted output.

How do you calculate ROI for a customer-support agent?

Measure eligible contact volume, resolution, escalation, handle time, customer satisfaction, repeat contact, human review, and the cost of unresolved or incorrectly resolved cases. Revenue impact may appear through retention or expansion, but attribute it carefully.

Do not call every deflected conversation a saved labor hour. Some customers would not have contacted support. Some will return after an unhelpful answer. Some issues require a human. Count verified resolution and the resulting cost or capacity change.

How do you calculate ROI for a sales agent?

Measure qualified opportunities, response time, meeting rate, conversion, gross margin, sales-cycle time, rep review, and the share of wins that would likely have happened without the agent. Use holdouts or matched cohorts where possible.

Revenue agents often have attractive forecasts because the revenue number is large. Use contribution margin and an attribution rule. Keep influenced revenue separate from incremental gross profit.

How do you calculate ROI for a back-office or finance agent?

Measure transaction volume, exception rate, processing time, rework, close-cycle time, control failures, reviewer minutes, and the cost of delayed or incorrect records. A finance agent may create value through shorter close, fewer exceptions, or better audit preparation rather than headcount reduction.

For high-consequence work, risk and approval cost are part of the design. A positive spreadsheet result does not override a control requirement.

How do you calculate ROI for a research or knowledge agent?

Measure time to find the right source, citation or grounding quality, answer acceptance, repeat questions, escalations, and the cost of bad information. Retrieval volume is not the same as useful research. The agent should be credited for a verified decision or deliverable, not for producing a long answer.

What should an AI agent ROI worksheet include?

Copy this structure into a spreadsheet or project brief. Use one row per benefit or cost so assumptions stay visible.

Identification

Agent name:
Workflow:
Business owner:
Finance reviewer:
Technical owner:
Decision date:
Evaluation window:
Counterfactual:
Alternative options:

Baseline

Units per period:
Eligible share:
Human minutes per unit:
Quality or error rate:
Outcome definition:
Loaded hourly value:
Current software and infrastructure cost:
Current contractor, overtime, or hiring plan:
Current delay or revenue signal:

Benefits

Benefit name:
Benefit type: cash / capacity / gross-profit revenue / loss avoided
Formula:
Baseline value:
Post-agent value:
Adoption:
Success or acceptance rate:
Realization factor:
Attribution share:
Evidence source:
Confidence: measured / expected / speculative
Monthly value:
Annual value:

Costs

Discovery and design:
Data preparation:
Integration and implementation:
Evaluation and testing:
Security, privacy, and compliance:
Training and change management:
Model usage:
Tool and data usage:
Hosting and storage:
Monitoring and tracing:
Human review and escalation:
Maintenance and support:
Incident and recovery allowance:
Opportunity cost:
Year-one total:
Later-year recurring total:

Decision

Conservative ROI:
Base ROI:
Upside ROI:
Payback:
NPV, if required:
Break-even volume:
Cost per successful outcome:
Non-financial benefits:
Unpriced risks:
Launch gate:
Post-launch review date:
Decision: build / pilot / hold / reduce scope / stop

The worksheet should be readable by someone who did not build the agent. If a formula requires a private conversation to understand, write the definition into the sheet.

What mistakes make AI agent ROI look better than it is?

Counting time saved as payroll savings

This is the most common error. A time reduction is not a cash reduction unless spend changes. Name the capacity destination or keep the benefit separate.

Counting all revenue touched by the agent

Use incremental gross profit and a defensible attribution share. If there is no comparison, label the revenue as influenced and exclude it from the conservative case.

Excluding internal labor

People designing, reviewing, monitoring, and repairing the system are part of the investment. Their time may not show as a vendor invoice, but it is still scarce.

Treating the API bill as total cost

Model, tool, hosting, review, evaluation, maintenance, security, and incidents can dominate the token line. Estimate cost per successful outcome.

Using a benchmark as the business case

A vendor example or public benchmark can help you choose a test. It cannot prove that your workflow will achieve the same result. Replace example inputs with your baseline.

Ignoring the counterfactual

If the team would have improved the process, hired a person, or bought another tool anyway, the agent does not deserve all of the resulting gain.

Hiding uncertainty inside one number

Show conservative, base, and upside cases. Identify the assumption that flips the decision. A range is not indecision. It is an honest representation of what the team knows.

Optimizing cost before measuring outcome quality

The cheapest model can be the most expensive choice if it creates more review, rework, or failed actions. Compare cost per successful outcome, not price per token in isolation.

Treating an agent as permanent once it launches

Usage, prices, models, policies, workflows, and user behavior change. AWS's production guidance treats ROI as a dynamic KPI. Recalculate it when the operating conditions change.

Using ROI to bypass safety decisions

An attractive percentage cannot justify a system with unacceptable residual risk. NIST's framework keeps benefits, costs, trustworthiness, human oversight, and ongoing measurement connected. A safety veto remains a veto.

What is the final go or no-go checklist?

Use this checklist before approving a build or expansion.

Evidence

• Is the workflow named precisely?
• Is the no-agent counterfactual written down?
• Is the baseline based on observed work rather than a memory-based estimate?
• Are outcome and quality definitions testable?
• Are the main assumptions and data owners named?

Benefits

• Are benefits separated into cash, capacity, gross-profit revenue, and loss avoided?
• Is adoption or eligible coverage included?
• Is released capacity tied to a real destination?
• Is revenue incremental and margin-based?
• Are risk benefits measured or clearly labeled as expected or unpriced?

Costs

• Are build and internal project time included?
• Are model, tool, hosting, and storage costs based on realistic traces or ranges?
• Are review, escalation, correction, evaluation, maintenance, and support included?
• Are security, privacy, compliance, and incident costs considered?
• Is the cost per successful outcome known or scheduled for measurement?

Decision

• Are conservative, base, and upside scenarios visible?
• Is the break-even volume or assumption known?
• Is payback calculated when useful?
• Is NPV required by finance for this investment?
• Is there a defined stop, hold, or scope-reduction gate?
• Is a post-launch review date scheduled?

If several answers are no, the right next step is usually a smaller measurement pilot, not a larger agent.

How should Marius Manolachi help with an AI-agent ROI case?

A good ROI case does not start with a model recommendation. It starts with one workflow, one owner, one counterfactual, and a measurement plan that can survive contact with real work.

Marius Manolachi can help a team turn an unclear agent idea into a bounded business case, evaluation plan, and operating scorecard. The useful engagement is not a promise of a percentage. It is a clearer decision about what to measure, what to build, what to control, and what to stop.

If you are preparing the case yourself, start with the worksheet above. Fill in the baseline before you write the benefits. Then run the conservative scenario first. If the project still looks worthwhile, you have a reason to test it.

What should you ask next about AI agent ROI?

The practical next question is not “What ROI do AI agents get?” It is “What evidence would make this particular agent worth funding?” Use the answer to set your pilot scope, telemetry, review cadence, and stop conditions.

The calculation is finished when someone else can inspect the assumptions, reproduce the arithmetic, challenge the counterfactual, and see which production measurements will replace the forecast. Until then, you have a proposal. That is fine. Just name it accurately.