How to manage AI investments in the agentic era

OpenAI redefines AI investment metrics for the agentic era

OpenAI has published a framework that reframes how enterprises should evaluate AI investments as the industry shifts from stateless models to agentic workflows. The core idea is straightforward but consequential: stop measuring cost per token and start measuring useful work per dollar. For developers building with AI agents, this signals a fundamental change in how tooling, infrastructure, and models will be judged—and how you should think about your own stack.

The source material—titled “How to manage AI investments in the agentic era”—argues that the traditional metrics used to gauge AI spending no longer apply when agents execute multi-step, autonomous tasks. Instead, the focus must be on the value delivered per unit of cost, efficiency improvements, and scaling only those workflows that prove their worth. While the document is aimed at enterprise decision-makers, its implications ripple directly into the daily choices of developers who integrate AI agents into production systems.

In short: the era of buying compute by the token is ending. The era of buying outcomes by the task is beginning. Here is what that change means for your development workflow, how to adopt the new metric, and where the biggest opportunities lie.

Why “useful work per dollar” changes the game

For the past two years, pricing models from API providers have centered on input and output tokens. Developers optimized for prompt compression, shorter responses, and batching—all in service of reducing token counts. That made sense when most interactions were stateless: one prompt in, one answer out. But agents change the economics dramatically. An agent that makes multiple tool calls, iterates on a plan, and handles error recovery might consume thousands of tokens to complete a single task. Judging that agent by token cost alone misses the point.

OpenAI’s concept of “useful work per dollar” elevates the task—not the token—as the unit of value. For a developer building a code review agent, the useful work might be “mergeable PRs generated” or “bugs correctly identified before deployment.” For a customer support agent, it might be “resolved tickets with no escalation.” The metric forces a direct link between spending and business outcome. It also exposes waste: agents that spin in loops, hallucinate irrelevant steps, or require excessive human oversight fail the useful-work test, regardless of how cheap their tokens are.

This perspective aligns with what many agent builders already intuitively practice. The most effective teams don’t ask “how many tokens did we use per session?” They ask “did the agent complete the goal, and was it worth the cost?” Formalizing this as an investment metric gives developers a stronger language for justifying infrastructure choices—and for weeding out tools that don’t deliver.

Measuring and improving agentic ROI: practical steps

The OpenAI framework suggests that managing AI investments in the agentic era requires three actions: measuring useful work per dollar, improving efficiency, and scaling high-value workflows. Each of these has a concrete translation for developers.

Measuring useful work per dollar. Start by defining a “unit of useful work” for each agent. This could be a successfully completed transformation (e.g., “generated unit test that passes”) or a milestone reached (“resolved ticket”). Then track total cost (API calls, compute, human review time) and divide. This ratio becomes your agent productivity index. Compare across agent versions, model choices, and prompting strategies. A lower ratio means you need to optimize; a higher ratio means you may be under-scaling a good candidate.

Improving efficiency. Efficiency in agentic systems isn’t just about shorter prompts—it’s about reducing failure loops. An agent that takes three retries to parse a function signature is far less efficient than one that gets it right the first time with a well-structured system prompt. Consider tool use patterns: an agent that invokes a file-read tool ten times where a single structured context would suffice is dragging down your useful-work-per-dollar. Audit agent logs for wasted steps, redundant calls, and non-deterministic behavior that adds cost without output.

Scaling high-value workflows. Not every agent use case deserves scaling. The framework advocates identifying workflows where the useful-work-per-dollar ratio meets or exceeds an internal threshold (e.g., saving more developer time than it costs). Those should be aggressively expanded—more parallel executions, more complex tasks, integration into CI/CD pipelines. Lower-performing workflows should receive targeted optimization before scale, or be parked. This pragmatic triage prevents runaway AI costs and surfaces where your team’s energy should go.

For builders using the growing ecosystem of coding agents, these criteria can directly inform tool selection. A detailed comparison of available agents—including how they stack up on useful work per dollar—can be found in our best AI coding agents of 2026 guide, which evaluates agents on exactly these dimensions.

How the metric reshapes agent selection and architecture

Shifting to a work-per-dollar mindset changes which agent features matter most. Raw speed and low latency become secondary to task completion reliability. An agent that finishes a code generation task with no human edits and a 90% acceptance rate is more valuable than one that is twice as fast but leaves bugs. Similarly, an agent that can correctly decide when to ask clarifying questions—avoiding expensive mistakes—beats one that plows ahead blindly.

This also has architectural implications. More teams will likely adopt a “router + specialized agent” pattern, where a lightweight orchestrator assigns tasks to purpose-built agents optimized for specific kinds of useful work, rather than using one generalist agent for everything. The generalist may have lower useful-work-per-dollar on any given specialized task. The OpenAi framework implicitly supports this disaggregation, because it encourages measuring and scaling workflows individually rather than treating all AI usage as a single budget line.

When choosing between specific coding tools, the useful-work-per-dollar metric can highlight surprising trade-offs. For instance, a copilot that integrates deeply with your IDE may deliver extremely high useful work for refactoring tasks but poor results for greenfield architecture. A more autonomous agent might excel at the latter but require more compute per successful output. Our comparison of Cursor vs. Claude Code examines exactly these kinds of differences, helping developers decide which tool offers the best ratio for their dominant workflow.

Another consequence: evaluation frameworks for agents must evolve. Traditional benchmarks (HumanEval, SWE-bench) test model capability, not cost-efficiency in production. Teams will need to build custom evaluation pipelines that measure both task success and dollar consumed per success. This is not trivial, but it is essential to avoid scaling an agent that looks good on a static benchmark but bleeds money in live use.

Finally, the framework signals that model providers will increasingly focus on efficiency improvements. OpenAI’s emphasis on “improving efficiency” suggests that future model releases may prioritize lower cost per useful output over raw intelligence improvements. For developers, this means staying informed about model version updates—they may deliver better ROI even if benchmark scores don’t jump dramatically.

The broader shift toward outcome-based AI spending

OpenAI’s framing is part of a wider industry recognition that AI investments cannot be managed like cloud compute or SaaS subscriptions. The agentic era introduces nonlinear cost and value curves: a small improvement in agent reliability can double or triple useful work per dollar, while a breakdown can cause costs to spiral with no commensurate output. Enterprises and development teams alike need new governance practices—and a new vocabulary for discussing what “better AI” really means.

For individual developers, this is both a challenge and an opportunity. The challenge: you can no longer rely on vendor-provided cost metrics to justify your tool choices. You must instrument your own workflow, define your own units of useful work, and defend your budget with data. The opportunity: teams that master this measurement will be able to identify and scale capabilities that competitors miss. In a world where AI spending is growing rapidly, the ability to show a clear return on agentic investment is a career asset.

Start small. Pick one agent you use daily—a code generator, a reviewer, a testing assistant. Log its completions, failures, and cost for a week. Compute your useful-work-per-dollar. If it’s strong, plan to scale that workflow to more repositories or more team members. If it’s weak, diagnose where the waste lies: too many retries? Overly complex prompts? Wrong model choice? That diagnosis is exactly the kind of analysis OpenAI’s framework encourages.

The agentic era rewards precision, not volume. Measuring useful work per dollar is the compass that helps you navigate it.

Source: OpenAI. Details as reported; verify specifics at the source.