赞助
停止计票，开始计票
为什么配给代理编码反火，以及什么可以衡量。
由HPE提供
当一个开发者给一个AI agent一个编码任务时，agent会做不止一次的回答。 它计划，生成代码，运行测试，并重复过程以纠正错误。 单项任务可以比基本的聊天提示多使用10到50倍的符号。 agent越有用，它的呼号就越多。 随着每桶定价，创造最大价值的工作流程也可能成为最昂贵的工作流程。
财政压力已经很明显。 据报道，Uber在扩大使用Claude Code后，在4月前用尽了全部2026年AI预算。 GitHub Copilot从平价转向了计量吸入器信贷。 Gartner预测，到2028年AI编码符号成本将超过开发商的平均工资。
自然反应是，在开发者发布 agents之前，配给使用量上限，座位限制，以及批准。 但是，毯式限制可以限制工作流程传递值。 它们也优化了错误的数字。 每个象征性成本衡量消费，而不是结果。 一些支出反映了浪费，包括复试和径行环路。 有些代表了航运软件的工作。 计量仪无法区分它们，支出上限也无法区分。
测量船舶的软件
一个更好的衡量标准是每个合并拉动请求的成本：AI辅助开发成本总额除以通过审查并合并的变动数。 轨迹重修和缺陷，加上如此便宜的改变，并不掩盖质量较低。
如果这一成本随着AI使用率的上升而下降，同时又不损害质量，开发者就会将更多的消费转化为有用的软件。 问题不在于它们使用多少代币，而在于投资产生了多少已完成的工作。
改进这个方程式需要两个改变：为需要它的任务保留昂贵的推论，并降低日常工作的成本。
匹配模型与任务
代理编码不需要每个步骤最强大的模型。 在政策需要时，使用前沿模型，或者说立面旗舰，来进行困难的规划和新的推理。 路由合适的工作，包括代码生成，测试创建，以及重复的重构，为您自己操作的开放量级模型。
一个网关可以根据任务的复杂性，数据敏感性，成本，和耐久性来传送请求。 这为有理由作出溢价推断而不是对整个工作流程适用溢价。 衡量例外，而不是工作量。
开放量级模式使得这种划分越来越实用。 软件工程基准测试显示，领先的开放量级模型可以在某些任务上接近前沿性能。 这并不确定每个储存库或工作流程的等同性。 在分配生产工作之前，根据自己的代码、测试和验收标准评估候选人。
改变重复使用的经济学
接下来，决定谁拥有能力。 通过租借推论，每拨新增到账单。 由于拥有自己的能力，大部分费用是预先承付的，因此，随着使用量的增加，每次额外的呼叫费用都会更便宜。
经济学很简单：每桶定价使得大量使用更昂贵，而自有能力随着团队更多使用而变得更加高效。 所有权不是免费的。 电力、作业、维修和折旧都必须加以考虑。 重要的数字是每个合并拉力请求的满载成本。
拥有能力还提供发票上从未出现的一种价值：对敏感代码的控制。 当代码生成和测试运行在前提上时，专有代码留在企业内部。 只有经核准的规划提示和规范的例外通过组织控制的网关进入外部模式。 这打开了敏感的储存库，那里的安全通常阻碍收养，那里最大的收益正在等待。
测试操作模式
在HPE上，一个混合AI平台将日常工作量从150多个内部应用程序引向在场地运行的开放量级模型，包括在HPE Private Cloud AI上运行。 结果：象征性成本下降30%至50%。
这就是混合问题。 有了HPE私人云AI，拥有你的推论并不意味着放弃前沿模型。 用你拥有的能力运行音量让网关发送最难的工作。
数据还显示，使用量不是有执照的人头数，而是驱动量。 其中前5%的用户产生大部分消费，最重的用户使用量大约是同一许可证上最轻的450倍。 如果电力用户从少数增长到劳动力的一半，月支出可随着定额人口数增长约4.4倍。 你们的组合会有所不同，这正是你们需要衡量的原因。
HPE跟踪2个度量衡，建议客户也这样做。 首先，它跟踪每个活跃的开发商的成本，因为在所有许可证中平均都隐藏了驱动的电力用户花费。 其次，它跟踪每个合并拉力请求的成本，因为它将AI支出与船舶软件连接起来。
在改变基础设施之前，先确定这两种成本的基线。 然后在自有能力上进行完整的开发周期。 如果两种度量法没有随着使用量的增长而改进，那么您目前的模型可能仍然是更好的选择。
建造供采纳，而不是配给
拥有的能力不是每个人都有的。 低或不可预测的使用有利于API，没有资本与闲置的基础设施捆绑在一起。 当持续的需求使其繁忙时，所有权就会得到回报。 大多数企业将经营混合型：用于要求工作或间歇工作的前沿API，拥有可重复体积的能力。 一个受管的网关决定什么离开大楼，所以你得到的前沿模型不放弃对代码的主权。
随着开发者更倾向于编码agents，使用量将不断上升。 真正的选择是，显示增长是作为更大的可变成本账单，还是作为更多的软件以你自己的能力运出。 领导AI辅助开发的公司不会通过配给来控制成本。 他们将建立一个操作模式，让更多的AI使用改善经济而不是破坏经济。
欲了解更多HPE私人云AI，请访问HPE.
该内容由HPE制作。 它不是麻省理工学院技术评论的编辑人员写的。
深潜
人工智能
不要被愚弄-LLMs没有道理
AlphaGo对阵Go冠军李赛铎十年后
“我们看错了”：破坏AI世界的爆炸性说法
他的2.6万字的病毒博客文章中
别被这个夏日的爱尔胡同所愚弄
关于AGI的无呼吸声称和新能力在严格审查下迅速瓦解。
美国花费数十亿用于边境监视。 为何不能在人们死前抓住他们？
监视塔日益由大赦国际提供动力，它保证对过境点作出更快的反应。 我们对塔台附近死亡事件的调查发现，它们未能交付。
保持连接
从
麻省理工学院技术审查
发现特别的报价，顶级故事，即将到来的事件等等。
本文由 AI图鉴自动抓取并翻译，版权归原作者所有；如需查看原文请点下方链接。
Sponsored
Stop counting tokens, start counting what ships
Why rationing agentic coding backfires, and what to measure instead.
Provided byHPE
When a developer gives an AI agent a coding task, the agent does more than answer once. It plans, generates code, runs tests, and repeats the process to correct errors. A single task can use 10 to 50 times more tokens than a basic chat prompt. The more useful the agent becomes, the more calls it makes. With per-token pricing, the workflows creating the most value can also become the most expensive.
The financial pressure is already visible. Uber reportedly exhausted its entire 2026 AI budget by April after expanding its use of Claude Code. GitHub Copilot moved from flat-rate pricing to metered credits. Gartner predicts that AI coding token costs will surpass average developer salaries by 2028.
The natural response is rationing usage caps, seat limits, and approvals before developers launch agents. But blanket limits can restrict the workflows delivering value. They also optimize the wrong number. Cost per token measures consumption, not results. Some spending reflects waste, including retries and runaway loops. Some represents the work of shipping software. A meter cannot distinguish them, and neither can a spending cap.
Measure the software that ships
A better measure is cost per merged pull request: total AI-assisted development cost divided by the number of changes that pass review and are merged. Track rework and defects alongside it so cheaper changes do not conceal lower quality.
If that cost falls as AI usage rises, without compromising quality, developers are converting more consumption into useful software. The question is not how many tokens they use, but how much finished work the investment produces.
Improving that equation requires two changes: reserve expensive inference for tasks that need it, and lower the cost of routine work.
Match the model to the task
Agentic coding does not require the most powerful model at every step. Use a frontier model, or an on-premises flagship when policy requires it, for difficult planning and novel reasoning. Route suitable work, including code generation, test creation, and repeated refactoring, to open-weight models you operate yourself.
A gateway can route requests according to task complexity, data sensitivity, cost, and latency. This reserves premium inference for the moments that justify it rather than applying premium pricing to an entire workflow. Meter the exception, not the workload.
Open-weight models make this division increasingly practical. Software-engineering benchmarks show that leading open-weight models can approach frontier performance on some tasks. That does not establish equivalence across every repository or workflow. Evaluate candidates against your own code, tests, and acceptance criteria before assigning production work.
Change the economics of repeated use
Next, decide who owns the capacity. With rented inference, every call adds to the bill. With owned capacity, most of the cost is committed upfront, so each additional call gets cheaper as usage grows.
The economics are simple: per-token pricing makes heavy use more expensive, while owned capacity becomes more efficient as teams use it more. Ownership is not free, though. Power, operations, maintenance, and depreciation all must be considered. The number that matters is the fully loaded cost per merged pull request.
Owned capacity also delivers a type of value that never appears on an invoice: control over sensitive code. When code generation and testing run on-premises, proprietary code stays inside the enterprise. Only approved planning prompts and governed exceptions go to external models, through a gateway the organization controls. That opens the sensitive repositories where security usually stalls adoption, and where the biggest gains are waiting.
Test the operating model
At HPE, a hybrid AI platform routes routine workloads from more than 150 internal applications to open-weight models running on premises, including on HPE Private Cloud AI. The result: token costs down 30 to 50%.
That is the point of hybrid. With HPE Private Cloud AI, owning your inference does not mean giving up frontier models. Run the volume on capacity you own and let a gateway send the hardest work.
Data also shows that usage, not licensed headcount, drives spend. The top 5% of users generated most of the consumption, and the heaviest used roughly 450 times more than the lightest on the same license. If power users grow from a small minority to half the workforce, monthly spend can rise about 4.4 times with flat headcount. Your mix will differ, which is exactly why you need to measure it.
HPE tracks two metrics and recommends customers do the same. First, it tracks cost per active developer, because averaging across all licenses hides the power users driving spend. Second, it tracks cost per merged pull request, because it connects AI spending to software that ships.
Baseline both costs before changing infrastructure. Then run a complete development cycle on owned capacity. If both metrics do not improve as usage grows, your current model may still be the better choice.
Build for adoption, not rationing
Owned capacity is not for everyone. Low or unpredictable usage favors APIs, with no capital tied up in idle infrastructure. Ownership pays off when sustained demand keeps it busy. Most enterprises will run hybrid: frontier APIs for demanding or intermittent work, owned capacity for repeatable volume. A governed gateway decides what leaves the building, so you get frontier models without giving up sovereignty over your code.
As developers lean harder on coding agents, usage will keep rising. The real choice is whether that growth shows up as a bigger variable-cost bill or as more software shipped on capacity you own. The companies that lead AI-assisted development will not ration adoption to control costs. They will build an operating model where more AI use improves the economics instead of undermining them.
To learn more about HPE Private Cloud AI, please visit HPE.
This content was produced by HPE. It was not written by MIT Technology Review’s editorial staff.
Deep Dive
Artificial intelligence
Don’t be fooled—LLMs don’t reason
Ten years after AlphaGo’s match against Go champion Lee Sedol, today’s AI still isn’t tapping into the machinery that made that win possible.
“We were looking at it wrong”: The explosive claim that’s upended the AI world
An exclusive interview with Nick Cammarata, the researcher whose 26,000-word viral blog post has AI safety folks celebrating.
Don’t be fooled by this summer of AI hype
Breathless claims about AGI and new capabilities fall apart pretty quickly under scrutiny.
The US spent billions on border surveillance. Why can’t it catch people before they die?
Surveillance towers, increasingly powered by AI, promised faster responses to crossings. Our investigation of deaths near the towers found they are failing to deliver.
Stay connected
Get the latest updates from
MIT Technology Review
Discover special offers, top stories, upcoming events, and more.
Auto-fetched and translated by AI Atlas. All rights belong to the original author.