A 28-billion-parameter model that claims to hold 10 million tokens of context in memory — and run on a graphics card you can buy at a consumer electronics store — is either the biggest long-context breakthrough of 2026 or the most aggressive benchmark-chart framing of the year. It's probably some of both.
On August 4, 2026, Pokee AI released Pokee-Isaac 28B, which the company's announcement calls "the world's first real 10M-token context frontier-class agentic model," deployable "on a single GPU (starting from RTX 4090 or equivalent)." The claim sits at the intersection of two things every team building with LLMs cares about right now: how much context a model can actually hold onto, and how cheap it is to run that context somewhere you control. explainx.ai has covered both threads before — most recently in context window pricing decoded and context window limit management for Claude Code — and Pokee-Isaac is the most aggressive single data point either thread has seen so far.
TL;DR
| Question | Direct answer |
|---|---|
| What is it? | A 28B-parameter agentic model with a claimed real 10M-token context window, released August 4, 2026 |
| What hardware does it need? | A single GPU, starting from an RTX 4090 or equivalent — no multi-GPU cluster required to run it |
| What's the architecture? | A proprietary non-decoder-only design — not the standard transformer decoder stack |
| How fast is it at max context? | Up to 137,000 tokens/second prefill on a single NVIDIA B200 at 10M-token context |
| How much does it cost via API? | $0.15 per million input tokens, $1.00 per million output tokens |
| Where can I run it? | Own VPC, on-premises, or on-device — Day-0 support for vLLM and SGLang |
| Are the benchmarks independently verified? | No — the comparison chart is explicitly labeled "internal benchmark summary" by Pokee AI itself |
| Who built it? | Pokee AI, a Bellevue-based startup founded in 2024, $12M seed from Point72 Ventures, Qualcomm Ventures, SCB10X, and Samsung NEXT |
What does "10M-token context" actually let you do?
Ten million tokens is roughly 15 million words — deep into the range of an entire mid-sized codebase, a full year of a company's Slack history, or dozens of long legal contracts, all addressable in a single prompt without chunking or retrieval. Most "frontier" models advertised as long-context today top out their useful range well before their advertised maximum: Pokee's own comparison chart shows GPT-5.6-luna and Gemini 3.5 Flash Lite scoring 0.0 on RULER at 1M tokens, meaning the advertised window exists on paper but the model can't actually retrieve information reliably once you fill it that far.
That gap between "context window size" and "context the model can actually use" is the real story in long-context AI right now, and it's the same gap explainx.ai flagged when covering Claude Code's context window limit management — a stated token limit is not the same as usable recall at that limit. Pokee's headline claim is specifically about closing that gap: "a real 10M-token context" is a pointed phrase, implying competitors' advertised windows are not real in the same sense.
The benchmark tables
Pokee AI compared Pokee-Isaac 28B against five models: GPT-5.6-luna, Gemini 3.5 Flash Lite, Claude Haiku 4.5, Nemotron-3-Super-120B (on Amazon Bedrock), and Qwen3.5-122B (on OpenRouter). The chart is explicitly sourced as "internal benchmark summary" — this is Pokee's own testing, not a third-party leaderboard, and some 1M-context scores for competitors are pulled from external published results rather than run in-house by Pokee.
Pricing (per 1M tokens)
| Model | Input | Output |
|---|---|---|
| Pokee-Isaac 28B | $0.15 | $1.00 |
| Nemotron-3-Super-120B (Bedrock) | $0.15 | $0.65 |
| Qwen3.5-122B (OpenRouter) | $0.26 | $2.08 |
| Gemini 3.5 Flash Lite | $0.30 | $2.50 |
| GPT-5.6-luna | $0.40 | $1.80 |
| Claude Haiku 4.5 | $1.00 | $5.00 |
Long-context: RULER (higher = better)
| Context | Pokee-Isaac 28B | GPT-5.6-luna | Gemini 3.5 Flash Lite | Claude Haiku 4.5 | Nemotron-3-Super-120B | Qwen3.5-122B |
|---|---|---|---|---|---|---|
| 256K | 96.9 | 95.0 | 94.5 | 0.0 | 96.30 | 0.0 |
| 512K | 96.7 | 91.4 | 94.6 | 0.0 | 95.67 | 0.0 |
| 1M | 95.0 | 0.0 | 29.4 | 0.0 | 91.75 | 0.0 |
| 2M | 95.8 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 4M | 96.7 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
| 10M | 93.3 | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 |
The pattern here is the single most important line in this whole release: every competitor in Pokee's chart falls to a flat 0.0 on RULER past 2M tokens, while Pokee-Isaac holds above 93% all the way to 10M. Nemotron-3-Super-120B is the only competitor that holds up reasonably well at 1M (91.75), but it also drops to zero beyond that point. If these numbers reproduce independently, Pokee-Isaac isn't just ahead on long context — it's the only model in this comparison set that has a usable answer past the 2M-token mark at all.
Long-context: MRCR v2 (multi-round co-reference resolution, higher = better)
| Context | Pokee-Isaac 28B | GPT-5.6-luna | Gemini 3.5 Flash Lite | Claude Haiku 4.5 | Nemotron-3-Super-120B | Qwen3.5-122B |
|---|---|---|---|---|---|---|
| 256K | 0.607 | 0.208 | 0.474 | 0.000 | 0.145 | 0.000 |
| 512K | 0.743 | 0.173 | 0.473 | 0.000 | 0.161 | 0.000 |
| 1M | 0.500 | 0.050 | 0.205 | 0.000 | 0.067 | 0.000 |
MRCR is a harder test than RULER's needle-in-a-haystack retrieval — it requires tracking multiple references across a long conversation, closer to what a real multi-turn agent session demands. Pokee-Isaac's lead here is wider in relative terms than on RULER: at 512K tokens it scores more than 4x Gemini 3.5 Flash Lite's result.
Agentic capability benchmarks
| Benchmark | Pokee-Isaac 28B | GPT-5.6-luna | Gemini 3.5 Flash Lite | Claude Haiku 4.5 | Nemotron-3-Super-120B | Qwen3.5-122B |
|---|---|---|---|---|---|---|
| BFCL v4 (overall) | 70.94 | 70.61 | 64.85 | 67.52 | 33.13 | 64.88 |
| τ³-bench (4-domain avg) | 0.662 | 0.527 | 0.631 | 0.408 | 0.426 | 0.611 |
| Terminal-Bench 2.1 | 65.1 | 69.8 | 46.5 | 34.9 | 24.4 | 46.5 |
| MCP-Atlas | 74.59 | 77.90 | 76.67 | 56.45 | 48.95 | 70.24 |
This table is where the release gets more honest than a pure marketing pitch would be — Pokee-Isaac does not sweep every agentic benchmark. GPT-5.6-luna beats it on both Terminal-Bench 2.1 (terminal/shell-based agentic tasks) and MCP-Atlas (an MCP-tool-calling benchmark), by margins of roughly 4-5 points each. Pokee-Isaac's advantage is concentrated in BFCL v4 function-calling accuracy and τ³-bench multi-domain agent tasks — both benchmarks that lean more on structured tool-use correctness and sustained context tracking, which lines up with the model's long-context architecture story.
Security: DTAP red-teaming benchmark
| Metric | Pokee-Isaac 28B | GPT-5.6-luna | Gemini 3.5 Flash Lite | Claude Haiku 4.5 | Nemotron-3-Super-120B | Qwen3.5-122B |
|---|---|---|---|---|---|---|
| Attack success rate (lower = better) | 35.6 | 50.1 | 66.3 | 37.9 | 60.4 | 54.0 |
| Benign success rate (higher = better) | 82.5 | 85.1 | 83.3 | 71.3 | 63.3 | 79.4 |
Pokee-Isaac posts the lowest attack success rate in the comparison — meaning it's the hardest of the six models to jailbreak or prompt-inject in Pokee's own red-teaming tests — while trailing GPT-5.6-luna slightly on benign success rate (correctly complying with legitimate requests). Claude Haiku 4.5 is notably weak on both axes in this particular chart, which is worth flagging as unusual given Anthropic's general safety-focused positioning — a reminder that any single vendor's red-team suite measures its own threat model, not a universal standard.
Why does single-GPU deployment matter here?
A 10M-token context window is only interesting if you can actually afford to run it. The standard approach to long context — attention over the full sequence — scales quadratically in compute and memory, which is exactly why most frontier labs cap effective context well below their advertised maximum and lean on retrieval-augmented workarounds instead. Running that much context typically demands multi-GPU inference clusters with expensive interconnects.
Pokee AI's claim that Pokee-Isaac runs "deployable on a single GPU (starting from RTX 4090 or equivalent)" — with the flagship 137K-tokens/second prefill figure coming from a single B200 at full 10M context — is the deployment claim that makes the benchmark claim matter in practice. This is the same theme explainx.ai has been tracking with on-device and single-GPU agentic models generally: Liquid AI's LFM2.5-2.6B, released the same week, makes a parallel argument at a completely different scale — a 2.6B model that fits under 2.5GB and runs on a phone. Pokee-Isaac is 28B parameters and needs a discrete GPU rather than a phone CPU, but the underlying pitch is identical: you don't need a frontier lab's cluster to run frontier-class capability.
The "non-decoder-only" architecture is the load-bearing claim behind that pitch. Standard transformer decoders keep a KV cache that grows linearly (at minimum) with sequence length, which is the direct mechanical reason a 10M-token window normally requires either enormous memory or heavy compression that degrades recall — exactly the failure mode showing up as those 0.0 RULER scores past 2M tokens for every other model in Pokee's chart. Whatever architectural change lets Pokee-Isaac avoid that scaling is the actual engineering story here, and it's one the tweet-length announcement gestures at without fully explaining — the deeper mechanism lives in Pokee's technical report at console.pokee.ai, which is the place to look for the real architectural detail rather than the announcement thread.
How legitimate is a new company's own benchmark claims?
Pokee AI's chart is labeled, in its own words, "SOURCE: INTERNAL BENCHMARK SUMMARY." That's a meaningfully different evidentiary bar than a third-party leaderboard result, and it's the same caveat explainx.ai applied to Black Forest Labs' own preference numbers for FLUX 3 — a company benchmarking its own model against a set of competitors it chose, using tests it ran, is not neutral evidence, even when the methodology is sound.
A few things are worth weighing before taking the numbers at face value:
- The comparison set is Pokee's choice. GPT-5.6-luna, Gemini 3.5 Flash Lite, Claude Haiku 4.5, Nemotron-3-Super-120B, and Qwen3.5-122B are all reasonably positioned mid-tier or efficient models — not the largest flagship reasoning models from each lab. A company optimizing for a favorable comparison chart would pick exactly this tier: capable enough to be a credible comparison, but not the absolute frontier.
- Some 1M-context numbers are sourced externally, per the chart's own footnote — meaning not every cell in that table was run by Pokee under identical conditions, which introduces methodology variance the chart doesn't fully disclose.
- The RULER-past-2M story is the hardest claim to fake or misreport, because a 0.0 score for every competitor is a stark, binary result rather than a marginal edge — if independent testers can't reproduce those zeros, or find competitors handle 4M-10M context better than Pokee's numbers suggest, that's the first place scrutiny should land.
- The company itself is credible on paper — Pokee AI's founder, Zheqing (Bill) Zhu, led Applied Reinforcement Learning at Meta AI and holds a Stanford PhD in reinforcement learning, and the $12M seed round from Point72 Ventures, Qualcomm Ventures, SCB10X, and Samsung NEXT (July 2025) suggests institutional diligence happened before this release, even if that's not the same as independent benchmark verification.
The honest read: Pokee-Isaac 28B's long-context story is the most differentiated and specific claim in the release — a flat 0.0 for every other model past 2M tokens is not a subtle margin, and if that reproduces under outside testing it's a genuinely notable result. The agentic benchmark comparisons (BFCL v4, τ³-bench, Terminal-Bench, MCP-Atlas) are closer contests where Pokee-Isaac wins two and loses two, which reads more like an honest snapshot than a cherry-picked sweep. Until an independent lab or evaluator runs its own pass, though, every number in this post should be read as "Pokee AI says," not "verified."
How does it compare to running Liquid AI's on-device models?
These two same-week releases sit at opposite ends of the "run it yourself" spectrum, and comparing them clarifies what each is actually optimizing for.
| Pokee-Isaac 28B | Liquid AI LFM2.5-2.6B | |
|---|---|---|
| Parameters | 28B | 2.6B |
| Context window | Up to 10M tokens (claimed) | 128K tokens |
| Minimum hardware | Single discrete GPU (RTX 4090+) | Phone CPU, laptop, or PC |
| Deployment | VPC, on-prem, or on-device via vLLM/SGLang | llama.cpp, MLX, vLLM, SGLang, ONNX |
| Pricing (API) | $0.15/M in, $1.00/M out | Open weights — no API cost, self-hosted |
| Core pitch | Frontier-class long-context reasoning, off the cloud | Zero-marginal-cost agentic tool use, fully local |
If the task is "hold an entire codebase or year of logs in context and reason across all of it," Pokee-Isaac's pitch is the relevant one — nothing in LFM2.5-2.6B's 128K window comes close to that scale. If the task is "run a bounded, tool-calling agent with zero cloud dependency and zero marginal cost per call," Liquid AI's approach is the better fit — a 28B model, even on one GPU, is a meaningfully bigger and more expensive footprint than a sub-3B model that fits in 2.5GB. Neither model is "open weights" in the fully open sense Pokee-Isaac ships as an API and self-hosted deployment option rather than a downloadable checkpoint on Hugging Face, which is worth noting for teams that specifically want to inspect or fine-tune the weights themselves.
What people are asking
Is Pokee-Isaac 28B open source? Not in the open-weights sense. Pokee AI offers API access and self-hosted deployment (own VPC, on-premises, or on-device) with Day-0 support for vLLM and SGLang, but the announcement doesn't indicate the weights are published for public download the way Liquid AI's or Nemotron's are.
Does the 10M-token context actually cost more to run? Pokee's flat per-token pricing ($0.15/$1.00 per million) doesn't change with context length in the announcement, but prefill compute — and therefore latency — scales with how much context you actually fill. The 137K tokens/second prefill figure is specifically measured at full 10M-token context on a B200, which is Pokee's answer to "yes, we tested the worst case, not just the empty-context best case."
Why does Pokee AI call this "non-decoder-only"? That phrasing signals a departure from the standard transformer decoder architecture nearly every frontier LLM uses, which is the direct cause of the linear-or-worse KV cache growth that makes multi-million-token context expensive. The deeper mechanism is described in Pokee's technical report rather than the announcement tweet.
How new is Pokee AI as a company? Very — founded in 2024, with its only prior public funding milestone being a $12M seed round in July 2025. Pokee-Isaac 28B is the company's first frontier-class model release, which is exactly why the "internal benchmark summary" label on its comparison chart deserves more scrutiny than a similar chart from a lab with a longer independent-verification track record.
The takeaway
Pokee-Isaac 28B's most credible claim is also its most specific one: a flat 0.0 RULER score for five competitor models past 2M tokens, against Pokee-Isaac holding above 93% all the way to 10M, is not a marginal benchmark win — it's a binary, easily falsifiable claim that independent testing will either confirm or puncture quickly. The single-GPU deployment story matters because it's what makes that context window practically usable rather than a lab-only curiosity, continuing the same "frontier capability without a frontier cluster" trend explainx.ai has tracked across LFM2.5-2.6B's on-device agents and Nemotron-3-Super-120B. The honest caveat sits right on the chart itself: this is Pokee AI's own internal benchmark summary, from a company that shipped its first frontier model this week — worth taking seriously, not yet worth taking as verified.
Related on explainx.ai:
- Context Window Pricing Decoded
- Claude Code Context Window Limit Management
- Liquid AI LFM2.5-2.6B: On-Device Agent Model
- NVIDIA Nemotron-3-Ultra 550B MoE Open-Weight Model
- Cursor Mixture-of-Kittens: MoE Megakernel
- What Is MCP (Model Context Protocol)?
Official: Pokee AI · Pokee-Isaac 28B technical blog · Technical report (PDF) · Pokee API console
Benchmark numbers, pricing, and hardware figures reflect Pokee AI's own reported "internal benchmark summary" as of the August 4, 2026 release, and may change as the model is updated or independently verified.