待翻譯：Do All Your Agents Need Models Like Claude 5 or GPT-5.6?

AI 服務暫時不可用，以下為來源正文，待恢復後補全翻譯。

AI agent systems are becoming increasingly common. They can dramatically improve productivity, but once an agent workflow starts making repeated calls across planners, workers, reviewers, tools, and retries, model cost can grow much faster than expected. Flagship models such as Claude Fable 5 and GPT-5.6 Sol are built for difficult work. They offer frontier-level reasoning, instruction following, tool use, and long-horizon agentic capabilities, and they represent the cutting edge of large language model engineering. That capability is expensive to build and expensive to serve. Training and running these models at scale requires massive computing clusters, advanced accelerators, high-performance networking, cooling infrastructure, and enormous amounts of electricity. Some of that cost inevitably appears in inference pricing—and, for anyone operating agents at scale, in the monthly bill. So it is worth asking a fairly simple question: do all of your agents actually need that level of intelligence? What Do People Use AI Agents For? In real-world workflows, AI agents perform a broad range of tasks. Some genuinely require advanced reasoning. Many do not. Typical agent workloads include: reading, classifying, summarizing, and routing emails, documents, tickets, and messages; extracting structured information from unstructured text; searching documentation, source code, databases, logs, and knowledge bases; generating reports, summaries, meeting notes, and routine business correspondence; translating, rewriting, or restructuring existing content; formatting data and converting information between schemas or file formats; writing, reviewing, testing, and documenting code; monitoring systems, logs, queues, dashboards, and scheduled jobs; calling APIs and coordinating deterministic tools; updating databases, spreadsheets, CRM systems, issue trackers, and project-management systems; comparing products, records, configurations, or documents according to predefined criteria; conducting routine research and gathering information from multiple sources; breaking larger workflows into smaller tasks and dispatching them to specialized sub-agents; checking whether an operation satisfies predefined rules, policies, or constraints; generating first drafts that will later be reviewed by another model or by a human; handling retries, validation, bookkeeping, status tracking, and other orchestration work. There are obvious cases where using the strongest available model makes sense: a major architectural decision, a subtle security review, an ambiguous legal document, a complex scientific problem, or an important business decision. These tasks are difficult, consequential, or both. But they are not representative of every model call inside an agent system. In a large workflow, they may account for only a small part of the total activity. Frontier Models Are Increasingly Optimized for Coding—But Agents Do Much More Than Code Software engineering has become one of the most visible battlegrounds in frontier-model development. Leading providers now place considerable emphasis on coding, agentic coding, long-running software-engineering tasks, terminal use, tool execution, and autonomous development workflows when presenting and evaluating their strongest models. Current frontier releases reflect that emphasis. OpenAI highlights GPT-5.6 Sol’s performance on coding and long-horizon engineering workflows involving planning, iteration, and tool coordination, while Anthropic positions Claude Fable 5 as its most capable model for ambitious coding projects and long-running agentic work. There are good reasons for this. Software development is one of the clearest commercially significant applications of generative AI. Code is highly structured, engineering work is economically valuable, and outputs can often be checked automatically with compilers, test suites, static analysis, CI systems, and other deterministic tools. Dedicated coding agents have also become substantial products in their own right. The incentives are therefore unusually strong: software engineering is both a technically attractive environment for AI agents and a market where better model performance can be converted into obvious economic value. Yet a large share of agent work has little to do with writing software. Only part of the workload listed above is inherently about producing or modifying code: writing, reviewing, testing, documenting, and analyzing software. Some other tasks—searching logs, monitoring systems, calling APIs, coordinating tools, or updating technical systems—are engineering-adjacent, but they are often structured operational work rather than software development itself. Then there is everything else: summarizing documents, classifying information, extracting fields, translating content, preparing reports, updating business records, comparing information, conducting research, routing messages, checking rules, drafting routine content, and coordinating workflows. That matters because raw model capability and “task-model fit” are not the same thing. A frontier model that performs exceptionally well on sophisticated software-engineering workflows may also be an excellent general-purpose model. But its coding strength does not imply that every non-coding task benefits proportionally from the same level of capability. Take a support-ticket classifier, an invoice extractor, a meeting summarizer, a short-message translator, a structured-record comparator, or an agent calling a well-defined API. A frontier model may handle unusual edge cases somewhat better or produce more polished output. But if a cheaper model already meets the required quality threshold reliably, that marginal improvement may have little practical value. This is where the economics become more important than the benchmark score. Paying substantially more makes sense when the additional capability changes the result. When it does not, the system is simply overprovisioned. The effect becomes much larger in multi-agent systems. A single user request may fan out into calls to planners, workers, reviewers, retrievers, classifiers, translators, monitors, and tool-using sub-agents, with additional calls generated by retries and validation. Once that starts happening, model cost stops looking like a per-request expense and starts looking like infrastructure. In practice, the best model for an agent is often not the smartest one available. It is the one that is capable enough for that particular job. Much of Agent Work Does Not Require Frontier Intelligence Routine agent work often has recognizable characteristics: the problem is well defined; the context is bounded; the required output format is predictable; the task involves extraction, transformation, classification, summarization, or routine execution rather than deep reasoning; mistakes can often be detected automatically; the output can be verified against deterministic rules; another agent or a human will review the result later; failure is limited, recoverable, or inexpensive; the task can be retried or escalated if the first attempt fails; throughput and cost matter more than small improvements in reasoning quality; the economic value of each individual operation is relatively small. A flagship model can perform these tasks very well. That is not the issue. Using it for every one of them is a little like assigning your most senior engineer to rename files, sort support tickets, copy values between spreadsheets, and check whether required fields are present. The work will probably be correct, but you are paying for expertise that the task does not use. For these jobs, a more useful engineering criterion is straightforward: choose the least expensive model that can meet the required quality and reliability threshold. Smaller and more economical models can often do that when the task is clearly defined, the necessary context is prepared properly, and the result can be checked. Different agents inside the same system can therefore use different model tiers according to task difficulty, uncertainty, value, and risk. What Can Model Overprovisioning Actually Cost? The numbers become interesting even at a fairly ordinary scale. Suppose an agent system makes 10,000 model calls per day, or about 300,000 calls in a 30-day month. To keep the example simple, assume that an average call uses: 2,000 input tokens; 500 output tokens. Rather than compare unrelated products from different vendors, consider three models from the same family. At the time of writing, the standard short-context API prices for GPT-5.6 Sol, Terra, and Luna provide a convenient example: Model Role in This Example Input per 1M Tokens Output per 1M Tokens Cost per Average Call GPT-5.6 Sol Flagship $5.00 $30.00 $0.025 GPT-5.6 Terra Main $2.00 $12.00 $0.010 GPT-5.6 Luna Economy $0.20 $1.20 $0.001 Prices will change, and real workloads do not consume exactly the same number of tokens on every call. The purpose here is simply to see what model allocation does to cost. Scenario 1: Use the Flagship Model for Everything If every call goes to GPT-5.6 Sol, 10,000 calls at an average cost of $0.025 each come to about $250 per day, or $7,500 over a 30-day month. There is nothing technically wrong with doing this. Every task gets access to the strongest model in the family. But the bill assumes that every task benefits enough from that capability to justify paying for it. Scenario 2: Use a Main Model for Routine Work Suppose 20% of calls genuinely justify the flagship model and the other 80% can be handled reliably by GPT-5.6 Terra. The daily calculation is simple: 8,000 Terra calls: $80; 2,000 Sol calls: $50; total: $130 per day. That works out to about $3,900 per month. The system still performs exactly 300,000 calls, but the model bill falls by 48%. Scenario 3: Match the Model to the Task Now suppose the workload is divided more finely: 60% routine, predictable, easily verifiable tasks use GPT-5.6 Luna; 30% moderately demanding tasks use GPT-5.6 Terra; 10% difficult or high-value tasks use GPT-5.6 Sol. The daily cost becomes: 6,000 Luna calls: $6; 3,000 Terra calls: $30; 1,000 Sol calls: $25; total: $61 per day. That is approximately $1,830 per month. The difference across the three approaches is substantial: Architecture Model Allocation Daily Cost Monthly Cost Savings vs. All-Flagship All Flagship 100% Sol $250 $7,500 — Main + Flagship 80% Terra / 20% Sol $130 $3,900 48.0% Economy + Main + Flagship 60% Luna / 30% Terra / 10% Sol $61 $1,830 75.6% Under these particular assumptions, the third architecture costs about $5,670 less per month than sending every request to the flagship model. The 75.6% figure is not a general prediction, and it certainly does not imply accepting 75.6% lower quality. It is the result of this specific workload and pricing example. The assumption is that cheaper models receive only the tasks for which they already meet the required quality threshold, while the flagship model remains available when its additional capability is useful. The allocation percentages are not a recipe either. A coding agent, a research assistant, a customer-service system, and a financial-analysis workflow will have very different task distributions. One system may need the flagship model for half of its calls; another may need it for only a few percent. What matters is that the difference can be large enough to justify treating model selection as an architectural decision rather than a default setting. Real production costs are also affected by prompt caching, context length, reasoning tokens, retries, batch processing, tool calls, provider discounts, and other factors. Those details can change the numbers considerably, but not the underlying economics. A fraction of a cent is easy to ignore on one call. Across hundreds of tho [truncated for AI cost control]