Cursor engineer consumes 1.5 trillion tokens per month: estimated at $132 million burned annually, how much is the actual cost disputed?

On October 21, OpenClaw founder Peter Steinberger estimated on stage at Cloudflare Connect that his token costs for AI work last month were about $10 million. The audience gasped, and he added: "Not all consumption is useful."

A few weeks earlier, another Peter—Peter Piekarczyk—had also run a jaw-dropping calculation. He saw that Lauren Tan's Cursor profile showed 1.5 trillion tokens used in the past 30 days, and so wrote on X: "At an estimated $8 per million tokens, Lauren consumes about $384,000 per day, or $132 million annualized." Even assuming Cursor gets a 90% discount for large customers, the annual cost would still be about $13 million.

These numbers quickly drew a lot of attention, because they turned invisible tokens into a payroll figure anyone can understand. Before doing the math, one first has to know how exaggerated 1.5 trillion is. Statistics from the engineering management platform Jellyfish on 12,000 developers show that a typical user (50th percentile) uses about 51 million tokens per month, while a 90th-percentile user uses about 380 million. By rough comparison, Lauren's usage is about 29,000 times that of a typical user; Peter Steinberger's publicly disclosed 603 billion tokens in May is about 12,000 times.

How was this "bill" calculated?

Lauren Tan currently works as an engineer on the SpaceXAI Grok team. Her career spans a considerable range: she studied finance in college, first encountered programming while writing VBA macros in Excel, began her career in UI design, later moved into frontend and React and took part in the React Compiler project; after the AI wave rose, she shifted her focus to agent workflows and built pstack, a set of agent skills.

She also knows how to manage her technical image. In mid-September, she said in a video talk that she "merges 2,000 PRs into production every month"—meaning nearly 100 PRs submitted on average every workday. That number is hard to believe and is undoubtedly an outlier.

On September 21, she herself pinned and posted this "2,000 PRs" video on X, but the caption became "Last month I merged 2,500 PRs into production," sparking a new round of discussion.

On October 26, she posted again saying "Looks like a record," with an image showing 4,000 PRs. The numbers rose each time, and each time was accompanied by a public post.

Previously, her Cursor profile showed that she used about 1.5 trillion tokens in the 30 days of September.

Marketing itself is no sin, but when you put an extreme value in a public shop window, you have to be prepared for others to multiply it by a unit price.

Peter Piekarczyk converted this public number into dollars: estimating at an average of $8 per million tokens, he arrived at about $384,000 per day, about $11 million over 30 days, and $132 million annualized. By his calculation, this is "one engineer burning $132 million a year."

He then assumed Cursor could get a 90% discount from Anthropic, that is, settling at one-tenth of the original price, which would bring the cost down to about $38,000 per day, about $1.1 million over 30 days, and about $13 million annualized. Calculating at an annual salary of $500,000 for a senior engineer, that money is equivalent to hiring 26 senior engineers.

Considering that the models she uses may differ, if all were Grok, 30 days would cost about $4.8 million; if all were Opus or Sonnet, about $13.2 million; estimating on a mixed usage of 40% input, 40% output, and 20% cache reads, about $11.5 million. Applying different discounts, the monthly cost of the mixed usage could also fall to $5.8 million or $9.9 million.

Agent programming also involves cache hits. Assuming the price of cache reads is about one-tenth the price of ordinary input, it is still $1 million per month.

However, Piekarczyk's calculation remains disputed.

The token statistics on the Cursor profile fall into at least four categories: ordinary input, model output, cache writes, and cache reads, with very large price differences. Taking Opus 5.5 as an example, ordinary input is about $4 per million tokens, output about $20, and cache reads about $0.20.

A usage screenshot for Opus 5.5 shows that 73.3 billion tokens correspond to about $30,000, or about $0.41 per million tokens; cache reads and writes together account for most of the cost. If this average price is applied to Lauren's 1.5 trillion tokens, the result is about $615,000 per month.

There is another layer to consider: Lauren does deep, long-running agent tasks, so she hits the cache more often than ordinary users. Long-running tasks repeatedly reuse the same context, which further drives up this item's share of the total cost. In Anthropic's published Opus 5.5 pricing, cache reads are $0.20 per million tokens, while ordinary input is $4. If all 1.5 trillion tokens were billed at the cache-read price, the monthly cost would be about $300,000; this is of course only an extreme lower bound.

Piekarczyk himself later backed off: even if his own calculation overestimated by 10 times, or Cursor uses its own GPUs, then at an estimate of about $0.80 per million tokens, the monthly cost would be about $100,000.

On October 9, Piekarczyk launched a poll asking people about their monthly AI budget cap at work; most were below $500 per month. Placed alongside Lauren's estimated monthly bill, the contrast is stark.

For another comparison, in May of this year, Peter Steinberger also posted a CodexBar screenshot on X: over the past 30 days, OpenAI API usage was about $1.305 million, involving 603 billion tokens and 7.6 million requests. He later explained that the screenshot was calculated at Codex's Fast Mode price, and that with Fast Mode turned off, the estimated API cost was about $300,000.

This October figure of $10 million was a verbal estimate at the event, but one thing is consistent: their order of magnitude is in a completely different world from the few-hundred-dollar monthly budgets of ordinary developers.

A way of working that ordinary people cannot try

Steinberger described this kind of investment as exploring "what software development would become if token cost were no longer a constraint." His three-person team was running about 100 Codex instances at the time.

These agent clusters can autonomously review pull requests, scan commit records to find security vulnerabilities, merge duplicate GitHub issues, and write fix code. Some agents proactively submit PRs based on the project's overall roadmap; others continuously monitor performance benchmarks and report performance regressions to the team's Discord server. According to The Decoder, some agents even attend meetings and generate PRs based on features mentioned in the discussion.

Lauren's 1.5 trillion tokens per month, no matter how it is calculated, is likewise an amount ordinary people cannot afford. So what does this money drive? By her own public account, she can now merge 4,000 PRs into production each month with high confidence. The key to this number is not generation but verification.

"The most important skill when using agents is verification. Verification means letting the agent actually run the code, capture CPU traces or heap snapshots, open the iOS simulator, or operate the app the way a user would touch it, actually testing and confirming whether the feature works. Verification closes the loop. It cannot guarantee that the agent writes excellent code, but at least it helps it write correct code; that is already a big step toward building trust."

Her verification skills let the agent check its own work and keep iterating until the task is complete. The logic is: an agent that can check its own output will keep working until the task is done; an agent that cannot will just hand you the diff and stop—and you become the slowest link in the entire loop.

At 4,000 PRs per month, if a human spent 5 minutes checking each one, that would add up to about 333 hours, more than a person's entire month of working hours. Manual review cannot be the verification layer; the checking system must run without human intervention and in parallel with the agent generating the code.

In this loop, the engineer's role is more like an "engineering manager for agents." Lauren said that if you cannot even trust one agent's output, you cannot scale to a hundred agents.

She believes that the vast majority of people have not put agents to use at all: "99% of people are only using 1% of GrokBot's true power. They only run one agent, with neither a 'loop' nor a 'graph.' I run a team of more than 20 GrokBot agents, operating autonomously throughout. I have a chief of staff agent, a project manager agent, and more than 20 agents executing tasks—this is the engineer's new tech stack."

The pstack workflow she has made public is essentially a concrete implementation of this multi-agent orchestration. Through step-by-step playbook guidance, it standardizes R&D tasks into sequential stages: understanding, design, coding, review, and verification. It assigns each sub-agent its own duties by scheduling them concurrently on the local machine (for example, /how for analyzing behavior and /interrogate for auditing risk).

In fact, what pstack records and distills is precisely the vertical verification skills (such as Control Glass) that she built up one by one by observing the failure modes that repeatedly appeared in agents locally, starting from when she had just joined Cursor and knew nothing about the old codebase. Although this multi-agent collaboration flow consumes enormous resources in the cloud, because models lack unlimited context when running locally, for it to truly run through with high confidence, the codebase itself also has to be suitable for agents to take over.

GrokBot was initially a new application rapidly Vibe Coded, with humans having read almost none of the code and with insufficient architectural constraints. Under this mode, when executing tasks, agents prioritize the most convenient approach at hand, causing code to pile up more and more, and functional boundaries and performance risks to spiral completely out of control. For agents to safely take over development over the long term, the codebase must be transformed to be easy for models to understand, and the modification paths must be clear and unavoidably verified.

To this end, Lauren used more than 600 PRs to refactor GrokBot into an architecture internally codenamed Dune; some PRs were relatively small, ranging from a few dozen lines to a few hundred lines to a thousand lines. Under this refactoring approach, the CI checks of the Dune architecture are extremely strict: useEffect is comprehensively banned to eliminate implicit side effects; writing comments is absolutely prohibited, to prevent models from being misled by useless context containing outdated historical information and thus making excessive inferences; at the same time, the dependency graph is rigorously validated to ensure that Electron's main and renderer directories never cross-import.

When this set of high-density refactoring guardrails was completed, because the instinct of agents to take shortcuts was forcibly reversed by the CI red lines, the lifecycle management of the entire system moved completely toward automation.

In Cursor's specific scenario, this personal experience was packaged into pstack, which internally contains 23 Playbooks (workflow scripts) and more than 20 engineering principles. It is Lauren's attempt to shape the discipline of a specific project into the "only shortcut" for agents to pass tests; some people have praised it to the skies, but how much practical value this highly customized dogma actually has for ordinary developers in general development scenarios, given its complex configuration costs, is clearly a question mark.

An "AI Slop" Factory Under Compute Privilege

This delivery model, built on the ultimate piling up of resources, is essentially a capital privilege enjoyed by only a very small number of people. As Peter Steinberger said bluntly, "not all consumption is useful"; this school's blind consumption is often just trial and error. When this extreme case, detached from commercial ROI (return on investment), was pushed into the public shop window, engineers in technical communities such as Reddit immediately launched fierce criticism.

In popular Reddit discussions, frontline developers pointed out bluntly that this frenzy of merging thousands of PRs every month on unlimited funding is not some fundamental revolution in software engineering at all, but rather the use of brute-force compute with no regard for cost to pour large-scale "AI Slop" (AI junk content) into the codebase without knowing the throughput.

Peers' mockery strikes directly at the soft underbelly of this brute-force school: the real bottleneck in software development has never been the "absolute quantity" of code generation, but the long-term maintainability of the system. Faced with ordinary engineers' monthly AI budgets that are generally below $500, once the cloak of "unlimited token consumption" is stripped away, micro-PRs lacking deep thought will spiral completely out of control.

This pipeline, which relies on sky-high-priced tokens for blind trial and error and reactive fool-proofing refactoring, appears to shorten the delivery path, but in reality it transfers the initiative in system design from the elegant holistic thinking of human architects to the mechanical piling up by machines in a sandbox. What this compute privilege, detached from the masses, ultimately leaves to production environments is often not any efficient asset, but rather a massive technical debt that ordinary people are simply unable to maintain in reality.

But in the logic of commercial marketing, this huge compute consumption is indeed worth it for publicity. T3 founder Theo did the math and estimated that Lauren's actual "internal price" is in fact between $25,000 and $50,000 per month, and said bluntly: "The value of this kind of exposure is far more than $25,000 a month; some companies spend more than $1 million on events and get less attention than a casual tweet from Lauren." From Cursor's perspective, this is more like an unsolvable PR myth: even at the rumored millions of dollars a month, the product publicity and traffic returns it generates are completely worth it.

Lauren herself also responded to the cost issue in an interview, acknowledging her methodology's absolute dependence on lab privilege: "I work at an AI lab, tokens are unlimited, so I can't say everyone should follow my approach exactly." But at the same time, she framed this logic as an early-stage input-output trade-off: spending tokens early on refactoring and adding constraints is to enable even the most basic agents to write good code, thereby allowing product managers and designers to deliver features directly. "The value of agents is to let you do things you couldn't do before, not to throw tokens at every little problem."

Although she firmly believes that "you don't have to spend until you're bankrupt to have a chance of reaching a similar state," this still cannot conceal a cruel technical reality: without the foundation of a lab's unlimited tokens, a high-frequency automated verification loop simply cannot be discussed; for ordinary customers and users who are extremely cost-sensitive, this methodology's high verification overhead means a threshold that is difficult to cross.

This article is from the WeChat public account "InfoQ" (ID: infoqchina), author: Tina, published by 36Kr with authorization.