Anthropic Unveils a Proven Solution to Resolve the Kimi Quota Issue

After releasing K3.1 Pro, Moonshot AI received many reports from users saying that the model was using up their quota far too quickly. The company quickly announced that “the problem lies with us, and we should have fixed it much earlier.” It gave users extra quota to make up for the problem and said it would “reduce unnecessary sub-Agent calls and output length.”

Just two days before the model launched, Anthropic published an article titled Building agents: When to fold subagents into your main agent loop. The article focuses on the same issue: sub-Agents.

Anthropic compared how Claude was used by several companies and reached this conclusion: an Agent with special skills performs better than a group of sub-Agents sharing the work. It usually also costs less and finishes tasks faster. Most importantly, a single Agent uses far fewer tokens than a group of sub-Agents.

Sub-Agents were basically a “patch” that companies created when models were not powerful enough. They helped models complete more tasks.

Back then, using several sub-Agents did help complete more tasks successfully than using a single Agent. But this came at a cost: token use increased sharply, making the system much more expensive to run.

Anthropic says that as models become more powerful and can handle longer conversations and more information at once, this “patch” no longer improves their abilities. Instead, it has become a “burden.”

What Did Anthropic's Article Cover

Anthropic argues that most tasks do not need many sub-Agents. Usually, one Agent, one model, one conversation history, and one repeating work process are enough.

The model keeps working through the same loop. In each round, it can make several tool calls at once. The results go straight back to the same model, which then decides what to do next.

For example, imagine cooking a dish in a restaurant kitchen. The process includes preparing the ingredients, washing the vegetables, cutting them, cooking the food, and finally putting it on a plate and serving it.

In the old way of sharing the work, you would give different people separate jobs: one washes the vegetables, another cuts them, another cooks, and another puts the food on the plate. Each person gets a list of tasks from the person before them. For example, the person cutting the vegetables receives instructions from the person who washed them.

If the dish tastes too salty when it reaches the table, it can be hard to tell where the problem started. Perhaps the cook added too much salt, or perhaps the vegetables were not cleaned properly.

A single Agent has an advantage because it does not need to explain “what flavor I want” to someone else at the start of every round. It handles the whole cooking process itself and can taste the food and adjust the salt as needed.

The article explains three problems with sub-Agents.

The first problem is that token use keeps adding up.

Every extra sub-Agent adds another layer of work and decision-making, increasing the total cost. A system with multiple Agents uses about 15 times as many tokens as a normal conversation.

The key point is that this 15-fold increase is not used for “thinking” but for “remembering.”

Each sub-Agent must load its own identity, rules, list of tools, and useful background information. It must then turn its results into a short summary and send that summary back to the main Agent. As a result, the main Agent keeps reading the same information again and again.

The second problem is that information loses detail as it passes between Agents.

Each time information moves from one sub-Agent to another, some of its original meaning or detail may be lost. By the time it reaches later sub-Agents, the information they receive may no longer match the original instructions.

In its 2025 article Don't Build Multi-Agents, Cognition described a case in which two sub-Agents were asked to recreate the game Flappy Bird separately. One had to build the background, while the other had to create the bird character. In the end, the first sub-Agent made a background that looked like Super Mario, while the second created a bird that did not look like a game character at all.

The third problem is that different Agents have different personalities and styles.

Even though several sub-Agents communicate within the same system, their responses can look very different because they follow different prompts. Yet users interact with only one main entry point.

Anthropic gives an example from its article: one company had more than a dozen specialized sub-Agents in its product. The company said these Agents made it “extremely difficult to maintain a consistent brand messaging standard.” Users also had to wait for the slowest sub-Agent to finish before they could get an answer.

However, Anthropic is not saying that sub-Agents should disappear completely. Instead, it says they should be loaded only when needed, as Skills.

Each sub-Agent comes with special knowledge. For example, one might know how to cut vegetables, while another knows how to control the heat when cooking. The system can call up the right skill when it is needed and stop using it once that stage of the task is finished.

This approach has measurable benefits.

Anthropic says in the article that, with the right supporting tools, turning sub-Agents into Skills can remove more than 80% of the system prompts.

This quickly removes the long, crowded prompts that used to get in the way of the model's decisions. It also frees up much more space in the model's context for the actual task.

Do We Still Need Sub-Agents At All?

Sub-Agents were basically an engineering compromise created because models had limits at the time.

Andrej Karpathy, who was working at OpenAI at the time, once posted a message on social media saying, in effect, that GPT does not understand that its context has a limit. When doing a task, it can easily fill up its entire context window, causing the task to fail.

So developers needed a way to break large tasks into smaller parts that the model could complete one step at a time.

In late March 2023, two experimental projects, AutoGPT and BabyAGI, were launched. Both used one Agent to break a large goal into several to-do lists, assign tasks to itself, and carry them out on its own.

These projects showed that a repeating work process could function as long as the model decided what to do next. But they also revealed a major problem: without a reliable way to check the results at each step, mistakes could grow larger as the process continued.

An Agent might say, “I'm going to look up this company's financial report.” Even if it finds the wrong report, it may continue reasoning from that incorrect information and eventually produce an answer that looks detailed but makes no sense. It may then keep repeating the same process and making even more mistakes.

From the second half of 2023 through 2024, the industry tried to solve this problem by creating systems that divided work in ways similar to a real company.

For example, MetaGPT gives the model four roles: product manager, architect, engineer, and tester.

If you ask it to “build a Snake game with a leaderboard,” it follows a step-by-step process. First, the “product manager” writes a document explaining the requirements. Next, the “architect” turns that document into a system design and defines the interfaces. Then, the “engineer” writes code based on those interfaces. Finally, the “tester” looks for bugs. Together, these steps produce the complete program.

At the time, the idea was simple: if one model often goes off track, several models could check each other's work and help prevent mistakes. This was an early version of the sub-Agent system.

In simple terms, sub-Agents use “system design to imitate a larger, more stable machine with more memory.”

Besides having limited context windows, models are not always reliable, Anthropic says in the article. The longer a chain of reasoning becomes, the more likely it is to break down. Models also work in a single thread, meaning they cannot think about several things in parallel on their own.

Anthropic says it created sub-Agents in 2024 to address three problems. First, keeping information separate stops large amounts of intermediate results from filling up the main context, effectively giving the system more room to work. Second, giving different tasks different tools helps prevent a failure at one step from ruining the entire task. Third, running separate tasks in parallel lets several independent lines of work move forward at the same time.

Anthropic sees sub-Agents as a kind of “patch” for models. But every patch comes with a cost in tokens.

Over the past two years, developers and companies using APIs have paid most of these costs. Their prices are clear and easy to calculate. If you use an extra 10 cents' worth of tokens, your bill goes up by exactly 10 cents. The cost is fully visible.

But as monthly subscription plans become more popular with everyday users, Anthropic says the situation needs to change.

A monthly quota is like a black box. Users only know “how much quota I have left this month.” They do not know “how much quota these sub-Agents have used in this one conversation.”

People with subscriptions judge their usage by “how many tasks I have completed.” But the system measures it by “how many times the model was called, how many branches were opened, and how many times files were read.”

Anthropic therefore argues that as models become more capable and computing power improves, these “patches” are useful only for very complex tasks. For most tasks, sub-Agents use far more tokens than they need to.

Anthropic's conclusion is that the benefits of sub-Agents no longer outweigh their built-in costs.

Anthropic has even released an open-source tool called single-agent-loop-kit for this purpose. It is designed to make models carry out tasks using only a single Agent, without calling any sub-Agents.

The Bill for K3.1 Pro

Moonshot AI is the latest company to face losses because it used too many sub-Agents.

On October 24, Moonshot AI released K3.1 Pro, a model known for its strong performance. It scored 65.7% on Terminal-Bench 4.0, beating GPT-6 Astra, which scored 58.2%, and finishing just 0.7 percentage points behind Claude Opus 5.5, which scored 66.4%.

However, many users in the community reported that the model used up its quota much too quickly. Just one or two small tasks could consume five hours' worth of quota.

In the early hours of October 26, Moonshot AI officially announced that it would reduce unnecessary sub-Agent calls and shorten output length.

Anyone who has worked at an internet company will probably find this situation familiar.

When a new project comes in, a company might assign a product manager, a designer, a frontend developer, a backend developer, a tester, and an operations specialist. Everyone has to leave comments on the project document, or it looks as if they are not contributing. In the end, a task that one person could finish in half a day may take more than half a year from defining the requirements to scheduling, testing, and launch.

In a company, this is called organizational capability. But when the same approach is used with models, it is simply token consumption.

People using the model can only choose how deeply it thinks. They cannot control how many sub-Agents it activates. They want to pay for getting the task done, not for all the sub-Agents to “align, hold meetings, and make PPTs.”

What's more, users cannot even stop the process. This is related to a concept called upfront failure cost.

In a normal transaction, you pay only after the task is complete. With sub-Agents, quota is used as soon as they are activated, even if a particular sub-Agent contributes almost nothing.

To be fair, this is not a problem unique to K3.1 Pro.

Claude users have also complained that, under the $20 subscription plan, a single prompt can use up five hours' worth of quota. When Opus 5.5 works on an existing codebase, it can hit the usage limit after about 30 minutes. Both problems are caused by Anthropic activating too many sub-Agents.

Anthropic believes this is a “structural contradiction” built into products designed to handle long, complex tasks using Agents.

When you give such a system a task, it must look up information, read files, write, revise, and check its own results. It may need to go through dozens of steps, reading the full context again at each step. That is why the process can easily take half an hour.

The more powerful the model becomes, the longer it may search, the more tools it may call, and the more rounds of checking its own work it may perform.

Anthropic's proposed solution is to have the product decide on users' behalf “which sub-Agent calls are unnecessary.” The system should then reduce the number of sub-Agents and use a single Agent whenever possible, rather than activating extra Agents.

Users should also be allowed to set a maximum number of steps and receive an estimated cost range before a task begins.

As Anthropic moves closer to going public on the stock market, reducing the use of sub-Agents to lower token consumption is also a way to make its consumer users happier.

This article comes from the WeChat public account “Letter AI”. It was written by Miao Zheng and republished with permission from 36Kr.