Budget a long agent project: compute vs tokens (RSA-260 case)

That ~$400k figure from Cognition's RSA-260 factoring is GPU rental, not a model bill. The report doesn't price the agent side at all, so if you plan a long agent project, you estimate the token line yourself: sessions × steps × tokens per step, on live prices. That's what the rest of this page does.

The source is Cognition's write-up by Eric Lu, an engineer at Cognition (Factoring RSA-260, published 9 September 2026, checked 6 November 2026). It's being re-shared with the dollar figure in the headline, and the figure is easy to misread.

What the $400k actually pays for#

The author factored a 260-digit number with GNFS, using a heavily modified CADO-NFS that runs on GPUs. The report gives GPU time for each phase:

• polynomial selection: 643 GPU-days
• sieving: 3,813 GPU-days
• linear system solving: 467 GPU-days

That's 643 + 3,813 + 467 = 4,923 GPU-days, which the report rounds to ~4,900. At the report's assumed $3.50 per GPU-hour:

4,923 × 24 × 3.50 = 413,532

That matches the $414k GPU figure in its appendix. So the headline is rented hardware running a number-crunching job for weeks. No model tokens are in that sum.

What the agents did, and what the report doesn't say#

The agent side is described by activity, not by cost. The first prompt went out on 13 August 2026, the work took about three weeks, and the numbers are:

• 233 Devin sessions for the factoring, on average 3 running in parallel and 18 at the peak
• 192 of them got messages from the author, 36 ran with no human intervention at all
• 101 child sessions were started by other sessions
• Devin's own accounting: 14,450 ACUs (that's Devin's unit, not tokens)

The sessions handled measurement, cluster operations, tuning and debugging. The human set priorities and built the benchmarks. Two honest details from the author: the decomposition around CADO-NFS was designed by a person and was essential, and the agents got more confused the further the code drifted from upstream.

What's missing is exactly what a budget needs: which models, how many tokens. So don't try to back out a token bill from 14,450 ACUs. Anything you read online that does is a guess.

The third line: human steering#

The author sent 3,328 messages, 82,702 words in total. That's 82,702 ÷ 3,328 ≈ 25 words per message, short nudges rather than essays. Those words cost almost nothing in tokens. They cost attention: someone has to read what the agents did and decide what's next. When you budget an agent project, put that on its own line in hours, not dollars of API usage.

So a long agent project has three lines:

Estimate your token line#

Here's the formula, and the one thing people forget: every step re-sends the history. An agent doesn't remember a session; each call carries the task, the files it read and the tool output so far. That's why input tokens usually dwarf output tokens (more on that in why AI agents use so many tokens).

Say you plan a project the size of Cognition's, 233 sessions, and you assume 60 steps per session. These two numbers are assumptions of this page, not Cognition data. Then:

233 × 60 = 13,980

that's 13,980 model calls. Now the size of one call. Suppose an average step sends 60,000 tokens in (task, history, a file or two) and gets 1,500 tokens back (a command or a patch). Totals:

60,000 × 13,980 = 838,800,000

1,500 × 13,980 = 20,970,000

So about 839M input tokens and 21M output tokens. Input is forty times the output, and that's the side where your budget lives. On DeepSeek-V4-Flash that project costs $14.68, and one session of 60 steps is $0.063. Here is the same load on every model, with the OpenRouter reference next to it:

Counted in total, with input and output together, each of our models comes out cheaper than OpenRouter for this load. Prices are live from the pricing page, so the table moves when tariffs do.

Get your own numbers in ten minutes#

Assumptions are only a starting point. Run one real session of your task on a cheap model and read the usage object the API returns on every response. OpenAI-compatible endpoints report prompt_tokens and completion_tokens per call:

curl https://api.cheaptokens.dev/v1/chat/completions \
  -H "Authorization: Bearer $CHEAPTOKENS_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "deepseek-ai/DeepSeek-V4-Flash-0731", "max_tokens": 1500, "messages": [{"role": "user", "content": "Summarize this test failure and propose a fix: ..."}]}'

Sum usage over the whole session, divide by the number of calls, and replace the 60,000 and 1,500 above with your averages. Setup details are in the CheapTokens docs; the per-step tracking in code is in track AI agent token cost in Python. For the same arithmetic on a single 50-step session, see agent session cost on GLM, DeepSeek or MiniMax.

For long loops, DeepSeek-V4-Flash has a 380K context window and up to 32,768 output tokens per answer, with one price at any hour. GLM-5.3-Flash has a 390K window and MiniMax-M2.7 has 180K, so check that your largest request fits.

Narrow the task before you raise the budget#

The report has one more lesson that fits a budget: the further the code drifted from upstream, the more confused the agents got. Confused agents take more steps. If your estimate looks too high, shrink steps per session first: a clearer brief, a smaller area of code, fixed steps moved into scripts (see do agents need the model at every step). Halving the steps halves the token line; that's the easiest lever you have.