Case study · Individuals · endlesstokens
A third of a billion tokens on one Daily pass
During our launch week, one person bought a single ₹999 Daily pass, pointed an AI agent at it and let it work for 30 hours. It moved a third of a billion tokens. On a per-token meter, the same work would have cost between 1.5× and 21× what they paid. On our side, it ran on one RTX PRO 6000 that never used more than 3 of its 16 sessions, never went above 73 °C and never throttled once. This post walks through what happened, how we measured it, how much of the card it took and what we learned.
TL;DR
- The customer: one individual, one Daily pass (₹999 + GST, ₹1,178.82 all in), plus a 6-hour promotional top-up, so 30 hours in total.
- The usage: 344 million tokens. Of the 337 million input tokens, 91% were served from cache. Output was 6.8 million tokens.
- The price per token that implies: ₹3.42 per million tokens, tax included.
- What a meter would have charged for the same tokens at list prices: $318 on Claude Opus 5.5, $159 on Claude Sonnet 5.5 or GPT-6.1 Sol, $66 on the model maker's own API, and $22 even on the cheapest provider listed for the same model.
- The hardware: one GPU. A heavy customer moving a third of a billion tokens used at most 3 of the card's 16 sessions.
- How fast it felt: median time to first token was 0.56 s. Median time per output token was 9.4 ms, about 107 tokens per second per stream.
- Heat and power: 0 throttle events over 30 hours, 73 °C at the hottest moment, and 7.7 kWh for the whole card, about ₹92 of electricity at ₹12/kWh.
- Why it works: we price on our real cost (time on a card), and we measure a card's real capacity under real agent load before we sell a single seat.
Chart 1 ROI indicators
Background: why we sell time, not tokens
Every large language model API you've used bills by the token. You pay for what you send in, a different rate for what comes back, and, increasingly, a third rate for input the provider already has in its cache. For a chat window that's fair. A person types a question, reads an answer, types another.
AI agents don't work like that. A coding agent working on a real repository reads a large slice of the codebase, plans, calls a tool, reads the result, and then sends the whole conversation back again with one more step on the end. It does this hundreds of times an hour. Each turn adds a little new text and re-sends everything before it. The work is overwhelmingly reading, and a meter charges you for every re-read.
Our own costs don't look like that at all. We pay for GPU time by the hour. A card costs the same whether it spends that hour reading a cached prompt or writing fresh code, and whether it serves one token or a billion. So we priced endlesstokens the way our costs actually behave:
- A pass is time on our capacity. A Daily pass gives you unlimited tokens for the length of the pass, with no token cap and no request cap.
- Capacity is shared fairly through sessions. Each key gets 2 parallel sessions, so one user can't take the whole card.
- We carry the risk of heavy use. Whether a customer sends a thousand tokens or a third of a billion, the price is the same. Our job is to make sure the card can carry it.
That last point is the claim this post tests. The customer below is the kind of user a per-token business worries about and a time-based business has to be ready for: an agent left running for a day and a night.
The customer
In our launch week, one person bought a single Daily pass: ₹999 + GST, ₹1,178.82 all in, with no custom deal and no discount. We added a 6-hour promotional top-up for launch-week buyers, so the pass ran 30 hours. They set one base URL and one key in their AI agent, the same two settings any agent that accepts a custom endpoint needs, and let it work.
We don't know what they built and we don't look: we keep inference data for at most three days and we never store prompts. What we can see is what any operator sees: how many tokens came in, how many went out, how much was served from cache, and what the GPU was doing at the time.
Figure 1: The time clock that doesn't count tokens
What the agent actually did
By the time the pass ran out, the agent had moved a third of a billion tokens:
- 337 million input tokens, of which 307 million (91%) came straight from cache
- 6.8 million output tokens
- on the card, a typical request carried about 64,000 tokens of context and got about 1,200 tokens back
That's ₹3.42 per million tokens, tax included.
Two ratios in those numbers explain almost everything that follows.
Reading outweighed writing about 50 to 1. For every token the model wrote, it read roughly fifty. That's the signature of an agent rather than a person: long, growing context, short focused replies. It's also why per-token pricing hurts agents. On a meter, the input side of the bill dominates, and the input is mostly the same text sent again.
91% of that reading was already in cache. When the next request starts with the same tokens as the last one, the GPU doesn't need to compute them again. It reuses the work it already did, and only the new tokens on the end cost real compute. For this customer, 307 million of the 337 million input tokens were reused this way. The GPU only had to compute about 30 million tokens of input from scratch over 30 hours.
That second ratio is the economic engine of this whole business. A cached token costs us very little. A meter still charges you for it, at a discount if you're lucky.
Chart 2 Where the tokens went
What the same work would have cost on a meter
To make the comparison fair, we took the customer's exact token mix (30.2M uncached input, 307.3M cached input, 6.8M output) and priced it at each provider's published list price on 9 November 2026.
We stacked every assumption in the meter's favour:
- Every provider got its own cache discount. Cached input is billed at each provider's cached rate, between a twentieth and a fifth of its normal input rate.
- No cache-write charges. Some providers charge extra to put tokens into the cache in the first place. We left that out.
- Our side uses the higher price. We compare against the $15 USD price of a Daily pass, which is more than the ₹1,178.82 this customer actually paid.
So each figure below is the lowest bill that provider could have sent.
Chart 3 What the meter would have said
Indicative INR at ₹95 per US dollar. The ROI badges use our $15 USD price; against the ₹1,178.82 this customer actually paid, every multiple is larger (for example, 25.7× against Claude Opus 5.5).
There are two kinds of rows in that table, and they answer different questions.
The frontier rows (Claude Opus 5.5, Claude Sonnet 5.5, GPT-6.1 Sol) are different, larger models. They aren't a like-for-like comparison of quality. They show what this volume of agent work costs when it runs through a meter, which is what most teams running agents pay today. At that volume, a single day of one agent costs $159 to $318.
The like-for-like rows run the same open model we serve. These are the honest test of the business. Against the model maker's own API, the pass was 4.4× cheaper. Against the median of 24 providers on OpenRouter, it was 4.6× cheaper. Even against the cheapest provider listed anywhere for this model, a provider that publishes no cache discount at all, the flat pass came out ahead. And the customer never had to watch a counter or decide whether the next agent run was worth it.
Chart 4 Price per million tokens
One caveat cuts the other way, and we want to be clear about it. A flat pass is the better deal for heavy, agent-style use. For a light user who sends a few questions a day, a per-token API is cheaper. A pass is built for people whose agents work for hours.
One GPU behind it
All of it ran on one GPU: a single NVIDIA RTX PRO 6000 Blackwell, serving Qwen3.8-27B exactly as published (its official FP8 model card, with no re-quantisation). That one card served everyone on endlesstokens during the pass, and this customer alone was 86% of its input tokens and 95% of its output. For practical purposes, this is a single heavy user's day on a single card.
How a request reaches the card
The path is deliberately short:
- The agent sends a standard chat or messages request to our endpoint with its key.
- Our gateway checks the key and the pass, counts the key's open sessions against its limit of 2, and decides admission. The gateway, not the inference engine, owns admission and queueing, so the rules are the same on every card and can change without a restart.
- The GPU runs the model and streams tokens straight back through the gateway to the agent.
- Metering for operations, not billing: the gateway records token counts, cache hits and latency for every request. Billing is by time, so those counters exist to run the service, not to charge for it.
The unit of capacity is a session, not a token
The most important design decision behind the pass is what we count as capacity. Tokens per second is the obvious choice and the wrong one for agents. A card's throughput swings wildly with how much of each prompt is cached and how long the context is, so a token budget is either wasteful or unsafe.
What stays stable is the number of concurrent sessions a card can serve while every one of them still feels fast. In our setup, one RTX PRO 6000 carries 16 sessions: 8 users with 2 parallel sessions each. That's the capacity we benchmarked, sized and sell, and it's the yardstick for everything below.
Figure 2: The GPU server with 16 session lamps
What the card was doing
We replayed the card's production metrics in 10-minute steps across the full 30 hours.
Chart 5 One GPU, mostly idle
At its busiest, the card ran 3 of its 16 sessions, under 20% of its capacity. On average, it ran one. The KV cache (the GPU memory that holds each session's working context) peaked at 27% and averaged 7%. The queue never held more than one request. A third of a billion tokens went through a card that spent most of the day with more than 80% of its seats empty.
Chart 6 Capacity used
Chart 7 Who used the card
and 95% of its output tokens
How fast it felt
Cheap is only interesting if it's also fast. An agent that waits ten seconds for every step is an agent nobody leaves running. We track two latency numbers, because they measure two different things a user feels.
- Time to first token (TTFT) is how long the agent waits before anything comes back. It's dominated by prefill: reading the prompt. A cached prompt prefills almost instantly; a fresh one has to be computed token by token.
- Time per output token (TPOT) is how fast the answer streams once it starts. It's dominated by decode: writing the reply one token at a time.
Measured on the GPU across the whole pass:
- Time to first token: 0.56 s at the median and 1.41 s on average. 75% of requests started streaming in under a second, and 91% in under 4 seconds.
- Time per output token: 9.4 ms at the median (about 107 tokens/s per stream), 18 ms at p90.
- Prefill: about 3,600 prompt tokens/s on average, peaking above 15,000 tokens/s, with 92% straight from cache.
- Decode: about 66 tokens/s on average across the card, peaking at 185 tokens/s.
The shape of these numbers matches the workload. Because 92% of prefill came from cache, most requests started streaming in about half a second even with 64,000 tokens of context. The requests that took longer are the other 8%: when an agent opens a fresh, very long context, the card has to read all of it once before it can answer. After that first read, the same context is cached for the turns that follow.
At 107 tokens per second per stream, a typical 1,200-token reply finishes streaming in a little over 11 seconds. That's faster than anyone reads, which is the bar that matters for an agent.
Chart 9 Time to first token
Chart 9 leaves out the 8 of 179 half-hour windows with fewer than 5 requests, where a single request would stand in for an average.
Chart 10 Time per output token
Chart 11 Prefill and decode throughput
Heat, power and what the electricity bought
Throughput on paper means nothing if the card overheats. When a colocation facility's cooling falls short, a GPU protects itself by thermal throttling: it lowers its clocks, every request slows down and the benchmark numbers stop being true. A capacity plan that ignores temperature is a plan that works in the lab and fails in July. So we watch the card's temperature, clocks and power alongside latency, with the same 10-minute resolution.
Over the 30 hours:
- Temperature: 50 °C on average, 61 °C at p95, 73 °C at the hottest moment.
- Throttling: never engaged. The card reported zero throttle events of any kind for the whole pass.
- Clocks: held between 2,302 and 2,422 MHz, averaging 2,397 MHz. That's never more than 5% below the top clock.
- Power: 255 W on average and 415 W at p95, against a 600 W limit. It touched the limit only in brief bursts of heavy prefill.
- Energy: 7.7 kWh for the whole pass, card-wide.
Chart 12 Temperature and clocks
No throttle event of any kind was recorded during the pass.
Flat clocks are the result we care about most here. They mean the latency numbers in the previous section aren't a best case from a cool moment; they held for the whole day and night.
The energy numbers tell the other half of the story. Across everything the card served, it delivered about 52 million tokens per kWh. This customer's third of a billion tokens took roughly 6.6 kWh of GPU electricity, about what a household air conditioner draws in a few hours.
What that electricity costs, at ₹12 per kWh:
| Energy | Electricity at ₹12/kWh | |
|---|---|---|
| The whole card, 30-hour pass | 7.7 kWh | ≈ ₹92 |
| This customer's share | ≈ 6.6 kWh | ≈ ₹79 |
| Per million tokens | ≈ 0.019 kWh | ≈ ₹0.23 |
The customer paid ₹1,178.82, and the GPU electricity behind their third of a billion tokens cost about ₹79, under 7% of the price. That's the electricity-against-ROI test, and it passes comfortably. These figures are GPU board power only; the server's other parts and the facility's cooling overhead add to them.
Chart 13 Power and energy
What one card can carry
A flat price only works if the capacity behind it is known exactly. The capacity math for one card looks like this:
| One RTX PRO 6000 | |
|---|---|
| Capacity | 16 sessions = 8 users × 2 parallel sessions |
| What this one heavy customer took | at most 3 of 16 sessions, while moving a third of a billion tokens |
| Seats still free at their busiest moment | 13 of 16 |
| Electricity at this load | ≈ 6.2 kWh a day, ≈ ₹74 at ₹12/kWh |
Chart 8 What one card can carry
Three things follow from that table.
- Capacity is a measured number, not a guess. 16 sessions is where our benchmark climb stopped, and it's the number we sell against.
- Heavy users fit. This customer, about as heavy as an individual gets, still left 13 of 16 sessions free at their busiest moment. A card full of users like them is still a card with headroom.
- Electricity is small next to the value delivered. About ₹74 of electricity a day for a card that carries 8 users' agents, so the lever that matters is filling seats, not how hard each user works the card.
This isn't luck. It's what happens when the math and the science are made to work together: a price built on our real cost (time on a card), and a card whose real capacity has been measured under real agent load before we sell a single seat. The next section is about that measurement.
How we got here: we benchmark like we're trying to break it
Every number in this post depends on one figure being right: 16 sessions per card. Set it too high and every user on the card slows down at the busiest hour. Set it too low and the economics above stop working. We don't take that number from a spec sheet or a vendor's chart. We earn it with agentbench, our own benchmarking tool, and it doesn't go easy.
Most published GPU benchmarks measure the wrong thing for agents. They send short, synthetic prompts, report the average throughput and stop at the first number that looks good. Real agent traffic is long, multi-turn and bursty, and what users feel is the slowest request, not the average one. agentbench is built around the traffic and the failure modes we actually see.
- It searches combinations, not settings. For every candidate we test GPU × model card × inference engine. The model's published quantisation stays exactly as its makers shipped it, so we never trade quality for speed. Only the combination that wins on real work goes to production.
- It replays real agent work, not synthetic prompts: multi-turn coding sessions with tool calls and contexts of 50,000 to 130,000 tokens, the traffic that breaks naive deployments.
- It climbs until something gives. We add users step by step until speed or quality drops. A step only counts if the slowest requests still stream at a usable speed, tool calls stay valid and answers stay coherent. A step with errors is thrown out, however fast it was. The 16 sessions on this card are where that climb stopped.
- It starts from the hardest card to win on. We don't buy performance with the most expensive datacenter flagship. We pick the most modest card that can hold the model and make it deliver throughput without giving up quality. That's what we're best at.
Two principles sit underneath those rules.
Quality is a gate, not a score. A configuration that is 20% faster but occasionally produces a malformed tool call is worse than useless for an agent, because one broken tool call can derail an hour of work. So quality checks run at every step of the climb, and a single failure disqualifies the step.
The slowest stream decides capacity. Averages hide the user who is having a bad time. We size each card so that even the slowest requests at full load still stream fast enough to keep an agent productive, and we stop the climb at the first step where that fails.
More than 100 full benchmark runs across eight GPU classes went into the setup this customer used.
Figure 3: The test stand
Want the method behind it? Token by Token publishes how we think about benchmarking: tokenbytoken.org.
What we learned
A single heavy user on a single card is a small experiment, but it confirmed several things we had designed for and taught us a few we hadn't fully priced in.
- Agents are readers. Input outweighed output 50 to 1. Any pricing or capacity model built around output tokens misreads agent workloads.
- The cache is the business. With 91% of input served from cache, the real compute cost of a heavy agent day is a small fraction of its token count. Protecting cache reuse is worth more than almost any other optimisation.
- Sessions are the right unit of capacity. While the card was busy, prompt throughput swung between about 1,000 and 7,700 tokens per second (the 10th and 90th percentile of 10-minute steps), peaking above 15,000, while open sessions stayed between 0 and 3. Sizing and selling by session kept the card predictable.
- Know what makes a first token slow. The slower starts came from long contexts read for the first time, not from load. Knowing that tells us what to improve and tells users what to expect.
- Cooling is part of capacity. A capacity number is only true while the card holds its clocks. Zero throttle events over 30 hours is as important a result as the latency figures.
- Electricity is not the constraint; utilisation is. About ₹92 of electricity carried this whole 30-hour pass on the card. The lever that matters is filling seats.
For enterprises: guaranteed in writing
This case study is one individual on a Daily pass. For enterprises, MIRASTACK LABS puts the same engineering under contract, with SLAs covering:
- Throughput: sustained tokens per second for your workload
- Time to first token (TTFT) and time per output token (TPOT)
- Uptime
- Failover: traffic moves to healthy capacity when a card or node drops
- Cold starts: capacity is ready before your traffic arrives
- Sudden spikes: bursts are absorbed without breaking latency
These are the same measurements this post reports, measured the same way, from the same benchmarking discipline. That's the state-of-the-art engineering we bring at MIRASTACK LABS. Monthly, Quarterly and Yearly passes are available, priced to your team.
Talk to us: enterprise.sales@endlesstokens.ai
Conclusion
Our cost is time: we pay for GPU time by the hour. A heavy customer spent a 30-hour pass pushing a third of a billion tokens through one card, using at most 3 of its 16 sessions, while the card never went above 73 °C or throttled once.
That's the business in one picture:
- The cache makes long agent sessions cheap to serve. 91% of this customer's input never had to be computed again.
- Benchmark-first sizing lets one modest card carry real load. 16 sessions is measured, not hoped for, and a heavy user still leaves most of the card free.
- Cool, unthrottled cards keep the numbers honest. The throughput we sell is the throughput we measured.
- So we sell time, not tokens. Customers get a flat price, no counter and no mid-task cap. We get a predictable cost per card, and every card has seats left to sell.
One customer, one pass, one GPU, and most of the card still free.
Pay for time, not tokens. Get your pass at endlesstokens.ai
Unlimited tokens = no token or request cap during your pass · 2 parallel sessions per key. Daily pass ₹999 ex-GST / $15.
About the author
Shiva Kumar R V is the founder and architect of MIRASTACK LABS, with more than 16 years spent building platforms that can't afford to fall over.
- At NPCI, as Deputy Chief of AI Build & Platforms, Shiva architected the infrastructure and platforms behind UPI and NPCI's 22 billion+ transactions a month: payments at population scale for India, a country of 1.4 billion people.
- Before that, Shiva transformed platforms at Swiggy, Razorpay and GrabTaxi.
- On stage, Shiva has spoken about how NPCI moved its mission-critical network to open networking with SONiC, at SONiC Workshop India 2025, and about running open-source, cloud-native infrastructure at population scale.
The discipline that keeps payments running at population scale for 1.4 billion people is the discipline behind this case study. Measure under real load, size from what you measured, and promise only what the numbers prove. MIRASTACK LABS brings that to AI inference: first to one person on a Daily pass, and under contract to enterprises.
Appendix: method and sources
- Usage: endlesstokens production billing and usage records for one anonymised customer's pass (a Daily pass plus a 6-hour promotional top-up, launch week, October 2026).
- GPU: production metrics from the serving engine, our gateway and the card's hardware exporter over the same 30 hours, sampled every 10 minutes for the charts. Latency percentiles, temperature, clocks, throttle state, power and energy cover the whole pass. The card served all customers during the window; the customer's share is their token totals divided by the card's.
- Capacity: 16 sessions per card (8 users × 2 parallel sessions), from our agentbench sizing for this setup.
- Prices: list prices per 1M tokens on 9 Nov 2026 from each provider's own page, with cache discounts applied and cache writes excluded.
- Claude Opus 5.5: $4 input / $0.20 cached / $20 output; Claude Sonnet 5.5: $2 / $0.10 / $10 (Anthropic pricing)
- GPT-6.1 Sol: $2 / $0.10 / $10 (OpenAI pricing)
- Qwen3.8-27B on Alibaba Cloud Model Studio (Singapore): $0.50 / $0.10 / $3 (Alibaba Cloud)
- Qwen3.8-27B on OpenRouter, 24 providers: cheapest $0.035 / $1.50, median ≈ $0.16 / $2.25. No cache price is listed, so input is billed at the full rate (OpenRouter).
- Indicative INR: USD figures converted at ₹95 per US dollar (close to the RBI reference rate in early November 2026). Rounded.
- Electricity: GPU board energy from the card's own counter over the pass, priced at ₹12 per kWh. Server and facility overheads are not included.
- Customer identity: removed. No name, account, location or exact dates are shown. We keep inference data for at most three days and never store prompts.