Claude API Rate Limits in 2026: How Many Requests Can You Run?

Claude API rate limits

Claude API rate limits on the Start tier allow most current models 2,000,000 input tokens and 400,000 output tokens per minute, with 1,000 or 4,000 requests per minute depending on the model. There is no fixed number of concurrent sessions: how many requests you can keep in flight depends on which of those per-minute limits your workload hits first, and how long each request takes.

Last verified: 12 November 2026, against Anthropic’s rate limits documentation.

Key Takeaways
  • The Claude API sets per-minute limits on requests, input tokens and output tokens, and none of them is a fixed concurrent-session count.
  • For any workload, the lowest of RPM, ITPM ÷ input per call and OTPM ÷ output per call sets your throughput.
  • Multiply that throughput by average request duration, divided by 60, to estimate requests in flight.
  • Cache reads don’t count toward ITPM on most models, so caching can lift input-bound workloads several times over.
  • Workspace overrides can lower a team’s effective limit below the organisation’s.
  • Plan below the maximum, read the rate-limit headers and retry with backoff and jitter.

Quick Navigation


Current Claude API rate limits by tier

Anthropic now groups organisations into Start, Build and Scale tiers, plus a Custom tier arranged with its account team. New organisations may begin in an Evaluation tier with lower limits while they build a usage history. Anthropic places organisations on a tier automatically, and you can ask for an increase from the Rate limits page in the Claude Console.

Each model group has three separate limits. Requests per minute (RPM) counts API calls. Input tokens per minute (ITPM) counts the prompt tokens you send. Output tokens per minute (OTPM) counts the tokens the model generates.

TierModel groupRPMITPMOTPM
StartOpus 5.5, Sonnet 5.5, Haiku 5.54,0002,000,000400,000
StartOpus 5, Opus 4.x, Sonnet 5, Sonnet 4.x, Haiku 4.51,0002,000,000400,000
StartFable 5.x4,000500,000100,000
BuildOpus 5.5, Sonnet 5.5, Haiku 5.510,0005,000,0001,000,000
BuildOpus 5, Opus 4.x, Sonnet 5, Sonnet 4.x, Haiku 4.55,0005,000,0001,000,000
BuildFable 5.x10,0001,500,000300,000
ScaleOpus 5.5, Sonnet 5.5, Haiku 5.513,00010,000,0002,000,000
ScaleOpus 5, Opus 4.x, Sonnet 5, Sonnet 4.x, Haiku 4.510,00010,000,0002,000,000
ScaleFable 5.x13,0004,000,000800,000

Source: Anthropic rate limits documentation, Messages API tables, checked 5 November 2026.

Each row in the table describes a limit for one model group, and groups don’t share a budget. Opus 4.8, 4.7, 4.6 and 4.5 draw from one combined Opus 4.x limit, while Opus 5.5 and Opus 5 each have their own. Sonnet 4.6 and 4.5 share a Sonnet 4.x limit, and Fable 5.1 and Fable 5 share a Fable limit. The Rate Limits API lists exactly which model IDs count against each group for your organisation.

Each tier also carries a monthly spend cap of $500 on Start, $1,000 on Build and $200,000 on Scale. Reaching it pauses usage until the first day of the next month, unless you get a higher limit approved sooner.

How many concurrent requests can you run?

An illustrative way to estimate concurrency from published rate limits.

The API publishes per-minute limits, not a cap on simultaneous connections. To estimate concurrency, work out how many requests per minute each limit allows for your workload, take the lowest, and multiply by how long a request lasts.

The formula

Estimated in-flight requests = permitted requests per minute × average request duration in seconds ÷ 60.

Permitted requests per minute is the smallest of three numbers:

  • your RPM limit;
  • your ITPM limit divided by the input tokens that count against it per request;
  • your OTPM limit divided by the output tokens per request.

The result is a sustainable average for a steady workload. It doesn’t promise that a given number of requests can start at the same instant.

Worked example 1: an output-limited workload

This illustrative workload runs on the Start tier with Opus 5, which allows 1,000 RPM, 2,000,000 ITPM and 400,000 OTPM.

  1. Each prompt is 20,000 tokens, and 80% of them are read from the prompt cache. Cache reads don’t count toward ITPM on this model, so each call counts 20,000 × 0.2 = 4,000 uncached input tokens.
  2. Input allows 2,000,000 ÷ 4,000 = 500 calls per minute.
  3. Each response is 2,000 tokens. Output allows 400,000 ÷ 2,000 = 200 calls per minute.
  4. RPM allows 1,000 calls per minute.
  5. The lowest of 500, 200 and 1,000 is 200 calls per minute, so output is the binding limit.
  6. With an average call lasting 30 seconds, in-flight requests come to 200 × 30 ÷ 60 = 100.

Output binds here because each response is long relative to the uncached prompt. On Opus 5.5, the RPM figure would rise to 4,000, but the answer would stay at 200 calls a minute because the token limits are the same. Even then, 100 is an average to plan around, and bursts above it can still trigger 429 errors.

Worked example 2: an input-limited workload

This second illustrative workload uses the same Start-tier limits for Opus 5, but each request summarises a fresh document.

  1. Each prompt is 50,000 tokens. Every document is new, so the cache hit rate is 0% and all 50,000 tokens count toward ITPM.
  2. Input allows 2,000,000 ÷ 50,000 = 40 calls per minute.
  3. Each summary is 1,000 tokens. Output allows 400,000 ÷ 1,000 = 400 calls per minute.
  4. RPM allows 1,000 calls per minute.
  5. The lowest of 40, 400 and 1,000 is 40 calls per minute, so input is the binding limit.
  6. With an average call lasting 15 seconds, in-flight requests come to 40 × 15 ÷ 60 = 10.

Caching changes this case sharply. If a 30,000-token instruction block were cached and only 20,000 tokens per call were new, input would allow 2,000,000 ÷ 20,000 = 100 calls per minute. Output would still allow 400, so the binding limit would rise from 40 to 100 calls a minute.

Where the estimate breaks down

The formula assumes steady request sizes and durations, which real traffic rarely has. Long and short prompts mix, streaming responses hold connections open longer, and network latency and queueing add time that the model isn’t using. Retries add load at the moment you can least afford it.

The rate limits are also enforced more finely than a minute. Anthropic uses a token bucket that refills continuously, and notes that a limit of 60 RPM might be enforced as one request per second. Sharp rises in an organisation’s traffic can also hit separate acceleration limits, so Anthropic advises ramping up gradually.

Two details help planning. ITPM is estimated when a request starts and corrected as it runs. OTPM counts only tokens actually generated, so a high max_tokens setting doesn’t use up the allowance on its own. Most teams plan well below the theoretical maximum to leave room for bursts and retries.

How prompt caching raises effective input throughput

At an 80% cache hit rate, a 2 million ITPM limit can carry about 10 million input tokens a minute.

For most Claude models, only uncached input tokens count toward ITPM. The API reports three kinds of input token: input_tokens after the last cache breakpoint, cache_creation_input_tokens written to the cache, and cache_read_input_tokens read from it. The first two count toward ITPM, and cache reads don’t.

Anthropic’s own example uses a 2,000,000 ITPM limit and an 80% cache hit rate. In that case, 20% of incoming tokens count, so the limit supports 2,000,000 ÷ 0.2 = 10,000,000 total input tokens per minute: 2 million uncached and 8 million cached.

The benefit applies only to the input limit. Caching doesn’t raise RPM or OTPM, and the first request that writes a cache entry still counts in full. The retired Claude Haiku 3.5 is an exception, because it counts cache reads toward ITPM. Billing for cached tokens follows a separate price schedule from rate limiting. Our guide to structuring prompts for caching covers how to keep a stable prefix that the cache can reuse.

What happens when you hit a limit

Exceeding any one limit returns an HTTP 429 with the type rate_limit_error that names the limit you crossed. When the response includes a retry-after header, Anthropic says to wait that many seconds, because earlier retries will fail. A 429 caused by the monthly spend cap carries no retry-after header and keeps failing until access resumes, so retrying it won’t help.

Successful responses carry rate-limit headers you can use to schedule work before you hit a wall:

  • anthropic-ratelimit-requests-limit, -remaining and -reset track requests.
  • anthropic-ratelimit-input-tokens-limit, -remaining and -reset track input tokens.
  • anthropic-ratelimit-output-tokens-limit, -remaining and -reset track output tokens.
  • anthropic-ratelimit-tokens-limit, -remaining and -reset show whichever token limit is most restrictive right now.

The reset headers use RFC 3339 timestamps, and the token “remaining” values are rounded to the nearest thousand. A scheduler can slow its dispatch rate as remaining capacity falls, which avoids most 429s in the first place.

When 429s do arrive, use exponential backoff with random jitter so that many workers don’t retry at the same moment. Anthropic’s official SDKs retry automatically, twice by default, and honour retry-after. A shared queue with a fixed concurrency cap is usually safer than letting each worker retry on its own.

Workspace limits and Priority Tier

Organisation limits are the ceiling, and workspace limits can be set lower to stop one team or app using everything. Without an override, a workspace inherits the organisation’s limit. The Rate Limits API can set workspace overrides for requests, input and output tokens per minute, cache-aware input tokens per minute, tokens per minute, tokens per day and tool uses per second. The lower of the workspace and organisation values applies, and changes take effect within about an hour.

Priority Tier is a separate capacity commitment measured in input and output tokens per minute for a specific model. Anthropic says new commitments are no longer available for purchase, though existing contracts continue until they end. Priority requests still draw on the ordinary rate limits, and traffic beyond the commitment falls back to the standard tier.

Claude.ai, Claude Code and API limits are separate

Usage limits on Claude.ai and Claude Code subscriptions are a different system from the API rate limits above. Anthropic bills the API separately from paid Claude plans, and its support documentation explains how the two relate. For plan allowances, check the current articles on Claude’s help centre.

How Claude API rate limits compare with other providers

Other providers combine request limits, token throughput, account tiers, daily caps and per-model rules in different ways, so their figures can’t be compared directly. Our overview of AI API rate limits across providers sets them side by side, and our guide to LLM cost per task shows how to price the same workloads.

Frequently asked questions

Does the Claude API have a fixed concurrent-session limit?

The rate-limit documentation doesn’t list one. Concurrency follows from the per-minute limits and request length, so a workload with short responses can run far more parallel calls than one producing long outputs.

Can multiple applications share the same Anthropic API rate limits?

Yes. Every key in an organisation draws on the same organisation limits, and the anthropic-workspace-id response header shows which workspace a request counted against. Giving each application its own workspace with lower overrides stops one from using all the capacity, though the organisation limits still cap the total.

What is the difference between a 429 rate-limit error and a server error?

A 429 means your organisation has used its allowance, so the fix is to slow down or wait for retry-after. A 500 signals an internal error and a 529 signals that the API is overloaded for everyone. Both are temporary and worth retrying with backoff.

Can prompt caching increase Claude API request concurrency?

Only when input tokens are the binding limit. Caching leaves RPM and OTPM unchanged, so an output-bound workload gets no extra concurrency from it.


Keep reading

AGI vs superintelligence

AGI vs Superintelligence: A New Name Isn’t a New Intelligence

Facts checked against official documents and reporting on 18 November 2026. On 29 September, the White House told federal agencies to stop writing “artificial intelligence” …
AI Coding Agent

AI Coding Agents Are Getting Expensive. Who’s Paying for the Tokens?

Pricing checked on official vendor pages on 17 November 2026. All USD. Cost scenarios are illustrative and labelled as such. On 28 October, TechCrunch published …
Model Weights

Verify Model Weights: 7 Checks Before You Download

Checked against the burner22/numbat repository and its discussions, Hugging Face and PyTorch documentation, and Moonshot AI’s announcement on 2 November 2026. On 1 November, a …
Agentic AI Statistics

30 Agentic AI Statistics for 2026: Adoption, Spending and Risk

Last updated: 15 November 2026. This page is updated monthly; each figure keeps its original publication date. Agent traffic at one healthcare booking platform rose …

Anthropic IPO: The $895 Billion Question Behind Its Valuation

Anthropic IPO valuation

Last updated: 9 November 2026. Latest confirmed development: Anthropic’s amended S-1, filed on 2 November, still leaves the share count and the IPO price range blank. As of our research on 9 November, we found no later amendment.

A month ago, some investors were reportedly talking about valuing Anthropic at up to $2 trillion. By 6 November, Bloomberg reported that prospective buyers were discussing a range of $1.2 trillion to $1.3 trillion, and that some were weighing $1.1 trillion. That is the headline version of the Anthropic IPO valuation story.

The filing tells a more useful one. Anthropic’s November 2 S-1/A shows $17.0 billion of revenue in a single quarter and a nine-month net loss of $104.0 billion, most of it non-cash. It also shows roughly $895.4 billion in aggregate compute and infrastructure commitments. Read together, those numbers explain more about the price buyers will pay than any single bid range does.

Key Takeaways
  • Valuation talk has fallen in reports, not filings: from up to $2 trillion earlier in the year to $1.2 trillion to $1.3 trillion, with one source citing $1.1 trillion.
  • The S-1/A confirmed fast growth and an operating loss: $16.96 billion of Q3 revenue, and a $567 million loss after a profitable Q2.
  • About 91% of the $104.0 billion nine-month net loss is a non-cash fair-value charge on convertible notes, which should end once the existing notes convert.
  • The $895.4 billion is a commitment schedule, not debt. Half of it is leases that have not commenced, and about $213.8 billion is conditional or terminable.
  • The 13.2x ratio shows scale, not solvency. The more useful test is $69.8 billion due in 12 months against $131.8 billion of cash and short-term investments.
  • Commitments could grow. The filing estimates a further $150 billion to $175 billion under arrangements with no fixed dollar figure.
  • Price, size and date are unconfirmed. All three are blank or absent in the filing.

Quick Navigation


Anthropic IPO valuation: what is confirmed and what is reported?

The figures in circulation come from very different places. Some are in a document Anthropic filed with the Securities and Exchange Commission. Others come from unnamed people describing investor conversations. This table keeps them apart.

ItemFigure or developmentEvidence status
Amended registration statementS-1/A (Amendment No. 1) filed 2 November 2026SEC-filed
Q3 2026 revenue$16.96 billion (three months to 30 September)SEC-filed
Nine-month 2026 revenue$33.24 billion, against $2.55 billion a year earlierSEC-filed
Aggregate commitmentsAbout $895.4 billion, substantially all compute and infrastructureSEC-filed
$1.2T to $1.3T valuation rangeDiscussed by prospective buyers, per Bloomberg, 6 NovemberAnonymous-source reporting
$1.1T lower endSome buyers weighing it, “one of the people said” (Bloomberg)Anonymous-source reporting
Earlier $2T expectationsInvestors expected up to $2 trillion earlier in the year, per ReutersPress-reported
Last private valuation$965 billion post-money, $65 billion Series H, 28 May 2026Company-disclosed
IPO timingRoadshow expected from the week of 9 November, pricing the week after, per ReutersAnonymous-source reporting
IPO price range and share countBlank in the amended filingSEC-filed (blank)
Commitments relative to revenueAbout 13.2 times annualised Q3 revenueCalculated
Disclosed figures come from the SEC filing; valuation ranges come from anonymous-source press reports and are not offering terms.

How the Anthropic IPO valuation talk changed

Three numbers mark the slide. Reuters reported that earlier in the year, investors expected an October listing at a valuation of up to $2 trillion. Bloomberg’s earlier reporting, as summarised by Investing.com, put the range investors had passed to bankers at $1.4 trillion to $1.5 trillion. Then, on 6 November, Bloomberg reported that potential buyers were discussing $1.2 trillion to $1.3 trillion, according to people familiar with the matter.

None of these is an official valuation, a filed figure, a trade or an IPO price. They describe what some buyers will discuss before formal marketing begins. For background on how the business looked before the filing, see our earlier analysis of Anthropic’s reported revenue and compute economics.

The Bloomberg report followed a sharp selloff on 5 November, when the Associated Press reported the Nasdaq composite down 4.5% in afternoon trading. AP linked the drop to rising borrowing costs, doubts about AI stock prices, and Democratic midterm gains that raised the prospect of curbs on data center construction.

What the November 2 S-1/A actually shows

The amended S-1 adds third-quarter results to the prospectus first made public on 26 October. Anthropic plans to list Class A shares on the Nasdaq Global Select Market under the symbol “ANT”. Goldman Sachs and Morgan Stanley head the underwriting list. The number of shares and the expected price range are still blank.

Revenue growth and the Anthropic IPO valuation

Revenue for the three months to 30 September was $16,956 million, against $1,382 million a year earlier. That is about 12.3 times the prior-year quarter, and 47% more than the $11,555 million reported for the June quarter. Nine-month revenue was $33.24 billion.

Operating results moved the other way in the latest quarter. Anthropic earned an operating profit of $974 million in Q2, then recorded an operating loss of $567 million in Q3. The filing attributes the swing mainly to $5.0 billion of compute bought under short-term commitments and a $2.0 billion non-cash charge tied to its employee donation matching programme.

Buying short-notice capacity suggests demand ran ahead of contracted supply. It also shows how fast compute costs can swing a quarter from profit to loss.

A $104 billion loss that is mostly not cash

The nine-month net loss of $104.0 billion looks alarming until you trace it. The filing says the accumulated deficit includes $94.3 billion of fair-value changes on convertible notes and derivative liabilities during the nine months, “driven by increases in our enterprise valuation”. In Q3 alone, that line was $21.9 billion of a $23.3 billion net loss.

These are accounting remeasurements. When Anthropic’s valuation rises, the notes are worth more to their holders and the company books a loss, but no cash leaves the business. The prospectus assumes the notes convert into shares immediately before the offering closes, which should end these charges on the existing notes. The filing also says Anthropic may issue up to $77.0 billion more in convertible notes, subject to conditions.

Other items need more care. Stock-based compensation was $3.3 billion over the nine months, and the donation charge was $2.0 billion. Neither is cash today, but both affect shareholders. The cash figures point the other way. Operating activities generated $6.6 billion in the first nine months of 2026, compared with $2.0 billion of cash used a year earlier.

The $895.4 billion figure behind the Anthropic IPO valuation

This is the number most easily misread. The filing describes “an aggregate committed spend of approximately $895.4 billion, substantially all of which is related to compute and infrastructure”. About $447.5 billion is expected before 31 December 2030, and “substantially all of the remainder” between 2031 and 2045.

It is not debt, money already spent, or a single year’s expense, and most of it is not on the balance sheet. It is a schedule of future purchases and leases, often agreed before the capacity is built.

The three figures are nested: the $69.8 billion falls within the $447.5 billion, which falls within the $895.4 billion. Source: Anthropic S-1/A, 2 November 2026.
How the $895.4 billion adds up

The contractual obligations section of the filing lets us rebuild the total. Our addition of the parts comes to $895.39 billion:

ComponentAmountWhat it is
Fixed obligations at 30 September$320.0 billionPurchase commitments of $313.8 billion plus operating and finance leases of $6.2 billion
Leases signed but not yet commenced$451.2 billionMostly expected to begin between 2026 and 2028, with terms up to 20 years
Commitments signed after 30 September$100.2 billionMainly data center leases and cloud hosting agreements
Short-term contracts$24.0 billion$17.4 billion at quarter end plus $6.6 billion signed afterwards

Half the headline, about 50.4%, is leases that have not started. Only about 36% sits in the payment table as of the balance-sheet date. The rest was added later or will only become an obligation when a facility is delivered. This is a large jump from the $518 billion figure reported from the confidential draft in October, which we covered in Anthropic’s earlier $518 billion infrastructure commitments.

The named contracts show the scale: at least $110.0 billion with Amazon through April 2036, about $121.3 billion with Google through July 2033 and at least $44.9 billion with Microsoft through June 2033. Each applies “regardless of actual usage”.

The filing also lists arrangements that are not in the $895.4 billion because they carry no fixed dollar commitment. It estimates payments under these at about $150 billion to $175 billion. It gives separate estimates for extra Google TPU capacity ($125 billion to $150 billion) and an AMD agreement (more than $20 billion), both outside the $895.4 billion. The headline may understate eventual spending even as parts of it stay conditional.

Not all of the total is locked. The filing says about $213.8 billion, roughly 24%, is subject to exercisable termination rights or to conditions before the arrangement begins, such as a counterparty securing financing, sites or regulatory approval. In general, Anthropic can also terminate if counterparties miss delivery dates.

That flexibility cuts both ways. Terms that let Anthropic walk away if a data center is late also mean some planned capacity may never arrive.

Anthropic Direct and the case for locking in capacity

The filing describes a shift from cloud contracts toward what Anthropic calls Anthropic Direct: leasing chips directly and hosting them in dedicated facilities run on its behalf. It says this allows the company “to separate our commitments for data center capacity from our commitments for the compute infrastructure deployed inside them”.

Data centers take years to build but are the smaller part of compute cost, so securing buildings early and buying chips later keeps the costliest decisions open. The trade-off is rigidity: leases of up to 20 years are hard to unwind if demand slows.

The filing also says some data center projects rely on “financing sources or partners who guarantee the lease obligations”. Fortune’s 4 November analysis argues that this shifts part of the risk onto chip suppliers. It is part of the financing pressures across AI infrastructure that have pushed some bond investors to demand higher yields.

The 13.2x comparison: useful for scale, easy to misuse

Here is the calculation behind a figure that has circulated widely:

  • Q3 revenue: $16.956 billion × 4 = $67.8 billion annualised
  • $895.4 billion ÷ $67.8 billion = about 13.2 times

That ratio is a scale illustration. The $67.8 billion annualises one quarter; it is not a forecast or reported annual revenue. The $895.4 billion spans almost two decades. The result is not a debt-to-revenue ratio, an enterprise-value multiple or a solvency test.

Better comparisons look at matching time frames. The filing says about $69.8 billion of obligations is expected to be paid in the 12 months after 30 September. That is roughly equal to one year of revenue at the Q3 rate (about 103%). It is also about 1.8 times the annualised Q3 compute and infrastructure expense of $39.5 billion. These are our calculations, and both comparisons assume revenue stays flat, which recent quarters suggest it won’t.

The pre-2030 figure gives a second view. A simple average of $447.5 billion over the roughly four and a quarter years to the end of 2030 is about $105 billion a year. That is an illustration, not a schedule. The filing’s own table shows payments rising from $29.2 billion in 2027 to $47.8 billion in 2029, before the leases not yet commenced are added.

Why buyers may want a lower Anthropic IPO valuation

The evidence points to several pressures at once, without showing which matters most. The market backdrop is the clearest. Bloomberg tied the lower bids directly to the post-election selloff. Reuters, citing four people familiar with investor discussions, reported that some potential buyers see $1.5 trillion as the top of their range and want a bigger discount. Truist’s Keith Lerner, quoted by Reuters, called the mood “a buyers’ strike in tech”.

Company-specific concerns also feature. Reuters reported investor attention on Anthropic’s record of quarterly losses, its capital needs and its large commitments to partners. Investors also want an October revenue figure to judge whether growth has picked up again after a recent slowdown.

At $1.2 trillion, Anthropic would be valued at about 17.7 times annualised Q3 revenue. At $2 trillion, the figure would be about 29.5 times. These are our calculations, and they ignore whether the reported figures are pre- or post-money.

The private round adds another reference point. Anthropic raised $65 billion at a $965 billion post-money valuation in May, per Reuters. Even the $1.1 trillion lower end is about 14% higher. The two figures are not directly comparable, though. A private round prices preferred shares with negotiated rights, while an IPO prices common stock in an open market and adds new shares.

Cash, liquidity and the Anthropic IPO valuation

Profitability and liquidity are different questions. Anthropic is not consistently profitable on an operating basis, but it holds a lot of cash.

At 30 September, the filing shows $95.6 billion of cash and cash equivalents and $36.3 billion of short-term investments. It also shows $14.8 billion available under a $15.0 billion revolving credit facility that matures in 2031. Cash and short-term investments of $131.8 billion cover the $69.8 billion due over the next 12 months about 1.9 times.

That cushion came mostly from investors, not from operations. Financing activities brought in $110.7 billion over the nine months. Investing activities used $36.5 billion, mainly to buy short-term securities. Spending on property and equipment was only $925 million, plus $2.0 billion of prepayments for leased assets.

The filing warns this will change. It expects more compute investment to need “significant upfront payments” before the compute is operational, and significant net cash outflows “for the foreseeable future”. It says its resources cover at least the next 12 months.

What the IPO could change

The filing says the offering aims to increase Anthropic’s “capitalization and financial flexibility” and create a public market for its shares. Proceeds are for general corporate purposes, including “investments in compute and infrastructure”. Reuters reported that some expect the deal to raise as much as $100 billion, although the filing gives no amount.

A listing would convert the existing notes and end their fair-value charges, making net income easier to read. It would give Anthropic a public currency for future raises. It would also reprice the company daily, so the commitment schedule is judged every quarter rather than once per funding round.

What the Anthropic IPO valuation debate can’t answer yet

Several facts that would settle the argument are not public. The price range and share count are blank. The split between new shares and shares sold by existing holders is unknown, which determines how much cash Anthropic actually raises.

The filing does not give a year-by-year schedule for the $451.2 billion in leases not yet commenced. Nor does it say how the $150 billion to $175 billion of variable arrangements will be phased. Most importantly, nobody outside the company knows how much of the contracted capacity will be needed by the time it arrives.

What to Watch Next

These would change this analysis, roughly in the order they are likely to appear:

  1. The next S-1 amendment: any change to the $895.4 billion or the $69.8 billion due in 12 months.
  2. The price range: the first company-set valuation signal, replacing press-reported ranges.
  3. The share count: needed to turn a price into a market capitalisation.
  4. New versus selling-stockholder shares: how much cash reaches Anthropic.
  5. The pricing date: a slip past the reported November window would be material.
  6. Updated financials, including the October revenue investors reportedly want.
  7. Timing changes confirmed by the company or a filing, not by sources.
  8. Revised investor discussions, treated as reporting, not offering terms.

FAQ

What is the Anthropic IPO valuation in 2026?

There isn’t one yet; the S-1/A leaves the price range blank. Bloomberg reported on 6 November, citing unnamed sources, that buyers were discussing $1.2 trillion to $1.3 trillion.

Why has the reported Anthropic IPO valuation fallen?

Reports link it to the AI stock selloff after the US midterms and to concerns about losses and compute commitments. Which factor weighs most is unclear.

Is the Anthropic IPO valuation higher than its last private valuation?

Based on reported discussions, yes. Anthropic’s May 2026 round valued it at $965 billion post-money. Even $1.1 trillion would be about 14% higher, though private and public valuations are not directly comparable.

How much revenue did Anthropic report in Q3 2026?

$16.96 billion for the three months to 30 September 2026, according to the S-1/A. That is about 12 times the $1.38 billion reported a year earlier.

What are Anthropic’s $895.4 billion compute commitments?

Purchase commitments and leases, substantially all for compute and infrastructure, including leases not yet started. About $447.5 billion falls before 2031 and most of the rest between 2031 and 2045.

Is the $895.4 billion current debt?

No. Most of it is future spending under contracts and leases that have not begun. About $69.8 billion is expected to be paid in the 12 months after 30 September 2026.

Has the Anthropic IPO valuation or price been set?

No. The price range is blank, and reported figures are investor discussions, not offering terms.

When is Anthropic expected to go public?

Reuters reported a roadshow from the week of 9 November and pricing the week after, while noting investor doubts about that timing. Anthropic has not confirmed a date.

Why do compute commitments matter to the Anthropic IPO valuation?

They lock in large future costs before the revenue to pay for them exists. Buyers have to judge whether demand will grow fast enough to use the capacity Anthropic has contracted.

What would change this Anthropic IPO valuation analysis?

A filed price range, the share count, the split between new and existing shares, and any change to the commitment figures in the next S-1 amendment.

This article is for informational and educational purposes only. It is not investment advice, a recommendation to buy or sell securities, or a prediction of Anthropic’s IPO valuation or share price. Reported investor discussions should not be interpreted as confirmed offering terms.


Keep reading

AGI vs superintelligence

AGI vs Superintelligence: A New Name Isn’t a New Intelligence

Facts checked against official documents and reporting on 18 November 2026. On 29 September, the White House told federal agencies to stop writing “artificial intelligence” …
AI Coding Agent

AI Coding Agents Are Getting Expensive. Who’s Paying for the Tokens?

Pricing checked on official vendor pages on 17 November 2026. All USD. Cost scenarios are illustrative and labelled as such. On 28 October, TechCrunch published …
Model Weights

Verify Model Weights: 7 Checks Before You Download

Checked against the burner22/numbat repository and its discussions, Hugging Face and PyTorch documentation, and Moonshot AI’s announcement on 2 November 2026. On 1 November, a …
Agentic AI Statistics

30 Agentic AI Statistics for 2026: Adoption, Spending and Risk

Last updated: 15 November 2026. This page is updated monthly; each figure keeps its original publication date. Agent traffic at one healthcare booking platform rose …

Claude Opus vs Sonnet: What the 2026 Price Gap Actually Buys

Claude Opus vs Sonnet

Last verified: 8 November 2026. All prices are Anthropic’s standard first-party API rates in US dollars per million tokens. They aren’t Claude Pro or Max subscription prices, and partner platforms can price differently.

A million output tokens from Claude Haiku 5.5 costs $0.50. The same million from Claude Fable 5.1 costs $50. That 100x spread across Anthropic’s four current models makes Claude Opus vs Sonnet only part of the decision, and price alone a poor guide to which model is the bargain.

The gap doesn’t mean Fable is 100 times more capable. It doesn’t even mean a task costs 100 times more, because input prices, long-prompt surcharges, caching and the number of attempts a task takes all change the bill. With all four Claude models compared on Anthropic’s API pricing, this guide shows what each costs and which workloads each one suits.

Key Takeaways
  • Output prices span 100x, from Haiku 5.5’s $0.50 to Fable 5.1’s $50 per million tokens. Opus 5.5 is exactly twice Sonnet 5.5.
  • Haiku 5.5 has a cliff at 100K tokens. Above it, the whole request is billed at five times the rate, cached tokens included.
  • List prices overstate the saving from a new model. Haiku 5.5 is 90% cheaper per token than Haiku 4.5, but Anthropic estimates about 75% cheaper per task.
  • Sonnet 5.5 is the everyday default for well-scoped coding, bug fixes and documents.
  • In Claude Opus vs Sonnet terms, Opus 5.5 earns its premium on hard, long-running work, where fewer retries can offset the higher price.
  • Fable 5.1 is Mythos 5.1 with safeguards. Mythos is restricted to vetted organisations; Fable blocks exploit development and redirects some security and biology work.
  • Caching can cut agent input costs by about three-quarters, leaving output as the bigger cost.
  • Choose by workload. Cost per successful task matters more than price per token.

Quick Navigation


Claude Opus vs Sonnet: four models, four jobs

Anthropic’s model overview positions each model for a different kind of work:

  • Claude Haiku 5.5 (released 7 October 2026) is for “high-volume, latency-sensitive tasks such as classification, extraction, and routing”. Anthropic describes it as its fastest model.
  • Claude Sonnet 5.5 (28 September) is billed as “the best combination of speed and intelligence”.
  • Claude Opus 5.5 (22 September) is for “long-running agentic coding and knowledge work”.
  • Claude Fable 5.1 (1 September) is for “demanding reasoning and long-horizon agentic work”. It’s also for cases where your evaluations of Opus 5.5 at higher effort still fall short.

All four are active and share more than the pricing suggests. Each has a 1-million-token context window, a 128,000-token maximum output, adaptive thinking and a June 2026 knowledge cutoff. The differences are speed, depth of reasoning and price. Opus and Fable have thinking always on; Sonnet and Haiku can run without it.

Claude Opus vs Sonnet: what the API prices reveal

Here are the standard rates from Anthropic’s pricing page:

ModelInputOutputCache read5-minute cache write1-hour cache write
Haiku 5.5 (prompts up to 100K tokens)$0.10$0.50$0.01$0.125$0.20
Haiku 5.5 (prompts over 100K tokens)$0.50$2.50$0.05$0.625$1.00
Sonnet 5.5$2$10$0.10$2.50$4
Opus 5.5$4$20$0.20$5$8
Fable 5.1$10$50$0.25$12.50$20

Opus costs exactly twice Sonnet on every line, caching included. Sonnet’s input and output cost 20 times Haiku’s short-prompt rates. Fable costs 2.5 times Opus. The Batch API halves input and output prices for work that can wait, and US-only inference adds a 10% premium.

For a quick sense of scale, take an illustrative short request: 8,000 input tokens (a file plus instructions) and 2,000 output tokens. Every model here uses the same newer tokenizer, so the same text gives roughly the same count on each.

ModelInput costOutput costTotal
Haiku 5.5$0.0008$0.0010$0.0018
Sonnet 5.5$0.016$0.020$0.036
Opus 5.5$0.032$0.040$0.072
Fable 5.1$0.080$0.100$0.180

At that size, even Fable’s request costs 18 cents. The differences only matter at volume, or when a long-running agent multiplies the calls.

Standard Claude API prices per million tokens. Output costs five times input on every model, and Haiku's rates rise above 100K-token prompts.

Claude Haiku 5.5: why cheap tokens aren’t always cheap tasks

Haiku 5.5 is the most interesting pricing story in the lineup, for two reasons.

The first is the 100,000-token threshold. Up to that size, Haiku costs $0.10 input and $0.50 output. Above it, every token in the request is billed at $0.50 and $2.50, including any cached tokens. Anthropic’s pricing page says a request over the threshold “pays the higher prices even when part of its prompt is a cache hit”.

That creates a cliff. On our arithmetic, a 90,000-token prompt with 2,000 tokens of output costs about $0.010. A 110,000-token prompt with the same output costs about $0.060, six times more for 22% more input. For long-document work, splitting inputs to stay under 100K tokens can matter more than the choice of model. Our comparison of LLM context windows and long-context pricing covers how other providers handle the same trade-off.

The second reason is the tokenizer. Haiku 4.5 was priced at $1 input and $5 output, so Haiku 5.5’s list prices are 90% lower. But Anthropic says the new model costs “around 75% less to run” on average. Two things close the gap.

Anthropic’s token-counting docs say Claude 4.7 and later models use a newer tokenizer that produces about 30% more tokens for the same text. That alone turns a 90% input-price cut into about 87% for the same document. Anthropic’s Haiku 5.5 page adds that the model “uses slightly more tokens per task”, which pushes the average saving down further.

The lesson applies to every model change. Price per million tokens and cost per task are different numbers, and the only reliable way to compare them is to count real prompts against the model you plan to use. The token-counting endpoint is free.

Within those limits, Haiku 5.5 is a large step up. Anthropic reports it scoring 72.4% on its offline subset of OSWorld 2.1, against 15.7% for Haiku 4.5. It suggests using it for summaries, classification, live customer support and as a subagent alongside Opus or Sonnet in coding work.

Claude Opus vs Sonnet for everyday work: where Sonnet 5.5 fits

Sonnet 5.5 kept Sonnet 5’s per-token price but, according to Anthropic, does the work more efficiently. The company says it “generates outputs 30%+ faster than Sonnet 5” and, in its testing, costs “up to 30% less per task”. The saving comes from needing fewer tokens for the same work, not from a lower price, so results will vary by workload.

Anthropic positions it for well-scoped everyday tasks: bug fixing, routine development and polished documents, slides and spreadsheets. It also says Sonnet 5.5 can follow slide templates closely enough that decks need little editing. Effort settings run from low to max. Lower effort answers faster with fewer tokens, which suits routine work.

Anthropic is also clear about where Claude Opus vs Sonnet tips the other way. It says Opus 5.5 “remains clearly stronger” at complex, open-ended work that needs sustained judgment. That’s the honest Claude Opus vs Sonnet line: Sonnet for work you can describe clearly, Opus for work where the model has to figure out what the problem is.

Claude Opus vs Sonnet: when Opus 5.5 is worth twice the price

Opus 5.5 is cheaper than the model it replaced. Its rates are $4 and $20, down from Opus 5’s $5 and $25, and Anthropic says it costs “40% less than Opus 5 on typical workloads” at default settings. That’s Anthropic’s measurement, and it depends on default effort.

In Claude Opus vs Sonnet decisions, paying twice Sonnet’s price makes sense in a few situations:

  • Long-running coding agents working across a large codebase for hours, where one wrong turn wastes everything after it.
  • Complex debugging and architectural changes where the model has to hold many interacting parts in mind.
  • Large migrations and repository analysis. Anthropic cites a tester completing a 680,000-line migration in under a day.
  • Tasks where retries are expensive, because each failed attempt repeats a large context.

The last point is where the economics can flip. If Sonnet needs three attempts at a hard task and Opus needs one, Opus can be cheaper overall. That’s a possibility to test, not a rule: on tasks Sonnet handles first time, Opus simply costs twice as much.

Claude Opus vs Sonnet speed: what Opus Fast Mode changes

Opus 5.5 also offers Fast Mode at $8 input and $40 output, twice the standard rate. Anthropic says it delivers “up to 2.5x higher output tokens per second”. It’s the same model on a faster serving configuration: “no change to intelligence or capabilities”.

The speed-up applies to output generation, “not time to first token”. If a request spends most of its time thinking before it answers, Fast Mode won’t remove that wait. For a long streamed answer, it can. A response that streams for 60 seconds might, at best, finish streaming in about 24, at double the cost. Our analysis of how Claude’s reasoning settings affect response speed found effort level usually matters more than model choice.

Fast Mode has its own rate limits, doesn’t work with the Batch API, and is available on the Claude API, Google Cloud (Anthropic managed) and Microsoft Foundry.

Claude Fable 5.1 and the Mythos connection

Fable 5.1 is the most capable model most developers can use, and the hardest to explain. Anthropic says Fable 5.1 and Claude Mythos 5.1 are “the same model, but with different levels of safeguards”.

Mythos 5.1 isn’t generally available. It’s offered to vetted organisations through trusted access programmes: a Cyber Verification Program for defensive security teams and a Life Sciences Verification Program for researchers. Anthropic says these are currently limited to US organisations, with plans to expand.

Fable 5.1 is the version with safeguards. According to Anthropic’s Fable and Mythos 5.1 announcement, it can identify software vulnerabilities in source code but won’t develop exploits. Penetration testing, exploit generation and binary-based vulnerability scanning are redirected to Opus models. Some life-sciences research questions are also routed to Opus, though Anthropic says biology safeguards now trigger 85% less often on benign questions. Opus 5.5 has its own cyber safeguards: Anthropic says cybersecurity tasks on it are mostly rerouted to Opus 4.8.

So Fable and Mythos share underlying capability but behave differently in deployment. For most coding, research and reasoning work, the safeguards won’t come up. For security work, they will.

At $10 and $50, Fable is 2.5 times the price of Opus. Anthropic’s own guidance is to reach for it when evaluations show Opus 5.5 at higher effort still isn’t good enough. Fable 5.1 did cut its cache-read price by 75% to $0.25, and Anthropic says that lowers typical workload costs by about 25%, and highly agentic ones by up to about 45%.

Claude Opus vs Sonnet: how caching changes the economics

Prompt caching stores a stable part of your prompt, such as a system prompt, tool definitions or a repository snapshot, so later requests can reuse it. You pay a premium to write the cache, 1.25 times the input price for five minutes or twice it for an hour, and then a fraction of the price to read it.

That fraction varies, which is the hidden pricing story in Claude Opus vs Sonnet comparisons. According to Anthropic’s prompt caching docs, cache reads cost 10% of input on Haiku 5.5, 5% on Sonnet and Opus, and 2.5% on Fable. The more expensive the model, the more caching saves in percentage terms.

Here’s an illustrative agent session with assumed numbers. An agent makes 40 calls in a short burst. Each call sends the same 60,000-token repository context plus 3,000 new tokens, and returns 1,500 tokens. With caching, the context is written once to the five-minute cache and read 39 times. For simplicity, the conversation history isn’t growing between calls.

ModelWithout cachingWith cachingOutput’s share of the cached cost
Haiku 5.5$0.28$0.0741%
Sonnet 5.5$5.64$1.2249%
Opus 5.5$11.28$2.4549%
Fable 5.1$28.20$5.5454%

The formula behind it: total API cost = input cost + output cost + cache-write cost + cache-read cost. Caching cut each session by roughly three-quarters. It doesn’t touch output, so after caching, output becomes about half the bill. At that point the model that writes less, or finishes in fewer steps, wins on cost.

Caching won’t help much for one-off prompts or ones that change every time, or when calls are spread out beyond the cache lifetime. It also has a minimum: prompts under 512 tokens on these models aren’t cached.

Claude Opus vs Sonnet: rate limits and throughput

Price isn’t the only constraint in Claude Opus vs Sonnet planning. Anthropic’s rate limits cap requests per minute (RPM), input tokens per minute (ITPM) and output tokens per minute (OTPM) by usage tier:

TierHaiku, Sonnet and Opus 5.5 (each)Fable 5.x
Start4,000 RPM, 2M ITPM, 400K OTPM4,000 RPM, 500K ITPM, 100K OTPM
Build10,000 RPM, 5M ITPM, 1M OTPM10,000 RPM, 1.5M ITPM, 300K OTPM
Scale13,000 RPM, 10M ITPM, 2M OTPM13,000 RPM, 4M ITPM, 800K OTPM

Fable gets a quarter of the others’ token throughput at the Start tier, and its limit is shared between Fable 5.1 and Fable 5. Opus 5.5 and Sonnet 5.5 each have their own budget. A high-volume service could hit Fable’s output ceiling long before its budget.

One useful detail: cache reads don’t count toward input-token limits, so caching raises effective throughput as well as cutting cost. Limits also differ by organisation, so check your actual numbers in the Anthropic Console. Our guide to Claude API rate limits and concurrent request capacity goes deeper into how many parallel sessions those limits allow.

Claude Opus vs Sonnet vs Haiku vs Fable: which model to use

The right Claude Opus vs Sonnet comparison isn’t cost per million tokens. It’s cost per completed task, and ultimately cost per successful production outcome, which includes retries, human review and failures. A cheaper model that needs more attempts can cost more than a dearer one that gets it right.

ModelUse this forWhyCost consideration
Haiku 5.5Classification, routing, extraction, summaries, subagents, simple codeFastest, cheapest per token, strong for its sizeStay under 100K-token prompts, or the whole request costs 5x more
Sonnet 5.5Everyday coding, bug fixes, documents and slides, general agentsBest speed-to-intelligence balance, per AnthropicUsually the default; drop effort for routine work
Opus 5.5Long-running coding agents, complex debugging, architecture, large refactors, hard knowledge workStronger sustained judgment on open-ended tasksTwice Sonnet’s price; justified when it saves retries
Fable 5.1Demanding reasoning, long-horizon agents, complex researchMost capable generally available model2.5x Opus and lower throughput; use when evaluations show Opus isn’t enough
A starting point for choosing a Claude model. Test on your own workload before committing.

Many teams will end up using more than one. A common pattern is Opus or Sonnet planning and checking work while Haiku subagents handle the high-volume steps. Whatever the mix, test on your own workload. When it comes to Claude Opus vs Sonnet, the right answer depends on how often Sonnet gets your hardest tasks right first time.

FAQ

Claude Opus vs Sonnet: what’s the difference?

Opus 5.5 is Anthropic’s model for long-running agentic coding and complex knowledge work, at $4 input and $20 output per million tokens. Sonnet 5.5 is faster and half the price, aimed at everyday development and documents.

Claude Opus vs Sonnet: is Opus 5.5 worth the higher price?

It is for complex, open-ended tasks where it avoids retries. For well-scoped tasks Sonnet handles first time, it just costs twice as much.

Is Claude Haiku 5.5 the cheapest Claude model?

Yes, at $0.10 input and $0.50 output per million tokens for prompts up to 100,000 tokens. Longer prompts are billed at $0.50 and $2.50.

What is the difference between Claude Haiku and Sonnet?

Haiku 5.5 is the fastest and cheapest model, built for high-volume tasks like classification and routing. Sonnet 5.5 handles more complex reasoning and everyday development, at 20 times Haiku’s short-prompt price.

What is Claude Fable 5.1?

Claude Fable 5.1 is Anthropic’s most capable generally available model, priced at $10 input and $50 output per million tokens. It shares its underlying model with Mythos 5.1 but adds cybersecurity and biology safeguards.

Is Claude Mythos 5.1 publicly available?

No. Mythos 5.1 is available only to vetted organisations through Anthropic’s cyber and life-sciences verification programmes, which are currently limited to US organisations.

Does Claude Haiku charge more for long prompts?

Yes. If a Haiku 5.5 prompt exceeds 100,000 tokens, the entire request is billed at $0.50 input and $2.50 output, cached tokens included.

How much does Claude prompt caching save?

Cache reads cost 10% of the input price on Haiku 5.5, 5% on Sonnet and Opus 5.5, and 2.5% on Fable 5.1. Caching doesn’t reduce output costs, so total savings depend on how much context you reuse.

What is Claude Opus Fast Mode?

Fast Mode runs Opus 5.5 on a faster serving setup for up to 2.5x higher output speed, at twice the standard price. It doesn’t shorten time to first token or change the model’s intelligence.

Claude Opus vs Sonnet: which is best for coding?

Sonnet 5.5 suits most everyday coding and bug fixing. Opus 5.5 is better for long-running agents, large refactors and hard debugging, according to Anthropic.


Keep reading

AGI vs superintelligence

AGI vs Superintelligence: A New Name Isn’t a New Intelligence

Facts checked against official documents and reporting on 18 November 2026. On 29 September, the White House told federal agencies to stop writing “artificial intelligence” …
AI Coding Agent

AI Coding Agents Are Getting Expensive. Who’s Paying for the Tokens?

Pricing checked on official vendor pages on 17 November 2026. All USD. Cost scenarios are illustrative and labelled as such. On 28 October, TechCrunch published …
Model Weights

Verify Model Weights: 7 Checks Before You Download

Checked against the burner22/numbat repository and its discussions, Hugging Face and PyTorch documentation, and Moonshot AI’s announcement on 2 November 2026. On 1 November, a …
Agentic AI Statistics

30 Agentic AI Statistics for 2026: Adoption, Spending and Risk

Last updated: 15 November 2026. This page is updated monthly; each figure keeps its original publication date. Agent traffic at one healthcare booking platform rose …

LLM Cost per Task: How to Calculate the Real API Cost

LLM cost

Prices checked 28 October 2026: standard (pay-as-you-go) API tier, US dollars per million tokens, from each provider’s official pricing page unless stated otherwise.

Kimi K3.1 Pro costs half as much per token as Claude Opus 5.5: $2 per million input tokens and $10 per million output tokens, against $4 and $20. On Artificial Analysis’s Intelligence Index runs, Kimi still cost more per task: $2.11 against $1.82 for Opus 5.5 at High effort. It produced 55,000 output tokens per task to Opus’s 36,000.

That’s the mistake a price table invites. A per-token rate tells you what one unit of text costs. It doesn’t tell you how many units a model will spend on your job, or how often the job comes back usable. LLM cost per task captures both.

LLM cost per task is the total API spend on every attempt at a set of tasks, divided by the number of attempts that met your acceptance criteria.

The rest of this article is about calculating that number correctly, and about knowing when to trust it.

Key Takeaways
  • Price per token and cost per task can rank models in opposite orders. Kimi K3.1 Pro is half Opus 5.5’s per-token price but cost about 16% more per Artificial Analysis task.
  • Reasoning tokens are billed as output by OpenAI, Anthropic and Google, even when you never see them. Anthropic also bills earlier turns’ thinking as input on its newest models.
  • Caching can swing the bill several-fold. In one public test, a broken cache made a single run cost $17.60 instead of $2.62.
  • Divide by successes, not attempts. Failed runs cost money and produce nothing.
  • Twenty runs can’t separate close results. An 80% and a 65% pass rate from 20 runs each have overlapping confidence intervals.
  • Price changes can settle a close call. One developer test found Gemini 4 Argon roughly level with Opus 5.5 per successful fix. At Argon’s December 1 prices, it would cost about twice as much.

Quick Navigation


The LLM cost per task formula

For one attempt, the API cost is the sum of each token category times its rate, with token counts converted to millions:

Attempt cost = (fresh input tokens  ÷ 1,000,000 × fresh-input rate)
             + (cache-read tokens   ÷ 1,000,000 × cache-read rate)
             + (cache-write tokens  ÷ 1,000,000 × cache-write rate)
             + (billable output     ÷ 1,000,000 × output rate)
             + per-call charges (web search, code containers, grounding)

Then, across a test set:

LLM cost per successful task = sum of all attempt costs ÷ number of successful attempts
LLM cost

Each line has its own billing rules, and they differ by provider. This is the buyer’s cost. What it costs a provider to serve those tokens, and its margin, is a separate question, covered in what inference actually costs per token.

What each line costs at OpenAI, Anthropic and Google
Line itemOpenAI (GPT-5.6 and later)Anthropic (Claude 5.5 models)Google (Gemini 4 Argon)
Fresh inputList rateList rateList rate
Cache read0.1× input; 0.05× on GPT-6.1 Sol and Terra0.1× input; 0.05× on Opus 5.5 and Sonnet 5.5$0.10 per million (0.05× input)
Cache write1.25× input (30-minute) or 2.5× (12-hour)1.25× input (5-minute) or 2× (1-hour)No separate charge listed; caching is implicit only
Reasoning tokensBilled as outputBilled as output, including when thinking text is hiddenBilled as output (“incl. thinking”)
Search tools$10 per 1,000 web searches$10 per 1,000 web searches$14 per 1,000 grounded queries after 5,000 free a month

Sources: OpenAI pricing and prompt caching; Anthropic pricing and prompt caching; Gemini API pricing.

Two details catch people out. Anthropic’s thinking defaults to a display mode of “omitted” on Opus 5.5 and Sonnet 5.5, but its thinking documentation is explicit: “You’re still charged for the full thinking tokens. Omitting reduces latency, not cost.” On those models, previous turns’ thinking blocks also stay in context and are billed as input, so a long agent session pays for old reasoning again on every turn.

Reading usage fields without double-counting

A common error in home-made calculators is adding a field that already contains another one.

  • Anthropic: input_tokens counts only the tokens after the last cache breakpoint. Total input is cache_read_input_tokens + cache_creation_input_tokens + input_tokens, and each part takes its own rate.
  • OpenAI: cached_tokens excludes tokens charged as writes, which appear in cache_write_tokens. Reasoning tokens sit inside output_tokens, under output_tokens_details.reasoning_tokens. Don’t add them again.
  • Truncated responses: with reasoning models, a request that hits its output limit can bill input and reasoning tokens and return no visible answer, as OpenAI’s reasoning guide warns. That attempt still counts toward the cost.

Then reconcile your summed usage against the provider’s invoice for the same period. In July 2026, developers on OpenAI’s forum reported that GPT-5.6 output-token counts were several times higher than the text actually generated. OpenAI didn’t publicly confirm a defect in that thread. Whatever happened there, the invoice is the figure your finance team will pay.

From cost per attempt to LLM cost per successful task

The numerator is everything you paid to get results. That includes failed attempts, automatic retries, intermediate calls inside an agent loop, any model you use as a judge and per-call tool fees. Count each API call once, at the moment it happens. If your harness logs both an agent step and its parent run, sum only one of them.

The denominator is the number of attempts that passed a fixed acceptance test, written before the run. “The tests pass” is a test. “The output looked fine” is not. The same criteria must apply to every model, or the division compares different jobs.

There are two valid ways to define a task:

  • Independent attempts. Each run is scored on its own, which is what most benchmark-style comparisons do.
  • Tasks with a retry policy. A task succeeds if any attempt within, say, three tries passes. Then the cost per task is all spend divided by tasks completed. That matches production better, but pick one definition and use it for every model.

API cost is not the whole bill. Human review, retrieval infrastructure, observability and sandboxes belong in a fully loaded cost per task whenever models differ in how much of that work they create. A model whose failures are obvious and cheap to discard can beat one whose failures look plausible and need a reviewer to catch.

A public test: 20 runs, four models

On 14 October 2026, a developer writing at paddo.dev replayed six merged changes from a production monorepo against four models. Each model got 20 runs (three or four per change) at medium effort in the Claude Code harness. Gemini 4 Argon was routed through OpenRouter. A run passed if the tests that shipped with the original fix passed. Costs were calculated at list prices.

ModelRunsPassing runsTotal costCost per runCost per passing run
Gemini 4 Argon2016$57.68$2.88$3.61
Claude Opus 5.52013$45.81$2.29$3.52
Claude Sonnet 5.52011$11.76$0.59$1.07
GPT-6.1 Sol2011$6.73$0.34$0.61

The totals and pass counts come from the post. The last two columns are our arithmetic, and they check: $57.68 ÷ 16 = $3.605, and $45.81 ÷ 13 = $3.524.

Argon and Opus are close, nine cents apart per passing run. Argon’s per-token prices matched Sonnet 5.5’s at the time ($2 input, $10 output), yet it cost five times as much as Sonnet per run. It wrote 1.37 million output tokens across the 20 runs, 2.8 times as many as Opus.

GPT-6.1 Sol had the lowest cost per passing run, but the post also records five Sol runs that broke a previously passing test, against none for the others. It doesn’t say whether those runs are among Sol’s 11 passes. If “breaks nothing” is part of your acceptance test, Sol’s denominator may shrink, which is why the test has to be written down before anyone divides.

How much a 20-run test can tell you

Not much, at the margin. A 95% Wilson confidence interval on 16 passes out of 20 is about 58% to 92%; for 13 out of 20, about 43% to 82%. The ranges overlap heavily, so a rerun could reverse the order. And six changes from one codebase, with correlated runs on each change, say little about a different stack.

What the December repricing does

Google’s pricing page doubles every Argon token rate on 1 December 2026: input from $2 to $4, cached input from $0.10 to $0.20, output from $10 to $20. If the runs used identical tokens, Argon’s total would become $115.36, or $7.21 per passing run, about twice Opus’s $3.52. We covered the change itself in Gemini 4 Argon pricing doubles Dec 1.

A simple break-even check shows how far the decision moves. One model is cheaper per success than another when its pass rate exceeds the other’s pass rate multiplied by the ratio of their per-attempt costs. Before December, Argon needed a pass rate above 65% × 1.26 ≈ 82% to beat Opus; it scored 80%. After December, it would need 65% × 2.52 ≈ 164%, which is impossible. Even at the bottom of Opus’s confidence interval, Argon would lose. On this test, the price change settles a question the sample size couldn’t.

How caching and reasoning change LLM cost per task

The same post found a stark caching failure. The first Argon run cost $17.60 because it read 8.4 million input tokens and only 59,000 came from cache. The harness inserted system messages that changed the prompt prefix on every call, so Gemini’s implicit cache never matched. After a fix, the same run cost $2.62, with 94% of input served from cache.

The second example is illustrative. The token counts and pass rates are assumptions, not measurements of any real model. Two models attempt the same agent task:

  • Model X: $1 input, $0.05 cache read, $1.25 cache write, $5 output, per million tokens. Pass rate 60%.
  • Model Y: $4 input, $0.20 cache read, $5 cache write, $20 output. Pass rate 85%.
  • Each attempt sends 300,000 input tokens over its turns. When caching works, 270,000 are cache reads and 30,000 are cache writes.
  • Model Y produces 20,000 output tokens per attempt, including reasoning. Model X produces 60,000.
ScenarioCost per attemptPass rateCost per successful task
Model X, cache broken (all 300,000 input tokens fresh)$0.60060%$1.00
Model X, cache working$0.35160%$0.585
Model X, cache working, reasoning doubles to 120,000 output tokens$0.65160%$1.085
Model Y, cache working$0.60485%$0.711

The calculation for the second row: 270,000 × $0.05 + 30,000 × $1.25 + 60,000 × $5, each divided by one million, gives $0.0135 + $0.0375 + $0.30 = $0.351. Dividing by 0.60 gives $0.585.

LLM cost

With caching working, the cheaper model wins. Break the cache, or let it reason twice as long, and the expensive model wins instead. Neither change shows up in a price table.

What published comparisons actually measured

Before using a published cost-per-task figure, check the effort setting, what counted as a task, and whether success was part of the number.

  • Effort settings. Put Gemini 4 Argon’s 36,000 reasoning tokens per task next to Opus 5.5’s 84,000, and Argon looks far leaner. Both figures appear on Artificial Analysis, but they come from different settings: Argon at High effort and Opus 5.5 at Max. At matched High effort, the comparison reverses: Argon used 36,000 reasoning tokens per task to Opus’s 18,000, and 62,000 output tokens in total to Opus’s 36,000. Argon still cost less per task, $1.62 against $1.82, because its tokens were half the price at the time.
  • Vendor claims. OpenAI launched GPT-6.1 Terra on 26 October at $1 input and $5 output. DataCamp’s write-up of the announcement says that at max effort Terra is over three times as token-efficient as Opus 5.5 and a quarter of the price per token, and it puts the combined effect at “9x lower cost per task”, attributed to OpenAI. No benchmark is named, and we couldn’t open OpenAI’s post to check. Three times the efficiency at a quarter of the price would multiply to about 12 times, not 9, so the figure depends on a token breakdown that hasn’t been published. Treat it as a vendor claim to test, not a result.
  • Cost per task is not cost per success. Artificial Analysis computes cost per task from token counts at list prices. It doesn’t divide by how many answers were right. A model that is cheaper per task but scores lower may still cost more per correct answer. As we argued in why benchmark scores don’t transfer to your workload, these numbers are good for building a shortlist, not for making the final decision.

How to measure LLM cost per task on your own workload

  1. Pick 30 to 50 real tasks from production traffic, covering easy, typical and hard cases. More tasks beat more runs of the same task.
  2. Write the acceptance test first: unit tests, a schema check or a fixed-judge rubric, identical for every model.
  3. Fix the configuration: prompts, tools, effort setting, context limits and retry policy.
  4. Log raw usage for every call, including retries and sub-agents, with each token field stored separately.
  5. Price the logs offline against a dated copy of each pricing page, so you can reprice them when rates change.
  6. Check cache hit rates per model. A low rate in a repetitive session usually means the prompt prefix changes between calls.
  7. Reconcile with the invoice for the test window.
  8. Report ranges: pass rate with a confidence interval, cost per attempt, cost per successful task and latency.

Run at least two attempts per task. That shows whether failures are random or the same task fails every time.

A decision rule for LLM cost per task

Compare models on cost per successful task, after deciding what a success is worth. Then apply three checks.

  • If the confidence intervals on pass rate overlap, treat the models as tied on quality and choose on cost per attempt, latency and operational fit.
  • If one model’s cost per attempt is k times another’s, it needs a pass rate more than k times higher to win. When that would take a pass rate above 100%, stop testing.
  • If a success is worth far more than the API cost, as with a merged fix that saves an engineer an hour, pass rate and reviewer time outweigh token prices. Optimise for the fewest failures, then for cost.

Per-token prices still have a job. They tell you where to look first. LLM cost per task tells you what you’ll actually pay.

Frequently asked questions

What is LLM cost per task?

It is the total API spend on all attempts at a set of tasks, divided by the number of attempts that met a fixed acceptance test. Failed attempts, retries, intermediate agent calls and judge-model calls stay in the total, because you paid for them. A broader, fully loaded version adds review time and infrastructure.

How do I calculate LLM API cost for one request?

Multiply each token category by its rate per million tokens: fresh input, cache reads, cache writes and output, including reasoning. Then add per-call tool fees such as web search. Take the counts from the response’s usage object, and check that one field doesn’t already include another before adding them.

Are reasoning tokens billed?

Yes. OpenAI, Anthropic and Google bill reasoning or thinking tokens at the output rate, even when the reasoning text isn’t returned. On Anthropic’s Opus 5.5 and Sonnet 5.5, previous turns’ thinking blocks are also billed as input when they stay in the conversation.

How much does prompt caching save?

Cache reads cost between 5% and 10% of the input rate at OpenAI, Anthropic and Google for current models. OpenAI and Anthropic charge 1.25 times the input rate or more to write to the cache. Savings depend on how much of each request repeats an earlier prefix, so measure the hit rate rather than assuming it.

Is the cheapest model per token ever the cheapest per task?

Often, yes. On Artificial Analysis’s figures, Gemini 4 Argon at High effort cost less per task than Opus 5.5 at High, while its tokens were half the price. The ranking flips when the cheaper model uses many more tokens, misses the cache or fails more often. Only measurement on your own tasks tells you which case you’re in.


Keep reading

AGI vs superintelligence

AGI vs Superintelligence: A New Name Isn’t a New Intelligence

Facts checked against official documents and reporting on 18 November 2026. On 29 September, the White House told federal agencies to stop writing “artificial intelligence” …
AI Coding Agent

AI Coding Agents Are Getting Expensive. Who’s Paying for the Tokens?

Pricing checked on official vendor pages on 17 November 2026. All USD. Cost scenarios are illustrative and labelled as such. On 28 October, TechCrunch published …
Model Weights

Verify Model Weights: 7 Checks Before You Download

Checked against the burner22/numbat repository and its discussions, Hugging Face and PyTorch documentation, and Moonshot AI’s announcement on 2 November 2026. On 1 November, a …
Agentic AI Statistics

30 Agentic AI Statistics for 2026: Adoption, Spending and Risk

Last updated: 15 November 2026. This page is updated monthly; each figure keeps its original publication date. Agent traffic at one healthcare booking platform rose …

Is Claude Faster Than ChatGPT? What the 2026 Benchmarks Show

Claude vs ChatGPT

Benchmarks read from Artificial Analysis on 27 October 2026. UniverseBlend did not run its own timing tests for this article.

Ask a hard question of Claude Opus 5.5 at its maximum effort setting through Anthropic’s API, and the first word of the answer can take more than eleven minutes to arrive. Artificial Analysis recorded a median of 688 seconds on its standard 10,000-token workload. Once the answer starts, it streams at about 96 tokens per second, faster than most of the field. The model is quick to write and very slow to begin.

That gap is the whole story of Claude vs ChatGPT speed. In independent API tests, Claude’s models usually generate text faster than OpenAI’s at comparable settings. At matched effort, Claude Sonnet 5.5 also starts answering sooner than OpenAI’s GPT-6.1 Sol, by 1.2 seconds against 2.9 at the lowest setting. But change the effort level, or compare the budget models, and the faster starter switches sides.

So is Claude faster than ChatGPT? At matched mid-tier settings, yes, by a clear margin. In general, the honest answer is that the reasoning setting you pick moves response time far more than the brand does.

Key Takeaways
  • Time to first token, not tokens per second, dominates total response time for any reasoning-heavy request: at high effort and above, over 70% of a 500-token response is spent waiting.
  • At matched effort, Claude Sonnet 5.5 beat GPT-6.1 Sol on both start time and generation speed at all five levels Artificial Analysis tests.
  • The budget tiers flip it: GPT-6 Luna (Low) starts in 2.1 s against Claude Haiku 5.5 (Low) at 6.7 s, and finishes first on any answer under about 1,360 tokens.
  • The same model can start in about 1 second or about 11 minutes depending on effort, so check the setting before blaming the model.
  • Benchmark medians shift by 10–15% between page loads on the same day. Measure your own prompts before choosing.

Quick Navigation


Claude vs ChatGPT speed: what are we actually measuring?

Claude vs ChatGPT

“Speed” bundles at least six different measurements. Comparisons that quote one and imply another are where most of the confusion comes from.

MetricWhat it measuresHow Artificial Analysis defines it
Time to first token (TTFT)Wait from sending a request to receiving the first tokenIncludes network latency; for reasoning models, the first reasoning token if one is streamed
Time to first answer tokenWait until the first token of the actual answerMeasured after any thinking time
Output speedTokens per second once generation has startedAverage after the first token arrives
End-to-end response timeRequest to complete answerInput processing + thinking + time to produce 500 answer tokens
Reasoning latencyTime spent thinking before or between visible outputNot reported separately; folded into the two figures above
Perceived responsivenessWhen the interface first shows something usefulNot measured; depends on the app

Definitions from the Artificial Analysis performance methodology. It reports the median of the past 72 hours, measured about every three hours from a server in Google Cloud’s us-central1 region, with a 10,000-token prompt as the default workload.

There’s a detail that changes how to read every figure in this article. For Claude Opus 5.5, Sonnet 5.5, GPT-6.1 Sol and GPT-6 Luna, Artificial Analysis lists identical values for time to first token and time to first answer token. Neither provider streams raw reasoning to the client by default. Anthropic’s docs say Claude 5.5 models default to display: "omitted", which skips streaming thinking tokens entirely. OpenAI’s say reasoning tokens are “not visible via the API”. So for these models, “time to first token” really means “time spent thinking, plus a little”.

A simple latency formula

For a streamed response, total time is approximately:

Ttotal≈Tfirst+NremainingRT_{total} \approx T_{first} + \frac{N_{remaining}}{R}

Here T_first is the wait for the first visible token, N_remaining the number of answer tokens still to come, and R the output speed in tokens per second. This is exactly how Artificial Analysis derives its end-to-end figure: Sonnet 5.5 (Low) at 1.17 s plus 500 tokens at 108.9 tokens per second gives the 5.76 s it reports.

The formula ignores tool calls, retries, queueing spikes and the uneven, chunky streaming Anthropic warns about when thinking is on. It still explains most of what users notice, because one of its two terms usually dwarfs the other.

Claude vs ChatGPT speed: what the latest benchmarks show

The fairest comparison available pairs Claude Sonnet 5.5 with GPT-6.1 Sol. They launched within a week of each other in September 2026, cost the same per token ($2 input, $10 output), and Artificial Analysis tests both at the same five effort levels on each provider’s own API.

EffortSonnet 5.5 TTFTGPT-6.1 Sol TTFTSonnet 5.5 output speedGPT-6.1 Sol output speedSonnet 5.5 end-to-endGPT-6.1 Sol end-to-end
Low1.17 s2.86 s109 tok/s43 tok/s5.8 s14.5 s
Medium1.80 s4.90 s108 tok/s45 tok/s6.4 s16.0 s
High12.15 s69.02 s109 tok/s58 tok/s16.8 s77.6 s
Xhigh31.59 s163.06 s112 tok/s53 tok/s36.1 s172.6 s

Source: Artificial Analysis comparison pages for Low, Medium, High and Xhigh, read 27 October 2026. Medians of the past 72 hours; 10,000-token input; first-party APIs. Sonnet variants run with Anthropic’s default fallback enabled.

On this pairing, Claude wins every row: it starts 2.4 to 5.7 times sooner and generates 1.9 to 2.5 times faster. That’s a clean result, but not a complete one. Sonnet 5.5 also writes more. On the same benchmark tasks it produced 14,000 output tokens per task at Low against GPT-6.1 Sol’s 4,000. Faster tokens partly pay for more of them. Artificial Analysis’s estimate of generation time per task (output tokens, thinking included, divided by output speed) puts the two close together: 82 s for Sonnet 5.5 against 93 s for GPT-6.1 Sol at Low.

Other pairings tell different stories:

Pairing (same page)Claude TTFTOpenAI TTFTClaude speedOpenAI speed
Opus 5.5 (Max) vs GPT-6.1 Sol (Max)688.0 s242.2 s96 tok/s62 tok/s
Opus 5.5 (Low) vs GPT-6.1 Sol (Low)8.97 s2.67 s81 tok/s51 tok/s
Haiku 5.5 (Low) vs GPT-6 Luna (Low)6.68 s2.14 s176 tok/s111 tok/s
Sonnet 5.5 (Max) vs GPT-6 Luna (Max)461.9 s93.8 s141 tok/s127 tok/s

Sources: Artificial Analysis comparisons for Opus vs Sol Max, Opus vs Sol Low, Haiku vs Luna Low and Sonnet vs Luna Max, read 27 October 2026.

Across every pairing in these tables, Claude generates faster. Which model starts sooner depends on the pairing. Notice too that GPT-6.1 Sol (Low) read 2.67 s and 51 tokens per second on one page and 2.86 s and 43 tokens per second on another the same day. These are rolling medians, and a 10% gap between two models in a single snapshot is not a result. Public leaderboards have other blind spots too, which we covered in why benchmark scores fail to predict production.

Claude vs ChatGPT speed: why reasoning settings change the result

Every current flagship from both companies reasons before it answers, and both let you set how hard. Anthropic’s Claude API offers five effort levels, Low through Max. Opus 5.5 and Haiku 5.5 default to Medium, Sonnet 5.5 to High. OpenAI’s reasoning effort runs from none to max; GPT-6.1 Sol doesn’t support none or minimal and defaults to Medium.

The effect on waiting time is enormous, and it dwarfs the gap between brands:

Claude Opus 5.5LowMediumHighMax
Time to first token8.97 s10.44 s21.55 s688.0 s
Output speed81 tok/s84 tok/s81 tok/s96 tok/s

Read from Artificial Analysis on 27 October 2026 (Opus Medium vs High, GPT-6 Sol Low vs Max).

Opus 5.5 waits 77 times longer at Max than at Low, while its output speed barely moves. OpenAI’s GPT-6 Sol, the model behind ChatGPT’s Instant mode, shows the same shape: 1.59 s to first token at Low, 132.5 s at Max. That’s the central argument in one row: effort changes how long a model thinks, not how fast it types.

Two cautions keep this honest. First, Anthropic’s thinking is adaptive: at Medium and below, Claude may skip thinking on a simple question, so a quick factual query can start much faster than a 10,000-token benchmark prompt suggests. OpenAI likewise says lower effort favours speed. Second, the two companies’ effort scales are separate designs. “High” on one isn’t calibrated to “High” on the other, so matched-effort tables compare labels, not identical amounts of thought. Capability differs by level too: GPT-6.1 Sol scores higher on Artificial Analysis’s Intelligence Index than Sonnet 5.5 at Low and Medium (42 against 36, 48 against 41), while Sonnet 5.5 leads at Xhigh (52 against 51).

Both providers also sell a paid speed boost. Anthropic’s fast mode promises up to 2.5 times higher output speed on Opus 5.5 at double the price, and says explicitly that it doesn’t shorten time to first token. OpenAI’s fast mode, formerly priority processing, claims up to 2.5 times faster speeds on supported models. Neither fixes the thinking wait.

A fair Claude vs ChatGPT speed test

UniverseBlend didn’t run its own timing tests for this article, so there’s no results table here. What follows is the protocol we’d use, and that you can run.

  1. Pick matched pairs by job, not by brand. Sonnet 5.5 against GPT-6.1 Sol is the closest current pairing on price and release date. Name the effort level for both, and don’t rely on defaults, which differ.
  2. Fix the prompts. Use 20 to 50 real prompts from your workload, identical across models, with the same requested output length.
  3. Stream everything. Record send time, first answer token and last token on the client, using a monotonic clock.
  4. Record the provider’s token counts, not a local tokenizer’s. Claude and OpenAI tokenize differently, so tokens per second aren’t directly comparable across providers. Characters or words per second are a useful cross-check.
  5. Repeat and spread across the day. At least five runs per prompt per model, at different hours. Report the median and the 90th percentile.
  6. Same machine, same region, warm connections. Run both from one client in one cloud region and reuse HTTP connections.
  7. Log failures. Rate limits, 529 overload errors, retries and timeouts are part of speed. Don’t silently drop them.
  8. Keep prompts unique per run, or account for caching. Repeated prefixes can be cached, which cuts processing time and cost.

The main limitation of the public data is the workload: Artificial Analysis uses generated prompts of about 10,000 tokens, which provoke more thinking than a short chat message does. Its numbers are a fair way to compare models on that workload. They won’t tell you your own app’s latency.

Why the fastest model may not feel the fastest

The formula has a consequence that surprises people: a model that starts sooner can lose to a faster generator once the answer gets long enough, and the reverse.

Take the budget tiers. GPT-6 Luna (Low) starts in 2.14 s and generates 111 tokens per second. Claude Haiku 5.5 (Low) starts in 6.68 s but generates 176. Solve for where their total times meet and you get about 1,360 tokens. Below that length, Luna finishes first; above it, Haiku does. A one-paragraph answer favours Luna by several seconds. A long report favours Haiku.

A closer case: Sonnet 5.5 (Low) at 1.17 s and 109 tokens per second against GPT-6 Sol (Low) at 1.59 s and 119 tokens per second. Sonnet shows its first word 0.4 s sooner, and GPT-6 Sol overtakes it after about 540 tokens. Neither difference is one a person would notice. That’s the point: on short interactive turns at low effort, both companies’ fast models start within two seconds, and the choice should be made on quality.

How it feels depends on the job:

  • Everyday questions. Answers are short, so time to first token is nearly the whole experience. Two seconds feels instant; twenty does not.
  • Summarisation. A long document means heavy input processing before anything appears. Generation speed matters less than how quickly the model gets through the input.
  • Coding. People read code as it streams, so a fast start with steady output feels quick even if the full file takes a minute. A model that thinks for two minutes and then dumps the file feels slow even if total time is similar.
  • Research. Users expect to wait. Perceived speed comes from progress signals, not tokens per second.

The apps add their own layer. OpenAI’s ChatGPT help centre says that with its “Intelligent UI” a response may begin while ChatGPT is still thinking. Anthropic’s Claude help centre says thinking can’t be turned off on its 5.5 models, and that higher effort means longer response times. Neither company publishes app latency figures, so app speed can’t be compared from public data.

Claude vs ChatGPT speed: which is better for your workload?

Claude vs ChatGPT

No workload has a universal winner. The table shows which metric to watch and what the current public data does and doesn’t support.

WorkloadMetric that matters mostWhat public data shows (27 Oct 2026)
Short questionsTime to first token at low or medium effortSonnet 5.5 starts 2.4 to 2.7x sooner than GPT-6.1 Sol at Low and Medium; GPT-6 Sol (Low) starts in 1.6 s, close to Sonnet
Long-form writingOutput speedClaude was faster in every matched pairing read; GPT-6 Sol (Low) slightly outpaced Sonnet 5.5 (Low)
Coding and debuggingTotal time per task, plus correctnessNo coding-specific latency data; on Artificial Analysis’s mixed task set at High, estimated generation time per task is 215 s for Sonnet 5.5 against 229 s for GPT-6.1 Sol, close because Sonnet writes more
Deep researchEnd-to-end time including tool callsNo comparable public data; tool latency dominates
Long-context analysisTime to first token at 100k+ inputNot covered by the figures read here; measure it
Agentic workflowsPer-call TTFT multiplied by number of callsNo public end-to-end agent latency comparison
Low-latency API apps90th-percentile TTFT at low effortBudget tier: GPT-6 Luna (Low) 2.1 s against Haiku 5.5 (Low) 6.7 s
High-throughput appsOutput speed under concurrencyHaiku 5.5 (Low) 176 tok/s single-stream; concurrent results not read

Agent workloads deserve a note. An agent that makes ten sequential model calls pays the time-to-first-token cost ten times, so a model that thinks for 12 seconds per call adds two minutes before any tool even runs. Our explainer on how AI agents work and what they cost shows how quickly call counts multiply. For agents, effort per call is usually a bigger lever than model choice.

How to measure AI response speed yourself

The public numbers describe one workload from one data centre. Yours will differ, and measuring it takes an afternoon. These two functions time a streamed response on each provider’s official Python SDK and return time to first answer token, total time, and visible output tokens.

import time
import anthropic
from openai import OpenAI

claude = anthropic.Anthropic()
oai = OpenAI()

def time_claude(prompt, model="claude-sonnet-5-5", effort="medium"):
    t0 = time.perf_counter()
    first = None
    with claude.messages.stream(
        model=model,
        max_tokens=8000,
        output_config={"effort": effort},
        messages=[{"role": "user", "content": prompt}],
    ) as stream:
        for event in stream:
            if (first is None and event.type == "content_block_delta"
                    and event.delta.type == "text_delta"):
                first = time.perf_counter()
        msg = stream.get_final_message()
    end = time.perf_counter()
    u = msg.usage
    thinking = getattr(getattr(u, "output_tokens_details", None), "thinking_tokens", 0) or 0
    return first - t0, end - t0, u.output_tokens - thinking

def time_openai(prompt, model="gpt-6.1-sol", effort="medium"):
    t0 = time.perf_counter()
    first, usage = None, None
    stream = oai.responses.create(
        model=model,
        input=prompt,
        reasoning={"effort": effort},
        stream=True,
    )
    for event in stream:
        if first is None and event.type == "response.output_text.delta":
            first = time.perf_counter()
        elif event.type == "response.completed":
            usage = event.response.usage
    end = time.perf_counter()
    reasoning = usage.output_tokens_details.reasoning_tokens
    return first - t0, end - t0, usage.output_tokens - reasoning

Generation speed is then visible tokens ÷ (total time − time to first token). A few caveats before trusting the numbers:

  • Billing counts include thinking. Both providers count reasoning tokens in output_tokens, so subtract them, as above, or you’ll inflate tokens per second.
  • Tokens differ across providers. Each uses its own tokenizer, so also compare characters per second.
  • Defaults differ. Set effort explicitly. Sonnet 5.5 defaults to High on the API and GPT-6.1 Sol to Medium.
  • First text isn’t always first output. A tool call or empty response leaves first unset; handle that case.
  • Variance is the point. Run each prompt at least five times across the day and report the median and 90th percentile. Queueing near capacity hits tail latency first, as our piece on accelerator utilisation explains.

Conclusion

Is Claude faster than ChatGPT? On the closest like-for-like API pairing, Claude Sonnet 5.5 against GPT-6.1 Sol at the same effort, yes: it started answering 2.4 to 5.7 times sooner and streamed roughly twice as fast in Artificial Analysis’s tests. Across every pairing read here, Claude’s models also generated tokens faster.

That isn’t the same as “Claude responds faster”. At maximum effort, Opus 5.5 kept users waiting 688 s against GPT-6.1 Sol’s 242 s. In the budget tier, GPT-6 Luna started three times sooner than Haiku 5.5. And the consumer apps add routing, interface and default settings that no public benchmark measures.

What the evidence supports, firmly, is the order of importance: effort setting first, model tier second, brand a distant third. Before you choose, time your own prompts at the effort level you’d actually ship, and watch time to first token before tokens per second.

Frequently asked questions

Is Claude faster than ChatGPT in 2026?

On matched API settings, usually yes. Claude Sonnet 5.5 started answering sooner and generated faster than GPT-6.1 Sol at every effort level in Artificial Analysis’s October 2026 data. At maximum effort, and between the budget models, OpenAI’s models started sooner. App speed isn’t publicly benchmarked.

Why does Claude sometimes take longer to start answering?

Because it’s thinking first. Claude’s 5.5 models reason adaptively, and their API hides that thinking by default, so nothing appears until the answer begins. Higher effort means more thinking: Opus 5.5 took about 9 seconds to start at Low and 688 seconds at Max on the benchmark workload.

What is time to first token?

It’s the time between sending a request and receiving the first token of the response, including network delay. When a model hides its reasoning, as both Claude and OpenAI’s models do by default, it effectively measures thinking time plus a small overhead.

Is a higher tokens-per-second score always better?

No. Tokens per second only describes speed after output starts. For short answers, the wait before the first token matters more. Haiku 5.5 (Low) generates far faster than GPT-6 Luna (Low), yet Luna finishes first on any answer under about 1,360 tokens.

Does extended thinking make Claude or ChatGPT slower?

Yes, for both. Thinking time is added before the answer appears. GPT-6 Sol’s time to first token rose from 1.6 seconds at Low effort to 133 seconds at Max. Both companies say lower effort favours speed and suits chat and latency-sensitive work.

Which is faster for coding: Claude or ChatGPT?

There’s no public coding-specific latency comparison. On Artificial Analysis’s mixed task set at High effort, which includes coding, estimated generation time per task is close: 215 seconds for Sonnet 5.5 against 229 for GPT-6.1 Sol, because Sonnet generates faster but writes more. Measure your own repository’s tasks, and judge correctness alongside time.

How can I measure Claude and ChatGPT response times myself?

Stream responses through each official SDK and record when you send the request, when the first answer text arrives and when the stream ends. Use identical prompts, set effort explicitly, repeat each test at least five times, and subtract reasoning tokens before calculating tokens per second.

Does API latency differ from the speed of the ChatGPT or Claude apps?

Yes. Apps choose models and default settings for you, may route between modes, and add interface features such as showing a response while the model is still thinking. Neither company publishes app latency figures, so API benchmarks are a guide to the models, not the apps.


Keep reading

AGI vs superintelligence

AGI vs Superintelligence: A New Name Isn’t a New Intelligence

Facts checked against official documents and reporting on 18 November 2026. On 29 September, the White House told federal agencies to stop writing “artificial intelligence” …
AI Coding Agent

AI Coding Agents Are Getting Expensive. Who’s Paying for the Tokens?

Pricing checked on official vendor pages on 17 November 2026. All USD. Cost scenarios are illustrative and labelled as such. On 28 October, TechCrunch published …
Model Weights

Verify Model Weights: 7 Checks Before You Download

Checked against the burner22/numbat repository and its discussions, Hugging Face and PyTorch documentation, and Moonshot AI’s announcement on 2 November 2026. On 1 November, a …
Agentic AI Statistics

30 Agentic AI Statistics for 2026: Adoption, Spending and Risk

Last updated: 15 November 2026. This page is updated monthly; each figure keeps its original publication date. Agent traffic at one healthcare booking platform rose …

Four Labs, One Evaluator: Anatomy of an AI Evaluation Sandbox Failure

AI evaluation sandbox failure

In May 2026, a Gemini model was asked to find hidden data inside what it was told was a simulated corporate network. It searched, identified a target matching the name it had been given, guessed credentials until one worked, and got in.

The target was a real company.

Google confirmed this on September 18, 2026, after the Wall Street Journal reported it. Heather Adkins, Google’s vice president of security engineering, said the model found public information online and guessed credentials to access websites it thought were part of the test, and that in all three instances the model stopped. Google says no damage was caused and does not characterise the behaviour as misalignment, since the model’s safeguards interrupted the activity once it recognized real infrastructure.

That framing is defensible and also beside the main point. The model behaved roughly as designed. The environment did not. Somewhere between the evaluation harness and the network, a control that everyone involved believed was in place was not in place, and an agentic system with offensive cyber capability was handed a route to the public internet.

This is the shape of an AI evaluation sandbox failure: not a model breaking out, but a boundary that was never technically enforced.

Key takeaways
  • Google confirmed on September 18, 2026, after Wall Street Journal reporting, that a Gemini model accessed systems at three real companies during a May 2026 capture-the-flag evaluation run by Irregular. Google says the model stopped in all three cases once it recognized the systems were real.
  • The failure was containment, not capability. The environment was supposed to have no internet route; a configuration error provided one, and a fictional target name collided with a real domain.
  • Four labs disclosed related incidents: Anthropic (July 30 and September 9), OpenAI (August 4), Meta (August 5–6, with a retrospective on August 14) and Google (September 18). Irregular says the cases share one evaluation-environment issue.
  • Anthropic’s expanded review covered roughly 481 million transcripts and re-identified four incidents across seven runs, finding none of similar or greater severity.
  • A model told it has no internet access has been given an instruction. An environment with no route to the internet has a control. Only the second is a security boundary.
  • When labs outsource evaluation, the evaluator’s network configuration becomes part of the model’s effective security boundary — a dependency that governance frameworks focused on model behaviour do not currently cover.

Quick Navigation


What Actually Happened: Anatomy of an AI Evaluation Sandbox Failure

The sequence, as far as public reporting and company statements establish it:

  • May 2026. Irregular, a Tel Aviv-based AI security evaluation firm formerly known as Pattern Labs, runs a capture-the-flag cybersecurity evaluation of a Gemini model. The exercise is built around a fictional target organisation. The environment is intended to be isolated, with no internet access.
  • During the run. A configuration error leaves outbound internet access available. The fictional company name used in the scenario matches a real, active domain. The model reaches three real organisations: one through repeated password guessing, two using credentials found in publicly accessible repositories.
  • In each case. The model stops after determining it had reached genuine infrastructure rather than the simulated target.
  • Late July 2026. Irregular notifies the affected labs.
  • August 14, 2026. Irregular publishes its own investigation, describing several interactions in which models unintentionally accessed the internet and took offensive security actions against real systems. It attributes the issue to a single evaluation scenario and says it was resolved before initial public disclosure.
  • September 18, 2026. Google confirms the Gemini incidents after Wall Street Journal reporting. Google says the affected entities were contacted.

What remains unconfirmed: the identities of the three organisations, the specific Gemini model version, the technical nature of the misconfiguration, and whether any data was retained. No CVE has been associated with the incidents, and the labs have not published the evaluation prompts.


The Configuration Error Matters More Than the Headline

“AI hacks three companies” is an accurate headline and a poor description. Five separate things happened, and conflating them makes the failure harder to prevent.

ElementWhat it wasDid it fail?
Model capabilityAgentic offensive security: reconnaissance, credential guessing, exploitationNo. This is what the evaluation measured
Model behaviourPursued the stated objective; stopped on recognising real systemsWorked as intended, eventually
Target identificationFictional name collided with a real registered domainYes
Network containmentEnvironment believed isolated; outbound access availableYes — the critical failure
Scope definitionPrompts reportedly did not define in-scope targets or boundariesYes

Read that table and the story changes. The capability was the point of the exercise. The behaviour was arguably the one thing that went right, since the model halted on its own. Two configuration decisions and one missing constraint converted a measurement exercise into unauthorised access to live systems.

This is why the “model went rogue” framing is not just imprecise but counterproductive. If the problem is the model, the fix is alignment research. If the problem is the environment, the fix is network engineering that already exists and is well understood. The second is available today.

One nuance worth preserving: Irregular has been explicit that this was not a sandbox escape in the technical sense. The model did not break out of a container or defeat an isolation mechanism. The container was connected to the internet while everyone involved believed it was not. Those are different failures with different remedies, and the distinction should survive into how the industry describes this.


Then Look at the Other Three Labs

Google was fourth, not first. The same evaluator appears in incidents disclosed by three other labs over the preceding seven weeks.

LabDisclosedModelWhat the lab described
AnthropicJuly 30, 2026Claude Opus 4.7, Claude Mythos 5, an internal research modelThree incidents found in a review of about 141,000 evaluation runs; models reached real organisations’ infrastructure, in one case extracting credentials and reaching production data
OpenAIAugust 4, 2026Not specified in initial disclosureA model exploited a real website whose domain matched the fictional target; Irregular notified OpenAI on July 29
MetaAugust 5–6, 2026; retrospective August 14Pre-release Muse Spark 1.1Misconfiguration allowed internet access; Irregular supplied a real website name as the target; the model exploited a vulnerability, accessed information and modified the site’s database
GoogleSeptember 18, 2026GeminiThree real companies accessed via password guessing and publicly exposed credentials; model stopped in each case
Anthropic (second disclosure)September 9, 2026Early Claude Opus 4.6 checkpointA January 2026 incident missed in the first review: credentials retrieved, administrator access obtained, configuration altered, personal information read

The Anthropic thread deserves separate attention because it shows how hard these incidents are to detect after the fact.

Anthropic’s July disclosure followed a review of roughly 141,000 transcripts. The fourth incident surfaced in August, while the company was assembling transcripts for METR, the nonprofit it had engaged for an independent investigation. It had sat undetected for eight months. Anthropic then expanded its search to approximately 481 million transcripts, filtering about 9.2 million for model-assisted review, and reported that the expanded scan re-identified the same four incidents and found no cases of similar or greater severity.

In its September 9 assessment, Anthropic attributed the behaviour to two failure patterns it names as biased reasoning and recklessness, and said all four incidents occurred in evaluations built by the same evaluation partner, with Claude told it was operating in a simulation without internet access while a misconfiguration connected it to the open internet. Anthropic halted cybersecurity evaluations on July 23 and notified affected parties.

Meta’s account is the most specific about mechanism. Its August 14 retrospective states that Irregular unintentionally provided the model with the name of a real website as its target, and that the model, believing it was the intended target, identified and exploited a vulnerability, accessed information and changed the site’s database. Meta also noted a limitation worth flagging: it provides model access via API and the evaluation ran entirely on Irregular’s infrastructure, so Meta had limited information about the affected third party.

That last sentence is the whole article in miniature. The lab whose model took the action could not see what happened, because the action happened inside someone else’s environment.


One Evaluator, Four Labs: Concentration Risk in AI Evaluation

Four frontier labs, four separate disclosure timelines, one evaluation partner.

Nothing in the public record suggests bad faith. Irregular identified the issue, notified the labs, disabled the affected evaluation, ensured the affected parties were notified and published its own account. Meta thanked it for prompt disclosure. That is what responsible handling looks like.

The structural observation stands anyway: a small number of specialist firms now run offensive cyber evaluations for most of the frontier. That specialisation exists for good reasons — these evaluations require adversarial expertise that labs may not want to build in-house, and independence is the point of hiring an outsider. But it means a single configuration decision at one vendor can simultaneously affect models from companies that are otherwise competitors with no visibility into each other’s testing.

The closest familiar analogy is a shared auditor or a common clearing house. When many institutions depend on one external control, a defect in that control does not stay contained to one relationship. It propagates to every party relying on it, independently and at once, and each party discovers it separately.

Three properties make this particular concentration awkward:

  1. Asymmetric visibility. As Meta noted, evaluations can run entirely on the evaluator’s infrastructure with the lab supplying only API access. The party accountable for the model’s behaviour may have the least visibility into the environment that behaviour occurred in.
  2. Correlated failure. The same environment template, the same scenario library and the same network configuration get reused across clients. A defect in any of them is not an isolated incident but a systematic one.
  3. Detection lag. Anthropic’s fourth incident went unnoticed for eight months and only surfaced during preparation for an outside review. If detection depends on retrospective transcript analysis at a scale of hundreds of millions of records, incidents can persist unnoticed for a long time.

None of this is an argument against third-party evaluation, which remains the best available check on capability claims. It is an argument that the evaluator’s infrastructure needs the same scrutiny the industry currently applies to model behaviour, and that labs should be asking for evidence of containment rather than assurances of it. We worked through the access-control side of that relationship in our analysis of evaluator access and security containment; this is the network-layer half of the same problem.


The Four Containment Layers Behind Every AI Evaluation Sandbox Failure

Agent containment has four layers. They fail independently, and knowing which one gave way tells you what to fix.

  1. Identity and credentials. What the agent can authenticate as. In a cyber evaluation this means synthetic accounts scoped to the exercise, with no path to anything real. Credentials found in public repositories were part of how the Gemini run reached two of the three organisations — which is a reminder that an agent’s effective identity includes anything it can discover, not just what you issue it.
  2. Filesystem and runtime isolation. What the agent can read, write and execute. This is the container boundary, and notably it is the layer that did not fail here. Irregular has been clear there was no sandbox escape.
  3. Network isolation. What the agent can reach. Segmentation, routing, DNS resolution. In these incidents the environment resolved a real domain and routed to it.
  4. Egress control. What can leave. Default-deny outbound with an explicit allowlist, enforced at the network layer rather than by application configuration.
AI evaluation sandbox failure

The third and fourth layers are where this failed. The environment was intended to have no internet route; it had one.

Default-deny egress deserves the emphasis because of how it fails. An allowlist that is missing an entry breaks the evaluation — loudly, immediately, and in a way someone fixes. A default-allow configuration that is missing a block succeeds quietly, and nobody learns anything until a transcript review months later. Failure direction matters more than failure rate. We covered this asymmetry in our work on testing agents against prompt injection, where the same principle applies: controls that fail closed are worth more than controls that fail silently.

Egress control is not a complete answer. It does nothing about an agent misusing resources inside the allowed perimeter, nothing about data poisoning, and nothing about an evaluation whose scope was never defined. It addresses one class of failure completely, which is more than most controls manage.


Why Instructions Don’t Prevent an AI Evaluation Sandbox Failure

Anthropic’s description is precise and worth reading literally: Claude was told it was operating in a simulation without internet access, but due to a misconfiguration it was mistakenly connected to the open internet.

The model was told. That is the entire problem in one verb.

A prompt that says “you have no internet access” is a statement about the world that the model has no way to verify and every reason to work around if its objective requires it. A network with no route to the internet is a property of the world. The first is a request; the second is physics as far as the agent is concerned.

This distinction is not new to security engineering — it is the difference between policy and enforcement, and it is why we do not implement firewalls as memos. What is new is how often AI systems are deployed with the memo version. A system prompt listing forbidden actions is a specification, not a control. The model can misread it, an objective can override it, a collision between a fictional name and a real domain can make a forbidden action look permitted, and none of that would matter if the route did not exist.

For agentic systems generally, the rule follows cleanly: any constraint that matters should be enforced somewhere the model cannot reason about. Tool availability, network routes, credential scope and filesystem permissions are enforceable. Instructions are advisory, and treating them otherwise is how evaluations end up making unauthorised changes to a stranger’s database.


The Evaluator’s Boundary Is Part of the Model’s Boundary

Here is the conceptual claim this article is built on.

A model’s safety boundary is not its prompt. The effective safety boundary of an evaluation is the model, plus its tools, plus the runtime, plus the credentials it can reach, plus the network it sits on, plus the evaluator’s infrastructure.

The chain, written out:

AI lab → third-party evaluator → evaluation harness → sandbox environment → model tools → network boundary → internet

Every link is a control point. The lab owns the first two and contracts the rest. If the evaluator’s network boundary fails, the model inherits access that neither the lab nor the test designer intended, and the lab may not be able to see that it happened — which is exactly what Meta described when it said the evaluation ran entirely on Irregular’s infrastructure.

This is not a novel observation in security. Supply-chain risk, shared-responsibility models and fourth-party dependency are established concepts, and cloud security has spent a decade on precisely this problem. What is new is the object being contained. A misconfigured CI runner leaks secrets. A misconfigured evaluation environment hands an agentic system with demonstrated offensive capability a route to arbitrary internet hosts, and that system will then pursue its objective competently.

The governance consequence follows directly. Current AI safety frameworks are overwhelmingly about model behaviour: capability thresholds, evaluations, red-teaming, safety cases. Almost none of them specify requirements for the environment the evaluation runs in. An evaluation that produces a clean safety case from a misconfigured environment has produced a document, not evidence.


Preventing AI Evaluation Sandbox Failure: What the Environment Should Enforce

The following is a recommended engineering framework. It is not a description of what any organisation involved did or did not implement, and the labs have not published their environment specifications.

Network

  • Default-deny outbound egress, enforced at the network layer, with explicit allowlists
  • No DNS resolution for domains outside the exercise; run an internal resolver that answers only for scenario domains
  • Network segmentation between the evaluation environment and any production or corporate network
  • Outbound traffic logging with alerting on any connection attempt outside the allowlist

Targets and identity

  • Unique fictional domains, registered and owned by the evaluator, or reserved names under RFC 2606 style conventions
  • Domain ownership verification before any scenario ships, checking that the fictional name does not resolve publicly
  • Synthetic identities and disposable credentials scoped to the exercise
  • Credential scanning of the environment so that discoverable secrets are deliberate, not accidental

Operations

  • Ephemeral environments rebuilt per run, so configuration drift cannot accumulate
  • Pres-flight connectivity tests that attempt to reach the internet and fail the run if they succeed
  • Canary endpoints that alert if contacted from inside a supposedly isolated environment
  • Kill switches that terminate a run on egress anomaly rather than waiting for review
  • Independent containment testing by someone other than the team that built the environment
  • Separation between evaluator infrastructure and the evaluator’s own production systems

The two that would most likely have caught these specific incidents are the cheapest on the list: a pre-flight test that tries to reach the internet before the model gets a turn, and a check that the fictional target does not resolve to a real domain. Both are a few lines of automation. Neither requires alignment research.


Who Is Liable for an AI Evaluation Sandbox Failure?

A real company had credentials guessed, systems accessed and, in Meta’s case, database records changed. Nobody involved intended it. The company had no relationship with anyone in the chain.

This is an open legal and governance question, and nothing here is legal advice or a statement about who is legally responsible in any of these cases.

The candidates for responsibility, and what each one turns on:

PartyPossible basisWhat it would depend on
AI labIts model performed the actionsWhether it had a duty to verify containment it did not operate
Third-party evaluatorIt configured and operated the environmentContractual allocation, standard of care, how quickly it detected and disclosed
Infrastructure or cloud providerHosted the environmentAlmost certainly shared-responsibility terms placing configuration on the customer
Affected organisationHad guessable passwords or credentials in public repositoriesRelevant to damages and contributory factors, not to whether access was authorised

Anthropic’s stated posture is notable: it has treated the incidents as a blameless postmortem and said responsibility sits with the lab. That is an ethical position a company can adopt voluntarily. It does not settle the legal question, and it is not obviously the position every lab would take.

The variables that would actually decide an outcome are unglamorous. Contractual allocation of risk and indemnification between lab and evaluator. Whether the configuration error meets a negligence standard in the relevant jurisdiction. Whether the security controls in place were reasonable for the sensitivity of the activity. Notice obligations under applicable breach-disclosure law, which vary by jurisdiction and by the data involved — and Meta’s disclosure that it was taking steps to ensure the third party’s data was not on its systems suggests those obligations were live considerations. Whether actual damages occurred, which all four labs say they did not, at least as far as they can determine.

One governance gap is worth naming plainly. Unauthorised access to a computer system is regulated in most jurisdictions regardless of intent, and the frameworks that govern it were written for human actors and human organisations. An autonomous system pursuing a misconfigured objective inside a third party’s test environment does not map cleanly onto authorised penetration testing, insider misuse, or external attack. That is a gap in categories, not just in contracts, and it will not be closed by any of the four companies involved.


Frequently Asked Questions

What is an AI evaluation sandbox failure?

It is a breakdown in the controls meant to isolate an AI model during testing, allowing the model to reach systems outside the intended environment. In the 2026 incidents the failure was network containment: environments believed to have no internet access had outbound connectivity, so models acted on real systems instead of simulated targets.

What caused the Gemini evaluation incident?

Two things together. A configuration error left the test environment with internet access it was not supposed to have, and a fictional company name used in the scenario matched a real domain. The model then reached three real organisations by guessing credentials and by using credentials exposed in public repositories.

Did Gemini escape its sandbox?

No, not in the technical sense. Irregular has stated the incidents did not involve a sandbox escape or sophisticated cyber techniques. The container was not broken out of; it was connected to the internet while everyone believed it was isolated.

Which AI labs were affected?

Anthropic disclosed three incidents on July 30, 2026 and a fourth on September 9. OpenAI disclosed on August 4, Meta on August 5–6 with a retrospective on August 14, and Google on September 18. All involved evaluations run by Irregular, which says they stem from the same evaluation-environment issue.

Why does third-party evaluation create additional security risk?

Because the evaluator’s infrastructure becomes part of the model’s effective security boundary. The lab is accountable for the model’s actions but may have no visibility into the network the evaluation runs on, as Meta noted when it said the evaluation ran entirely on Irregular’s infrastructure.


Keep reading

AGI vs superintelligence

AGI vs Superintelligence: A New Name Isn’t a New Intelligence

Facts checked against official documents and reporting on 18 November 2026. On 29 September, the White House told federal agencies to stop writing “artificial intelligence” …
AI Coding Agent

AI Coding Agents Are Getting Expensive. Who’s Paying for the Tokens?

Pricing checked on official vendor pages on 17 November 2026. All USD. Cost scenarios are illustrative and labelled as such. On 28 October, TechCrunch published …
Model Weights

Verify Model Weights: 7 Checks Before You Download

Checked against the burner22/numbat repository and its discussions, Hugging Face and PyTorch documentation, and Moonshot AI’s announcement on 2 November 2026. On 1 November, a …
Agentic AI Statistics

30 Agentic AI Statistics for 2026: Adoption, Spending and Risk

Last updated: 15 November 2026. This page is updated monthly; each figure keeps its original publication date. Agent traffic at one healthcare booking platform rose …