Through OrcaRouter the orca cyber ultra 1.0 card costs $5.00 and $10.00 per million, and that is the price everyone quotes. The number that decides whether you can actually use it is 42.2 tokens per second — the throughput measured across the seven days ending 2026-10-26 on our gateway [OURS]. A model that emits forty-two tokens a second is not slow in the way a benchmark measures; it is slow in the way a user notices.
Throughput converts a price into a duration, and duration is what an agent loop actually spends.
What the numbers look like in wall-clock
The arithmetic is simple and rarely done before a build:
| Output size | Time on Ultra (42.2 tok/s) | Time on Flash (138.8 tok/s) |
| 2,000 tokens | 47 s | 14 s |
| 8,000 tokens | 3 min 10 s | 58 s |
| 32,000 tokens | 12 min 38 s | 3 min 51 s |
| 131,072 tokens (ceiling) | 51 min 46 s | — |
A two-thousand-token answer is the size of a triage summary. Forty-seven seconds is tolerable if a person asked one question and is waiting; it is not tolerable if an agent is making twenty tool calls and each one ends in a synthesis step. At twenty calls the loop spends sixteen minutes of its wall clock waiting on generation alone, before any tool latency.
This is the constraint that most often turns a flagship model into a batch job. It is also invisible on a pricing page.
First token is a different problem
Ultra’s p50 time to first token is 4,046 ms [OURS]. That is more than four seconds before the first character arrives, against 1,453 ms on the fastest card in the batch — a 2.8× difference at the same stage of the request.
Two details matter.
First, a reasoning model is expected to have a longer first-token time: it thinks before it writes. You cannot remove that by streaming; streaming only changes when you see tokens, not when they are ready.
Second, the p95 on this card sits at the platform’s ten-second reporting cap, which means the slow tail is not precisely measured. Treat 4,046 ms as the median and assume the tail is materially worse.
For an interactive client, four seconds to first token is the edge of comfort. For a queue worker, it is irrelevant.
The volume context
Six billion tokens passed through this card in seven days — 6,010,685,841 — against thirty point six billion on Zero 1.5 and twenty-two billion on Flash 1.0 [OURS]. The flagship carries the least traffic of the three, which is what you would expect from the most expensive and slowest tier.
It also means there is less production evidence about it. Six billion tokens at an error rate of 0.295% is a solid sample — roughly four times the error rate of Zero, but far from alarming — yet the distribution of workloads behind it is unknown. A card used mostly for one kind of job at one customer looks healthy and tells you little.
Sizing the queue
Throughput turns directly into headcount if the work is a queue. The arithmetic is simple enough to do before you provision.
Take a 20,000-token report per audit — an ordinary size for this card’s stated use. At 42.2 tokens per second, that is 474 seconds of generation, just under eight minutes, plus the 4,046 ms median first token.
- 20 audits a day: 9,480 seconds = 2.6 hours. One worker with a generous timeout covers it.
- 100 audits a day: 13.2 hours. One worker is marginal; two is comfortable.
- 500 audits a day: 65.8 hours a day — three workers minimum, four to leave headroom for retries.
- 2,000 audits a day: eleven workers.
Those numbers assume perfect overlap-free serial processing and a single attempt per audit. Real queues need headroom for retries, for the p95 first-token latency, and for the fact that a worker waiting on a model is a worker not doing anything else.
Two consequences for architecture.
First, a slow model makes queue depth the thing to watch, not CPU. A worker pool sized for token throughput rather than for requests is the difference between a stable queue and one that grows all night.
Second, the cheap tier is a pressure valve. At 138.8 tokens per second, the same 20,000-token report takes 144 seconds on Flash — three times faster. A pipeline that routes only the cases that need depth to Ultra, and the rest to Flash, keeps its queue short and its bill small.
Designing around a slow model
If throughput is the constraint, three patterns make the card usable without making it fast.
Batch the questions, not the answers. Instead of twenty synthesis calls, gather twenty findings and ask for one structured summary. Output tokens are the bottleneck; a single 8,000-token answer costs three minutes regardless of how many inputs preceded it.
Use structured output to skip prose. A JSON response with the fields you need is shorter than a narrative and parses without a second pass. At forty-two tokens a second, every saved paragraph is real time.
Let the cheap tier do the triage. Run first-pass filtering on the fast, cheap card and escalate only the cases that survive. The 28× price difference makes the split obvious, and the 3.3× throughput difference makes it necessary.
None of these is exotic. They are the normal adaptations to a deep model, and they are worth deciding before the prototype, not after.
Why anyone accepts it
Because depth is the product. The card’s stated purpose is large-codebase security scanning, cross-file vulnerability discovery, exploit-chain analysis, and forensics over a full audit report or log stream [OURS]. Those are jobs where a wrong fast answer is worse than a right slow one, and where the input is measured in hundreds of thousands of tokens.
A million-token context is also, by itself, a reason for the latency. Prefill over that much input takes time, and the p50 first-token figure already includes it.
The trade is legible: you accept a fifty-minute ceiling and a four-second first token in exchange for reasoning that reads the whole thing at once. That is a reasonable trade for an incident. It is a bad trade for a chat box.
The takeaway
Forty-two tokens a second is the number that governs how this model can be used. It puts a two-thousand-token answer at forty-seven seconds, an eight-thousand-token report at three minutes, and the 131,072-token ceiling at fifty-two minutes. Four seconds to the first token narrows it further for interactive work.
The card earns that cost only when the input is enormous and the answer matters more than the clock. Decide that before you wire it into a loop, because the loop will decide it for you.
Sourcing note: pricing, context and ceiling are OrcaRouter catalogue data, checked 2026-10-27 [OURS]. Throughput, p50 and p95 first-token latency, traffic and error rate are OrcaRouter production telemetry for the seven days ending 2026-10-26 [OURS]. All durations are division of token counts by the measured throughput, assuming a single uninterrupted stream. No benchmark scores are quoted, because the model page publishes none.
| 🔗 You may also like: |
| Buy or build AI agents companies |
| Zecway explained |
