In the single-model era, one API call usually implied one relatively legible execution path. You knew which model ran. You had a rough mental model of cost. You could reason about latency and usage from the outside. In the orchestration era, none of that holds. A case study 👇 ---- @SakanaAILabs launched Fugu this week. It looks like one model. You call it through a single API. But what you call and what actually runs are two different things. Fugu is a coordinator trained to break a task apart, route pieces of it to a pool of other models, and call instances of itself recursively to handle sub-tasks. One prompt can fan out into a swarm of sub-calls the user never sees. The whole thing still surfaces as one model response. Two developers ran into the consequences of that almost immediately. @LLMJunky said a single prompt consumed 100% of a five-hour quota. @cortesi paid for Sakana's $200 tier, found the API slow, and said he hit his limit in under an hour. Neither could say which models ran, how many times Fugu called itself, or why one prompt cost what it did. The issue isn't specific to Fugu either. When @AnthropicAI briefly opened access to Fable earlier this month, users reported similar quota burns with similarly little visibility into why. When one request fans out into many model calls, and some of those calls spawn more, the unit the buyer sees no longer maps cleanly to the unit of work happening underneath. Forecasting cost gets harder. So does explaining latency, attributing performance, or knowing what actually ran. Sakana's benchmark figures sharpen the question. Shared numbers for Fugu include 54.2 on SWE-Pro, 95.1 on GPQA-D, and 93.2 on LiveCodeBench v6, with testers noting scores above Opus, Gemini 3.1, and GPT 5.4 on each. But Sakana's own base model is around 7B parameters. Frontier-tier results from a coordinator that size strongly suggest that a meaningful share of the work is being done by the larger third-party models it calls. Behind one endpoint, the system may be making its own decisions about how much work to do, which models to invoke, and how many times to invoke them. For hobby use, opaque execution is an annoyance. For production systems touching real money or real workflows, it becomes harder to dismiss. You can't price what you can't predict, and you can't debug what you can't trace. When the run is a sealed box, it also becomes harder to prove what the agent actually did. Fugu is one early launch, and Sakana will likely smooth out the rough edges. But as orchestration becomes the product, execution visibility becomes core infrastructure. The next layer of competition in AI will be won by the teams that can make increasingly complex agentic runs legible enough to trust. Follow @SaharaAI for analysis of agent infrastructure, the AI economy, and where the real building is happening.(Sahara AI 🔆)