One node. Guaranteed lanes. 4.9 billion tokens later.
We put full-weight DeepSeek V4 Flash 0731 on Shared Reserved Inference and handed the keys to real developers - real repos, real agents, real deadlines. Over five live sessions, this is exactly what the node served, measured at the metal.
full-weight, 1M context - not a distill, not a quant · methodology at the end.
The next beta hour is free. Your lane is waiting.
Another dedicated hour on the full-weight model - bring your real project, point your tools at the endpoint, and push it as hard as the people above did.
A private GPU lane, without the private-GPU price.
Serving open models has always forced a choice between two bad deals. Shared Reserved Inference is the third way - scroll through how it works.
A whole GPU is truly yours…
…for $12–30+ per hour. You get every guarantee, and you pay for every idle minute. For a developer who codes in bursts, most of that money buys silence.
…or join the crowd.
Per-token APIs pool everyone together. It's cheap when it's quiet, but under load you hit 429s, throttling, and prices that move without warning. You compete for capacity you don't control.
Split the node into guaranteed lanes.
One powerful node is divided into equal, reserved slices. A small cohort books it together for a block of time. Your lane is yours for the whole hour - nobody else's traffic can take it.
Dedicated throughput, cohort pricing.
You keep the guarantees of a dedicated GPU and split the bill with the cohort: $0.20–0.40 per hour per lane for V4 Flash 0731. Flat. Predictable. No meter racing you.
| Approach | Per-token API shared pool | Shared Reserved Inference what we benchmarked | Whole dedicated GPU rent it all |
|---|---|---|---|
| Capacity | ✗You compete for capacity | ✓Your own guaranteed lane | ✓Fully dedicated to you |
| Under load | ✗Rate limits & throttling under load | ✓No rate limits, no mid-session throttling | ✓No rate limits or mid-session throttling |
| Pricing | ✗Prices can spike anytime | ✓Flat, predictable hourly price | ✗$12–30+/hr - idle time is wasted money |
| Commitment / model | ✓No commitment | ✓Full-weight model, 1M context | ✗You run the serving stack |
| Price | metered | $0.20–0.40/hr | $12–30+/hr |
The middle column is what we benchmarked: 97.8% of input tokens served from warm cache.
Your lane remembers your repo.
Coding agents resend the same huge context every turn. On a shared pool that context gets evicted by strangers' traffic. On a reserved lane, it stays warm - and that changes the economics of every single request.
One hour, one node.
Of 827M input tokens, the model recomputed only 19M. The rest streamed from a cache no stranger could evict.
The first request pays the toll.
Your agent sends the repo - hundreds of thousands of tokens. The model reads all of it once. This is prefill, and it's the expensive part of inference.
Your context stays on the node.
Your lane is sticky: the computed state of your entire context is held warm for you. No stranger's 800k-token paste can evict it - the lane is reserved.
The model skips straight to thinking.
Repeat context is recognized and served from cache - the model only processes what's new. Across the whole beta, ~98% of all input tokens hit warm cache.
808M of 827M tokens - cached.
In a single one-hour run, developers pushed 827M input tokens through the node. Only 19M were computed fresh. The other 97.8% streamed from warm cache at a fraction of the cost.
Five live sessions. Real workloads. Zero failed requests.
Not a synthetic load test - developers pointed Cline, agent harnesses, and their own tooling at the node and worked on real projects. 27 developers across the three one-hour runs, 15 seats in the three-hour marathon.
- Input tokens
- 827M
- Output tokens
- 2.6M
- Requests
- 5,939
- Active devs
- 18
- Input tokens
- 717M
- Output tokens
- 3.6M
- Requests
- 5,589
- Active devs
- 15
- Input tokens
- 947M
- Output tokens
- 3.3M
- Requests
- 5,456
- Active devs
- 16
- Total tokens
- 1.93B
- From cache
- 1.87B
- Crashes
- 0
- Active devs
- 15
the three one-hour runs alone: 2.50B tokens · 16,984 requests · zero failures
One developer pushed 227 million tokens. In sixty minutes.
No per-token meter racing them, no rate limit stopping them - just a lane, a warm cache, and an agent running flat out. These are the heaviest single hours from Run 1.
- Requests 1,054
- Most active of the whole cohort
- Value drawn $1.54–3.10
- Requests 1,017
- ≈ 63,000 input tok/s, sustained
- Value drawn $2.63–5.30
- Steady agent workload, cache doing the lifting
- Value drawn $1.46–2.90
The typical developer wasn't far behind. Across the three one-hour runs the node served 830M, 721M and 950M tokens among 18, 15 and 16 active developers - tens of millions of tokens each, inside an hour. That's the point of a reserved slice - the cache works for you, and nothing races you.
Pay for an hour. Draw multiples of it back.
We priced every request at DeepSeek's own published API rates - including their cache discounts, the most conservative comparison possible. The gap between what a lane costs and what developers actually drew through it is the whole product.
Across the three free Friday hours alone, the cohort drew $42 of off-peak DeepSeek-equivalent usage - $83 at peak rates. In the marathon, the heaviest developer drew $3.25 off-peak / $6.50 peak over three hours.
average developer: 4–7× the lane price in off-peak API value · heaviest hours cleared 13–26× at peak rates
The part we can't graph.
Every beta seat came with a feedback form. Nineteen written reviews later, here's the pattern - and the quotes, exactly as testers wrote them.
"I've worked a session up to around 940k context without any hallucination. The agent behaved well - the time didn't waste."
"Zero dropped requests in Cline, and cache speeds were great during long coding sessions."
"It was fast compared to other providers - that's a big win. And intelligence was on par. If this keeps up it'll explode in popularity."
"The real-time console was great. Token usage, cache rate, and API value were easy to understand - and matched my harness metrics very closely."
"Quite detailed and fast as compared to the main DeepSeek API."
"If $0.20 is indeed the price, then it's a steal deal."
"Incredible speed."
"Everything worked. The dashboard was handy and accurate, the API key was quickly delivered and worked great. No complaints."
A beta is for finding the edges. We found them.
Testers reported issues; we shipped fixes between sessions and verified them in the next run. That cadence is the product too.
Brief slowdowns when very large, uncached contexts loaded mid-session - improved caching and scheduling shipped between runs.
Fixed · verified liveRare formatting artifacts in streamed output under heavy agent workloads - traced and resolved at the serving layer.
Fixed · verified liveThe final session: three hours, 1.93 billion tokens, fifteen developers - zero crashes, zero rate-limit errors.
Clean runThe next beta hour is free. Your lane is waiting.
Another dedicated hour on the full-weight model - bring your real project, point your tools at the endpoint, and push it as hard as the people above did.
deepseek-v4-flash-0731 is now a permanent model on SingularityAPI - currently the cheapest per-token pricing in the market for it.
See model pricing →- 1All figures are live telemetry measured at the serving node - request counts, token totals, cache-hit rates - not extrapolations. Session dates: Aug 18–24, 2026.
- 2"Value drawn" prices every request at DeepSeek's published API rates for the same model, including their cached-input discount - the most conservative equivalent-cost comparison available. Off-peak and peak figures use DeepSeek's own two pricing windows.
- 3Cache-hit rates are prefix-cache hits measured at the engine: 97.0–97.8% across one-hour runs, 96.9% in the marathon (1.866B of 1.926B tokens).
- 4Model: full-weight DeepSeek V4 Flash 0731, 1M context. Not a distill, not a quantized cut-down. Developer counts overlap across sessions; per-session actives are reported per run.
- 5Your workload will differ - that's what the next beta hour is for.