Pokee-Isaac 28B: 10 Million Tokens of Context, and an Architecture Pokee Won't Describe

There is a column in Pokee-Isaac 28B's launch comparison where five of the six models score 0.0, and the footnote under it is more interesting than the number above it. At a 10-million-token context length, Pokee AI's new 28B model scores 93.3 on RULER and every baseline it was measured against — GPT-5.6 Luna, Gemini 3.5 Flash Lite, Claude Haiku 4.5, Nemotron 3 Super 120B, Qwen 3.5 122B — returns nothing usable. The footnote explains that three of those five cannot be purchased at any context length above 262K in the first place. So the score is real, and the room is empty. Those are two different claims, and most of the coverage published since the model appeared on 5 August 2026 has run them together.

That is not a reason to dismiss what Pokee shipped. It is a reason to be precise about which parts of it are demonstrated, which are merely uncontested, and which are simply not described. Everything below comes from four primary sources: the Pokee-Isaac model page on Pokee's own console, the Pokee developer documentation, the model's reseller listing on NanoGPT, and the launch statements from Pokee AI and founder Zheqing (Bill) Zhu. Every benchmark figure in this article was produced by Pokee AI. Pokee says so plainly — the console states that each figure "was measured by Pokee AI in a single controlled environment, for Isaac and for every baseline alike, unless marked otherwise" — and to their credit that means the baselines were re-run rather than copied from other vendors' announcements. It also means no independent lab has reproduced any of it, and as of today none has published an attempt.

What Pokee actually shipped

The public surface of the model is unusually well documented for a launch this young, so it is worth laying out before we get to the contested parts.

• Model — Pokee-Isaac 28B, versioned v0, served as pokee-isaac from api.pokee.ai behind a compatible endpoint.

• Size and context — 28 billion parameters against a 10,000,000-token input window; Pokee describes it as "usable end to end, not merely addressable."

• Output — 60,000 tokens, which is both the default and the hard cap.

• Modalities — text in, text out. Image, audio and video inputs are not supported, which is worth noting given what the model is built from.

• Price — $0.15 per million input tokens and $1.00 per million output, on Pokee's own list.

• Agentic features — function calling and structured output in the standard chat-completions schema; the model is positioned as a planning-executing-reviewing agent rather than a chat model.

• Request limits — a 45 MiB request body cap, with anything over 16 MiB required to use SSE streaming (stream: true plus an Accept: text/event-stream header).

• Rate limits — 500 requests and 20 million tokens per minute, with 10 concurrent requests on free accounts and 25 on paid.

• Deployment — datacenter B200, RTX 4090/5090 workstations, Intel Arc Pro client cards, edge NPUs (Qualcomm and Intel Panther Lake, with AMD listed as pending), and on-device, with VPC and on-premises licensing under which, in Pokee's words, "no request leaves your perimeter."

• Serving stacks — day-zero support in vLLM and SGLang.

• Company — Pokee AI, founded in 2024 by Zheqing (Bill) Zhu, previously head of applied reinforcement learning at Meta; $12M seed led by Point72 Ventures with Qualcomm Ventures and Samsung NEXT.

The weights are closed. Coverage has described the model as closed-source "for now," which is Pokee's own hedge rather than a commitment, and there is no announced date or license for a release.

The architecture nobody will describe

Pokee attributes the 10M window to a "proprietary non-decoder-only architecture." That phrase is the entire technical disclosure. The console links a technical report titled Pokee-Isaac 28B v0: A 10M-Token Context Efficient Agentic Model, dated 3 August 2026; we could not reach a public copy of it, and the launch materials that are reachable do not name the attention mechanism, the memory scheme, or the training recipe.

What Pokee has said about lineage is more specific, and it is a slightly awkward thing to say: some of Isaac's weights are fine-tuned from Qwen3.6-27B under its Apache-2.0 license, other weights were trained from scratch by Pokee, and the result is "not a conventional fine-tune." That is a careful sentence. It concedes the base and denies the characterisation at the same time.

It is also enough to constrain the guessing, which is what the AI research community immediately started doing. The researcher who posts as @teortaxesTex laid out the constraint set the day of the launch — partly fine-tuned from Qwen3.6-27B, non-decoder-only, 10M context, 28B total — and proposed two candidates: "some kind of souped-up Memory Sparse Attention" or "just 1B document encoder." Both guesses are worth understanding, because they are not idle.

Start with the arithmetic. Qwen3.6-27B is a dense 27B model with a 262K native window, gated-delta hybrid attention, and a vision encoder that can be skipped to run the model text-only. Isaac is 28B and text-only. If you drop the base model's vision tower and add roughly a billion parameters of something else, 28B is exactly where you land. A ~1B document or memory encoder bolted onto a 27B decoder is the most parsimonious reading of the parameter count Pokee published, and it would make the "non-decoder-only" label literally true without being a novel claim.

The Memory Sparse Attention guess points at a real and recent line of work: the MSA paper (arXiv:2603.23516) combines scalable sparse attention with document-wise RoPE to get linear complexity in training and inference, adds KV-cache compression plus a "Memory Parallel" scheme, and reports under 9% degradation from 16K all the way to 100M tokens, with 100M-token inference running on two A800s. That is the same shape of result Pokee is claiming, one order of magnitude further out, from a different group. Nothing connects the two beyond the shape — MSA is not Pokee's work and Pokee has not cited it — but it establishes that a decoupled-memory design reaching these lengths on modest hardware is a published, plausible thing rather than a marketing impossibility.

There is one number in Pokee's own materials that quietly supports the separate-encoder reading. Prefill throughput on a single B200 is 42,400 tokens/second at a 1M-token context and 137,200 tokens/second at 10M. Throughput rises more than threefold as the context gets ten times longer. A decoder paying quadratic attention costs does the opposite. Whatever is consuming those tokens gets more efficient per token as you add them, which is the signature of a bulk encoding pass over documents rather than an ordinary prefill.

Why any of this matters to someone deciding whether to use the model: if the 10M window is a document encoder plus a compressed memory rather than a 10M-entry KV cache, then "context" here is not the object your intuitions are built around. How it behaves when you append to a conversation, edit one document in the middle of a corpus, or expect prefix caching to work is unspecified, and Pokee's documentation lists no caching mechanism at all. You cannot reason about those behaviours from the spec sheet, and right now you cannot reason about them from the architecture either.

RULER at 10M is a real number in an empty room

Pokee's long-context evidence is RULER, run at 256K, 512K, 1M, 2M, 4M and 10M, with ten samples per configuration. Isaac scores 96.9, 96.7, 95.0, 95.8, 96.7 and 93.3 across those six lengths — the only model in the panel that returns a score at every one.

The panel below 1M is where the honest reading lives:

• At 256K — Isaac 96.9, Nemotron 3 Super 120B 96.3, GPT-5.6 Luna 95.0, Gemini 3.5 Flash Lite 94.5, and 0.0 for both Claude Haiku 4.5 and Qwen 3.5 122B, whose windows stop below that length.

• At 512K — Isaac 96.7, Nemotron 95.7, Gemini 3.5 Flash Lite 94.6, GPT-5.6 Luna 91.4.

• At 1M — Isaac 95.0, Nemotron 91.8, Gemini 3.5 Flash Lite 29.4, and GPT-5.6 Luna 0.0, both of the last two flagged as context-overflow errors.

• At 2M and beyond — Isaac alone, everything else 0.0.

Three things follow. First, up to 1M, Isaac's margin over the field is a point or two, not a generation — and the one baseline that stays close, Nemotron 3 Super 120B, is a 120B model whose 256K-to-1M figures are NVIDIA's own self-reported numbers, which Pokee flags and excludes from the row comparison rather than passing off as measured. So the closest competitor at those lengths isn't actually a matched measurement, in either direction.

Second, at least one of the blanks looks like a deployment artifact rather than a model limit. Pokee ran GPT-5.6 Luna through Azure and annotated its window as ">272K context," recording a context-overflow error at 1M. the vendor's own documented window for that model is about 1.05M tokens, which is what our own model page for it reports. A reader who takes the 1M column at face value would conclude Luna cannot do 1M; the more defensible conclusion is that the Azure deployment Pokee tested could not.

Third, RULER is a synthetic retrieval-and-aggregation suite, not a reasoning benchmark. Pokee is transparent about a methodological wrinkle here too: the 256K and 512K columns average all 13 task configurations, but common-words extraction is unavailable from 1M onward, so the long columns average the remaining 12. The 93.3 at 10M and the 96.9 at 256K are therefore not scored on quite the same task mix.

The harder long-context test stops at 1M

The more revealing benchmark on Pokee's page is not RULER. It is MRCR v2, an 8-needle multi-round co-reference task where several targets are scattered through a long conversation and the model must retrieve and disambiguate a specified one, so partial recall and cross-needle interference both cost you. On a 0–1 scale, at 1M tokens:

• Pokee-Isaac 28B — 0.500

• Gemini 3.5 Flash Lite — 0.205

• Nemotron 3 Super 120B — 0.067

• GPT-5.6 Luna — 0.050

• Claude Haiku 4.5 and Qwen 3.5 122B — 0.000, nothing usable at that length

This is a much wider and much more credible gap than RULER produces, and it is where the model's pitch actually cashes out. Luna scores 95.0 on RULER at 256K and 0.050 on MRCR at 1M; single-target recall and multi-needle disambiguation are not the same skill, and the second one collapses first. Isaac degrades far more gracefully.

It is also the single largest evidentiary hole in the launch. MRCR v2 was run at 256K, 512K and 1M — and stopped. Isaac's own scores there are 0.607, 0.743 and 0.500: non-monotonic, and at 1M it retrieves half the needles. There is no published multi-needle result at 2M, 4M or 10M from anyone, including Pokee. The 10M claim rests entirely on the easier of the two tests, at exactly the lengths where the harder test was not attempted. If you are considering this model because you want to put a 25,000-page corpus in one prompt and ask a question whose answer is assembled from four places in it, that specific capability is unmeasured at that specific length.

On agentic work, Isaac is Luna's peer, not its better

Pokee ran four agentic benchmarks, and this is where the company's candour is genuinely unusual: its own page summarises the result as Isaac leading two, placing second on one, and third on one. That is an accurate description, and it is not the description in the launch coverage.

• BFCL v4, function calling (scored by AST and state-transition matching rather than an LLM judge) — Isaac 70.94 vs GPT-5.6 Luna 70.61, with Claude Haiku 4.5 at 67.52, Qwen 3.5 122B at 64.88, Gemini 3.5 Flash Lite at 64.85, Nemotron 3 Super at 33.13.

• τ³-bench, four-domain average (multi-turn customer-service tasks against a simulated user whose requirements change mid-conversation) — Isaac 0.662 vs Gemini 3.5 Flash Lite 0.631, Qwen 3.5 122B 0.611, GPT-5.6 Luna 0.527, Nemotron 0.426, Claude Haiku 4.5 0.408.

• Terminal-Bench 2.1, text-only subset — GPT-5.6 Luna 69.8% vs Isaac 65.1%, then Gemini 3.5 Flash Lite and Qwen 3.5 122B tied at 46.5%, Claude Haiku 4.5 34.9%, Nemotron 24.4%.

• MCP-Atlas, claim coverage across live tool servers — GPT-5.6 Luna 77.90%, Gemini 3.5 Flash Lite 76.67%, Isaac 74.59%, Qwen 3.5 122B 70.24%, Claude Haiku 4.5 56.45%, Nemotron 48.95%.

A 0.33-point margin on BFCL v4 is parity, and Pokee's page says as much rather than calling it a win. Read across all four, a 28B model trades wins with a frontier vendor's fast tier on agentic tasks. For a 28B model that is a strong result. It is not the result "frontier-class agentic model" implies to most readers, and it means the reason to choose Isaac is the window and the deployment envelope, not the agency.

The safety number is the panel's best and still isn't good

On DTAP, a prompt-injection suite, Isaac posts the lowest attack success rate in the panel at 35.6 combined, ahead of Claude Haiku 4.5 at 37.9, GPT-5.6 Luna at 50.1, Qwen 3.5 122B at 54.0, Nemotron at 60.4 and Gemini 3.5 Flash Lite at 66.3. Direct and indirect rates differ by less than a point, so the robustness is at least even across both vectors.

Three caveats, all of them from Pokee's own reporting rather than from critics. The indirect measurements were taken with guards inactive. Explicit refusals fired on just 1.5% of malicious tasks, which Pokee describes as most of the current defence being "incidental rather than declined" — the model is not recognising and rejecting attacks so much as failing to be usefully steered by them. And against a broader 16-system leaderboard rather than this six-model panel, Isaac places fifth on direct attacks, sixth on indirect and ninth on capability: mid-field, not leading.

There is also a cost to the safety. Isaac's benign success rate is 82.5, below GPT-5.6 Luna's 85.1 — it refuses or fumbles slightly more legitimate work than the model it beats on attacks. And 35.6 means roughly one injection attempt in three still lands. For a model whose entire premise is reading ten million tokens of documents you did not write, that is the number to design guardrails around, not the number to be reassured by. DTAP itself is worth a flag: unlike RULER, BFCL and τ³-bench, it is not an established public leaderboard, and we could not find independent documentation of the suite.

What a ten-million-token call costs, and how long you wait

Ten million tokens is roughly 7.5 million words, or about 25,000 pages. At Pokee's $0.15 per million, filling the window once costs $1.50. Add a maximum-length 60,000-token answer at $1.00 per million and one maximal call lands at about $1.56. That is genuinely cheap for the volume of text involved, and it is the strongest simple argument for the model.

The time is the real price. On a single B200, Pokee reports 72.9 seconds to first token at 10M — which is exactly 10,000,000 divided by the 137,200 tokens/second prefill figure, so it is the benchmark-hardware number rather than a measured API latency. Pokee's own developer documentation tells a different story to developers: allow at least a ten-minute client timeout for multi-million-token prompts, because a large prompt can take "around seven minutes at 10 million tokens." That is roughly a six-fold gap between the throughput slide and the integration guide. Both are Pokee's numbers; the one in the docs is the one your timeout config has to believe.

Decode is flat at about 335 tokens/second regardless of how much context is resident, which is the good news architecturally and awkward news practically: a full 60,000-token output takes about three minutes on top of the prefill. On consumer hardware the picture shifts again — on an Intel Arc Pro B70, Pokee reports 1,087–1,500 tokens/second prefill (3.6–5× stock llama.cpp) and 58.8 tokens/second decode. Those are respectable numbers for a client GPU and they are not 10M-token numbers.

Two practical limits fall out of the size of the input itself. Ten million tokens of English is roughly 38 MiB of text, which fits under the 45 MiB request-body cap but sits far above the 16 MiB threshold, so every genuinely full-window call must be streamed — there is no non-streaming path to the headline feature. And with no documented prompt caching on Pokee's API, each re-query of the same corpus is another $1.50 and another multi-minute prefill. The reseller listing on NanoGPT does publish a cache-read rate of $0.079 per million, which if it applies to Isaac makes a cached re-read about $0.79 — roughly half price, not the order-of-magnitude discount that prompt caching implies elsewhere.

One correction to the pricing comparison, because it changes the headline. Pokee prices GPT-5.6 Luna at $0.40/$1.80 per million, sourced from Azure. the vendor's own list price for Luna after the 31 July 2026 cut is $0.20/$1.20, which is what our model page for it shows, because OrcaRouter passes provider list prices through at 0% markup rather than reselling at a margin. Against the correct number, Isaac is 25% cheaper on input and 17% cheaper on output than the fast frontier tier — still cheaper, but a much narrower edge than the panel suggests, and the panel's cheapest output price overall belongs to Nemotron 3 Super at $0.65. Isaac's price advantage is real; it is just not the part of this launch that is remarkable.

The part that is actually new

Strip out the benchmark framing and something unusual is left. A 28B model with a very long context that runs inside a VPC, on a workstation RTX 4090, on an Intel Arc Pro card, and on NPU-class mobile silicon, with day-zero vLLM and SGLang support and an on-premises license — that combination is close to unavailable elsewhere. Pokee also claims roughly 5× KV-cache efficiency versus standard implementations, which is a vendor figure with no reproduction, but it is the kind of figure that would have to be true for the deployment story to hold.

The customer for this is not someone shopping for a better agent. It is someone with a large, sensitive, mostly static corpus — contract sets, case files, a monolithic codebase, months of logs — that legally or politically cannot leave a boundary, and who would otherwise be building a retrieval pipeline to work around a 200K window. Against that alternative, the pitch is not "cheaper than RAG." Embedding and retrieving over 25,000 pages costs cents per query and always will. The pitch is that there is no chunking strategy to tune, no retrieval recall to lose, and no second system to keep in sync with the first. Whether that trade is worth $1.50 and several minutes per query depends entirely on how often you query.

Who should try it now, and who should wait

Try it now if you are prototyping against a corpus in the 1M–4M range, where Isaac's numbers are strongest and the alternatives are genuinely thin, or if on-premises deployment at 28B is the requirement that has been blocking you. The free tier's ten concurrent requests are enough to find out whether the model reads your documents the way you need.

Wait if you need the 10M number specifically and the questions you ask are multi-hop, because that combination is precisely what nobody has measured. Wait if you need multimodal input, which the model does not accept. Wait if latency matters, since a full-window call is minutes not seconds. And weigh the obvious dependency risk: this is a v0 model, with closed weights, from a company with a $12M seed round, and it is the only model in the world that serves the capability it is selling. There is no second provider to fail over to if it goes away.

That last point is the practical reason to keep the comparison honest. Pokee-Isaac 28B is not on OrcaRouter today — if you want it, Pokee's own API or a reseller is where it lives. But three of the five baselines it measures itself against, GPT-5.6 Luna, Gemini 3.5 Flash Lite and Claude Haiku 4.5, are on one OrcaRouter key at provider list price, which makes the useful experiment cheap to set up: run your actual long-context task against those three at the lengths they support, and see whether your corpus really needs ten million tokens or whether it needs 400,000 and a better prompt. If it needs ten million, you have learned something worth $1.50 a call. If it does not, you have avoided building a production path on a single-source v0.

Three questions worth answering

Is Pokee-Isaac 28B just a fine-tune?

Not by any normal use of the phrase, though it is not independent of that base either. Pokee's position is that some weights are fine-tuned from Qwen3.6-27B under Apache-2.0 while others were trained from scratch, and that the architecture is not decoder-only. Both halves of that are consistent with the parameter count: Qwen3.6-27B is 27B dense with a skippable vision encoder, Isaac is 28B and text-only, so about a billion parameters of new machinery replaced the vision tower. What that machinery is has not been disclosed, and until it is, "not a conventional fine-tune" is a claim resting on Pokee's word rather than on anything checkable. The Apache-2.0 license on the base makes the derivation legal; it does not make the closed release of the result unusual, which is worth noting mostly because a lineage this specific is rarely volunteered.

Can it really run 10M tokens on an RTX 4090?

The single-GPU claim and the 10M claim come from the same launch but not from the same measurement. Every throughput figure Pokee publishes at 10M context — 137,200 tokens/second prefill, 72.9-second time to first token — is on a single B200. The RTX 4090 and Arc Pro figures are real but are quoted at much smaller scale; the Arc Pro B70 numbers are 1,087–1,500 tokens/second prefill, which would put a 10M-token prefill in the hours. "Deployable on a single GPU starting from an RTX 4090" is best read as a claim about the weights fitting and the model serving usefully, not about the headline context length being practical on that card.

Should I replace a RAG pipeline with it?

Not on this evidence, with one exception. The case for replacing retrieval is strongest when your queries are multi-hop — exactly the failure mode chunked retrieval handles badly — and multi-hop performance past 1M tokens is the thing Pokee did not measure. MRCR v2 stops at 1M, where Isaac retrieves half the needles. The exception is a corpus that fits comfortably inside 1M–2M tokens, where Isaac's measured numbers are strong, the wait is tens of seconds rather than minutes, and dropping a retrieval layer removes real operational complexity. Above that, treat the window as a way to avoid building retrieval for a prototype, not as a reason to delete one that works.

What would settle it

Four things, none of which require trusting anybody. An independent RULER or MRCR run at 2M or above, by anyone, on the public API. An MRCR v2 result from Pokee at the lengths it already advertises. A reachable technical report that names the mechanism, at which point the encoder question stops being arithmetic and becomes a fact. And a weights release, which "closed-source for now" gestures at without promising.

Until then, the fair summary is narrower than the launch and more interesting than the skepticism. Pokee AI has shipped a 28B model that measurably holds long-context retrieval further out than anything you can currently buy, trades even with a frontier fast tier on agentic work, is the safest of its own panel and mid-field against a wider one, and runs in places nothing of its capability runs. It has also chosen to publish the only numbers that exist about the capability nobody else offers, and not to say how it works. Both of those are choices a young company gets to make. Neither is a substitute for someone outside the building running the test.