In a post on X, @cursor_ai says Cursor reduced token costs by 7% without a drop in agent quality. The company attributes the result to changes in its agent harness—the software layer that assembles requests, supplies tools and manages context for an AI coding agent.

Cursor’s research post describes several changes behind the result: trimming the system prompt, loading less frequently used tools only when needed, improving prompt-cache reuse, reducing file-read overhead and changing how agents use subagents. Cursor presents the 7% figure and unchanged quality as results from its own testing and production monitoring, not as an independent evaluation.

What an agent harness controls

A coding agent does not send only a user’s latest request to a model. Each turn can also include system instructions, tool definitions, information about the development environment, previous conversation, tool outputs and newly read files. As an agent works through a longer task, that context can grow and much of it may be resent on later turns.

Cursor says its harness gives the company control over how those requests are assembled, which context is reused and when work is divided between agents. The reported savings therefore concern the way Cursor manages an agent run, rather than a change to the underlying models themselves.

Cursor does not provide a contribution breakdown showing how much of the overall 7% reduction came from each optimization. The individual percentages below describe particular changes or measurements Cursor reports; they should not be added together as separate shares of the final result.

A smaller system prompt reduces repeated overhead

Every agent turn includes instructions from Cursor, including the system prompt and definitions for available tools. Because this material is sent throughout a conversation, Cursor says it became one of the largest areas of spending that the company could directly control.

Cursor reports trimming roughly 66% of its system prompt. Earlier prompts contained detailed directions for tool use, task management and code changes, as well as instructions intended to prevent behaviors such as long hash dumps, binary output and emoji use. The company says improved model behavior made some of those instructions unnecessary, allowing it to define tool behavior more directly instead of repeating long lists of prohibitions and requirements.

Cursor says it continues to adjust these instructions as different models need new guidance. It describes A/B tests on a large user base as important because standard evaluations may focus on unusually difficult tasks rather than the full range of requests in production.

Selective tool loading keeps definitions out of most requests

Tool definitions are another form of repeated context. Cursor says its agent gained more tools over time, including background shell monitoring, cloud subagents and web-access capabilities. Many of those tools are useful but are invoked in fewer than 20% of conversations.

Instead of including every tool’s full definition in every request, Cursor moved less frequently used built-in tools into dynamic context. Dynamic context means the definitions are loaded when the agent needs them, while frequently needed tools remain available from the start.

Cursor kept reading, searching, editing and shell tools in static context. It also retained ask_question, which the company says some models tended to hallucinate calls for, along with tools required for specific product flows such as create_plan in Plan Mode. Other tools are loaded only when needed.

The company says it tested different configurations based on how often tools were used and whether models needed to see them at the beginning of a task. It tracked token usage, cost, latency, tool-call errors and overall agent usage. Offloading built-in tools reduced static-context description tokens by 60%, according to Cursor.

Cursor describes a similar earlier change for MCP tools—tools supplied through the Model Context Protocol. It says moving those tools into dynamic context reduced total tokens by 46.9% across sessions that called an MCP tool. That figure applies to those specified sessions, not necessarily to all Cursor agent runs.

Cache reuse makes stable context cheaper to resend

Prompt caching allows a model provider to reuse an unchanged prefix of a request instead of processing all of it as new input each time. An agent’s request often begins with stable material such as system instructions and tool definitions, followed by a conversation that changes as the task progresses.

Cursor says it improved cache reuse after reducing its static context. For requests using the OpenAI API, the company says the API’s explicit cache breakpoints introduced with GPT-5.6 allowed it to mark reusable sections more clearly alongside implicit caching. Cursor now places breakpoints after stable layers and before the growing conversation.

The arrangement matters because a cache boundary is useful only when the content before it remains stable. Cursor says it moved more variable setup—such as skills, subagents and environment information—past those boundaries into a “phantom user message.” It also reserved the front of the request for tools and instructions that change less often.

Cursor reports that these changes reduced the rate of cold-cache misses by 20%. A cold-cache miss means the expected reusable context was not available, so the provider had to process more of the request as new input.

Compressed file reads reduce working-context growth

Agents often add context by reading files. Cursor’s Read tool traditionally included a line number for every line because models can have difficulty counting lines and need line references when citing code.

Cursor says each line number uses around three to five tokens. That overhead can become meaningful when an agent reads tens of thousands of lines during a session. The company changed the format so that line numbers appear on every tenth line instead of every line.

Cursor says this reduced cache-read tokens by 1.6% without reducing quality. The change targets context added while the agent works, rather than the static instructions and tool definitions included at the beginning of each turn.

Subagents can isolate context, but coordination has a cost

A subagent is a separate agent process that handles part of a task and reports its findings to a parent agent. Cursor says subagents can reduce token use because they generally start with a fresh context window instead of carrying the parent’s entire conversation. The parent receives the result without retaining the subagent’s full working context.

That separation can also create a coordination cost. Agents without shared context may duplicate work or continue with an assignment that is no longer necessary. Cursor says it made two changes to capture the benefit without encouraging unnecessary delegation.

First, it removed instructions that strongly encouraged subagents for codebase exploration. Cursor says models had increasingly learned to use subagents from training and post-training, so the extra prompting was no longer needed and removing it produced more balanced usage.

Second, Cursor tightened how subagents select models. Its agents can use any available model for a subtask, which can be useful when the user or harness wants to pair different strengths or costs. Cursor says agents should now choose a different model only when the user or harness directs them to do so.

What the reported 7% reduction establishes

Cursor’s account connects the reported savings to several kinds of harness work:

  • Static prompt overhead: trimming instructions reduces material repeated on agent turns.

  • Tool-definition overhead: selective loading keeps rarely used tools out of requests until they are needed.

  • Repeated-context reuse: explicit cache boundaries and more stable request prefixes improve the chance that prior context can be reused.

  • Working-context growth: less frequent line numbers reduce the size of file reads.

  • Agent coordination: more restrained subagent use limits unnecessary delegation and model switching.

Together, these changes show where an agent harness can affect token spending even when the model’s coding task stays the same. They also involve trade-offs: dynamic tools must still be discovered when needed, cached prefixes depend on stable request structure, compressed line numbering must remain usable for code references and isolated subagents can require more coordination.

Cursor says its internal testing and usage monitoring found no reduction in agent quality, but the source does not include independent evaluation results. It also does not provide the baseline token spend, sample sizes, test duration or detailed A/B-test results behind the headline figure.

The result therefore describes Cursor’s reported experience with its own harness and workloads. It does not establish that the same optimizations will produce a 7% reduction for other coding tools, models, agent designs or individual users.

Sources