Pokee-Isaac 28B is a 28-billion-parameter AI model from Pokee AI that claims to process up to 10 million tokens of context on a single NVIDIA B200 GPU — and to do so while charging $0.15 per million input tokens via its API. The headline number is real, at least on paper: it scored 93.3% on the RULER long-context benchmark at 10 million tokens, where every other comparable model from GPT-5.6 Luna to Gemini 3.5 Flash Lite either hit context-overflow errors or scored zero. But the weights are not public, the architecture is undisclosed, all benchmarks are vendor-run, and coding was deliberately not trained. For businesses that need local, long-context AI agents — regulated industries, sovereign deployment, or teams tired of per-token pricing — it is the most interesting release of August 2026. For everyone else, it is a promising claim awaiting independent verification.
TL;DR
- Pokee-Isaac 28B: a 28B parameter, non-decoder-only model fine-tuned from Qwen3.6-27B (Confirmed — Pokee AI technical report)
- Context window: 10 million tokens (Vendor claim; 93.3% RULER at 10M — vendor-run, no third-party verification yet)
- Deployable on a single NVIDIA B200; also runs on Intel Arc Pro B70 and Qualcomm Snapdragon X2 Elite (Vendor claim)
- API pricing: $0.15 / $1.00 per million input/output tokens (Confirmed — Pokee API docs)
- Weights: proprietary, not published; coding not a training priority
- Last verified: 2026-08-05 · Pricing and limits are volatile — confirm before deploying.
What is Pokee-Isaac 28B?
Pokee-Isaac 28B is a proprietary AI model released by Pokee AI on August 3, 2026. It is described in its technical report as a "non-decoder-only foundation model" — meaning it does not use the standard decoder-only transformer architecture that powers GPT, Claude, and most other LLMs. The specific architecture has not been disclosed. Some weights are fine-tuned from Qwen3.6-27B (Apache 2.0 license), but Isaac itself remains proprietary.
The model was built for three things: long-context reasoning (up to 10M tokens), agentic tool use, and local deployment inside customer-controlled boundaries (VPC, on-premises, or on-device). Pokee AI, headquartered in Bellevue, Washington, positions it specifically for regulated and sovereign-deployment scenarios where data cannot leave the customer boundary — a use case we explored in our sovereign AI enterprise guide.
How does 10 million tokens actually work?
The KV cache problem — and why most models stop at 1M
In a standard decoder-only transformer, every token in the context generates key-value (KV) cache entries that the model stores in GPU memory to speed up subsequent predictions. The larger the context, the larger the KV cache. At 10 million tokens, a conservative estimate puts KV cache alone at 500+ GB — far beyond what any single GPU holds in VRAM. This is the core reason no frontier model currently offers more than 1 million tokens of usable context through a commercial API: the attention mechanism's O(n²) computational complexity and the linear growth of KV cache make it prohibitively expensive.
Pokee-Isaac's technical report claims it solves this through its "non-decoder-only" architecture, but it does not explain how. The report confirms the model runs on a single NVIDIA B200 (which has 192 GB of HBM3e memory) and that prefill throughput actually increases from 42,400 tokens/s at 1M context to 137,200 tokens/s at 10M context — a counterintuitive result that suggests the model is not doing full KV caching at the full context length. Whether this involves linear attention, state-space components, context compression, or a hybrid approach is unknown.
RULER benchmark: 93.3% at 10 million tokens
The RULER benchmark (Hsieh et al., 2024) tests whether a model can retrieve specific information planted in a long document — the "needle in a haystack" test, scaled to extreme lengths. Pokee-Isaac's results, as reported in its own technical report:
| Model | 256K | 512K | 1M | 2M | 4M | 10M |
|---|---|---|---|---|---|---|
| Pokee-Isaac 28B | 96.9% | 96.7% | 95.0% | 95.8% | 96.7% | 93.3% |
| GPT-5.6 Luna | 95.0% | 91.4% | 0.0%* | 0.0% | 0.0% | 0.0% |
| Gemini 3.5 Flash Lite | 94.5% | 94.6% | 29.4%* | 0.0% | 0.0% | 0.0% |
| Claude Haiku 4.5 | 0.0% | 0.0% | 0.0% | 0.0% | 0.0% | 0.0% |
| Nemotron 3 Super 120B | 96.3%ˢ | 95.7%ˢ | 91.8%ˢ | 0.0% | 0.0% | 0.0% |
| Qwen 3.5 122B | 0.0% | 0.0% | 0.0% | 0.0% | 0.0% | 0.0% |
*Context-overflow error. ˢSelf-reported by vendor.
Source: Pokee-Isaac 28B Technical Report, Table 1
Isaac is the only model that sustains retrieval accuracy beyond 1 million tokens. The zeros for other models are not purely capability failures — three of the five comparison models hit context-overflow errors at 1M+ and could not complete the test. Nemotron 3 Super 120B's scores at 256K–1M are NVIDIA's own self-reported figures, not independently measured by Pokee.
The MRCR v2 catch: retrieval is not reasoning
The MRCR v2 (Multi-Round Coreference Resolution) benchmark is harder than RULER because it inserts multiple "needles" and requires the model to disambiguate among them — a test of multi-target reasoning, not single-target retrieval. Isaac scores 0.607 at 256K and drops to 0.500 at 1M. The report does not provide MRCR results beyond 1M, so there is no evidence of multi-needle disambiguation at 2M, 4M, or 10M.
This distinction matters for real-world use. Finding one specific clause in 10,000 pages of contracts (RULER-shaped task) is very different from synthesizing contradicting terms across 10,000 pages. For the former, Isaac's numbers are strong. For the latter, the evidence is thin.
How fast is it, and on what hardware?
Pokee-Isaac's serving profile on a single NVIDIA B200:
| Context | Concurrency | Time to First Token | Prefill (tok/s) | Decode (tok/s) |
|---|---|---|---|---|
| 1M | 1 | 23.6s | 42,400 | 335 |
| 1M | 4 | 49.3s | 81,200 | 322 |
| 10M | 1 | 72.9s | 137,200 | 337 |
Source: Pokee-Isaac 28B Technical Report, Section 5.1
Key observations:
- At 10M tokens, the model takes about 73 seconds to produce its first output token — under 90 seconds for the equivalent of ~15,000 pages of text.
- Decode speed holds flat at ~337 tokens/s regardless of context size, which is architecturally unusual for standard transformers.
- The B200 is a data-center-class Blackwell GPU, not consumer hardware. The claim of "starting from RTX 4090 or equivalent" in Pokee AI's launch announcement refers to smaller-context deployments, not the full 10M window.
Pokee also reports running on Intel Arc Pro B70 (a client-class GPU) with 3.6–5× prefill throughput improvement over stock llama.cpp, and on Qualcomm Snapdragon X2 Elite for edge deployment. These are vendor-reported numbers from the technical report.
What does it cost?
Pokee offers two API tiers:
| Model | Input (\(/M tokens) | Output (\)/M tokens) | Cache Read ($/M tokens) | |
|---|---|---|---|
| pokee-isaac-high-reasoning | $3.00 | $15.00 | $0.30 |
| pokee-isaac | $0.30 | $5.00 | $0.10 |
Source: Pokee Enterprise API — Models and pricing
The technical report also lists provisional pricing of $0.15 per million input tokens and $1.00 per million output tokens for the managed API, noted as "provisional and subject to confirmation at launch." The API docs page shows $0.30 / $5.00 as the standard tier rate — the discrepancy likely reflects a promotional or early-access rate versus the listed price. For comparison with frontier models at long context:
| Model | Max Context | Input $/M | Output $/M |
|---|---|---|---|
| Pokee-Isaac 28B (report rate) | 10M | $0.15 | $1.00 |
| Pokee-Isaac (API docs rate) | 10M | $0.30 | $5.00 |
| GPT-5.6 Luna (>272K context) | 1M | $0.40 | $1.80 |
| Gemini 3.5 Flash Lite | 1M | $0.30 | $2.50 |
Source: Pokee-Isaac 28B Technical Report, Table 9
At the technical report's provisional rate, Isaac is cheaper than both GPT-5.6 Luna and Gemini 3.5 Flash Lite while offering 10× more context. Even at the API docs rate, it is price-competitive at $0.30 input (matching Gemini Flash Lite) with a higher output cost but a dramatically larger context window. For teams currently routing between cheap and expensive models based on context length — a pattern we covered in our DeepSeek vs Claude Opus cost-routing guide — Isaac's flat pricing across 10M tokens could simplify that decision.
The bigger value proposition for enterprises: when deployed inside a VPC or on-premises, the cost becomes a fixed function of the hardware provisioned, not a variable per-token charge. That converts the most expensive long-context workloads into a predictable line item.
What are the agentic benchmarks?
Pokee-Isaac was built as an agent model, not a general-purpose chatbot. The technical report benchmarks it across four agentic evaluations:
1. BFCL v4 (Berkeley Function Calling Leaderboard)
Isaac scores 70.94 overall, narrowly edging GPT-5.6 Luna (70.61) and Claude Haiku 4.5 (67.52). The scoring formula weights agentic execution (40%), multi-turn tool use (30%), and live/non-live/hallucination metrics (10% each). Isaac's strongest sub-categories: live parallel calling (93.8%), memory vector retrieval (74.2%), and multi-turn base (77.5%).
Source: Pokee-Isaac 28B Technical Report, Section 3 · BenchLM independently tracks this at 70.9% against the field
2. τ³-bench (Multi-Turn Interactive Tasks)
Isaac leads the four-domain average at 0.662, with its strongest performance in retail (0.789) and telecom (0.912). In the banking domain — the hardest, with 698 documents and 195K tokens of context — Isaac ties GPT-5.6 Luna at 0.186 while Gemini 3.5 Flash Lite leads at 0.203.
3. MCP-Atlas (Multi-Server Tool Orchestration)
This test runs 500 tasks against 36 real production MCP servers (GitHub, Slack, Google Workspace, Notion, and others). Isaac ranks third at 74.59% claim coverage, behind GPT-5.6 Luna (77.90%) and Gemini 3.5 Flash Lite (76.67%). The notable finding: Isaac completes tasks in an average of 9.10 turns per task versus Gemini's 14.99 — roughly 40% fewer steps for comparable coverage, which translates to lower token consumption per agent task.
4. Terminal-Bench 2.1 (Shell Execution)
Isaac ranks second at 65.1% (56 of 86 text-compatible tasks), behind GPT-5.6 Luna at 69.8% (60/86). It leads open-weight models by a wide margin — Qwen 3.5 122B and Gemini 3.5 Flash Lite both scored 46.5%, and Nemotron 3 Super 120B scored 24.4%.
The agentic results paint a consistent picture: Isaac is competitive with, not decisively superior to, frontier cloud models on agent tasks. Its advantage is that it achieves this parity at 28B parameters on a single GPU, not that it beats GPT-5.6 Luna or Gemini 3.5 Flash Lite on every benchmark. For teams building agent systems — something we cover in our agent OS guide for businesses — the deployment economics matter as much as raw capability.
What about security and privacy?
Pokee's technical report includes a DTAP red-teaming benchmark across 12 Linux-Docker domains with 6,195 judged tasks. Isaac reports the lowest combined attack success rate (ASR) at 35.6%, compared to GPT-5.6 Luna (50.1%), Gemini 3.5 Flash Lite (66.3%), and Claude Haiku 4.5 (37.9%). Its direct/indirect ASR balance is notable: only 0.8 points between direct (36.0) and indirect (35.2) attack vectors, versus 13–38 point gaps for other models, suggesting it is not simply refusing everything to look safe.
Security features include in-boundary operation (the model never sends data externally), policy-aware tool use with deny-by-default behavior, and structured audit logging. The API docs confirm that Pokee does not persist inference prompts in its own storage, retains only metadata (token counts, timestamps, model, API key ID), and does not use prompt data for training.
What are the limitations?
No independent verification. All seven benchmark rows tracked by BenchLM are labeled "Provider exact" — they come from Pokee AI's own technical report, not from independent third-party evaluation. BenchLM notes the model is "tracked, but not publicly ranked yet" due to insufficient non-generated coverage.
Coding is not trained. The technical report explicitly states: "Coding is not a training priority for our first-ever Pokee-Isaac model and this report does not evaluate it directly." The Terminal-Bench results are shell-execution tasks, not code-authoring benchmarks. If your use case is AI-assisted coding — the kind of work we cover in our multi-model coding workstation guide — Isaac is not the right tool yet.
Architecture is undisclosed. The report confirms "non-decoder-only" but does not reveal whether the model uses state-space components, linear attention, context compression, or some hybrid. Without understanding the architecture, the long-context claims cannot be independently validated or reproduced.
Text-only. Isaac does not process images, audio, or video. Llama 4 Scout, the other 10M-context model, is natively multimodal. This limits Isaac to text-based agentic workloads.
Weights are proprietary. Unlike Llama 4 Scout (available under the Llama 4 Community License) or Qwen models (Apache 2.0), Isaac cannot be downloaded, inspected, or fine-tuned by third parties. The base model it was fine-tuned from — Qwen3.6-27B — is open-weight, but Isaac's modifications are not.
Single-GPU means data-center GPU. "Single GPU" refers to a single NVIDIA B200 (data center class). Running 10M context on consumer hardware like an RTX 4090 is not confirmed for the full context window — the launch tweet's "starting from RTX 4090" likely refers to smaller-context or quantized deployments.
How does it compare to Llama 4 Scout?
Llama 4 Scout is the only other model with a 10 million token context window. The comparison reveals two fundamentally different approaches:
| Feature | Pokee-Isaac 28B | Llama 4 Scout |
|---|---|---|
| Parameters | 28B (dense) | 109B total / 17B active (MoE) |
| Architecture | Non-decoder-only (undisclosed) | Decoder-only MoE |
| Context window | 10M tokens | 10M tokens |
| RULER at 10M | 93.3% (vendor-run) | Not published at 10M |
| Multimodal | Text-only | Text + image |
| Weights | Proprietary | Open (Llama 4 Community License) |
| Deployment | API, VPC, on-prem, on-device (Intel/Qualcomm) | Self-hosted (fits on single H100 at Int4) |
| Input pricing | $0.15–$0.30/M tokens | ~$0.15–$0.30/M tokens (self-hosted infra cost) |
| Coding | Not trained | Supported |
Sources: Pokee-Isaac technical report · Meta Llama 4 model card
The key difference: Scout is open-weight and multimodal; Isaac is proprietary but optimized for on-device edge deployment across heterogeneous silicon (Intel, Qualcomm, AMD coming). Scout is the better choice for teams that want model ownership and multimodal. Isaac is the better choice for teams that need a managed local agent with long context and cannot ship data to a cloud API. For a deeper look at the open-vs-proprietary split in AI, see our open-weight AI strategy analysis.
What this means for you
If you are a regulated business (finance, healthcare, legal, government): Pokee-Isaac's value proposition is aimed squarely at you. The ability to run an agent with 10M tokens of context inside your own VPC or on-premises — without sending data to OpenAI, Anthropic, or Google — solves a real procurement problem. The $0.15/$1.00 per-token API rate (if it holds at launch) is below cloud frontier rates, and the fixed-cost local deployment model eliminates the variable pricing that makes long-context workloads budget-unpredictable. But wait for independent benchmark verification before committing.
If you are a developer building AI agents: Isaac's MCP-Atlas efficiency — completing tasks in 9.10 turns versus Gemini's 14.99 — is the most interesting number for agent builders. Fewer turns means fewer tokens, which means lower cost per task. The BFCL v4 score (70.94) is competitive but not category-leading. Try it for tool-use-heavy workloads where context length and turn efficiency matter more than raw reasoning.
If you are looking for a coding model: Skip Isaac for now. Pokee's own technical report says coding was not a training priority and is not benchmarked. Stick with Claude, GPT-5.6, or open-weight options like Qwen3.8-Max for code generation.
If you are running local LLMs on consumer hardware: The model fits on a single B200 (data-center class), not an RTX 4090 for the full 10M context. Pokee's edge portability to Intel Arc Pro B70 and Qualcomm Snapdragon X2 Elite is real, but the context lengths achievable on client-class silicon have not been independently verified. For free local model setups, our Kimi K3 local deployment guide covers models you can actually run today.
Should you use it or wait?
The honest answer: Isaac is the most architecturally interesting model release of August 2026, and the benchmarks — if independently verified — would make it the best long-context agent for local deployment. But "if independently verified" is doing heavy lifting. Every benchmark is vendor-run. The architecture is undisclosed. The weights are proprietary. The coding gap is acknowledged. And the pricing discrepancy between the technical report ($0.15/$1.00) and the API docs ($0.30/$5.00) suggests the numbers are still settling.
The right move is to sign up for the API (300 free developer credits at sign-up), test it on your actual workload, and treat the published benchmarks as a floor, not a ceiling. If your use case is long-context retrieval on text data that cannot leave your network, Isaac has no direct competitor right now. If your use case is coding, multimodal, or general-purpose reasoning, the existing frontier models remain the safer bet.
FAQ
Q: Is Pokee-Isaac 28B open source? A: No. The model is proprietary. Some weights were fine-tuned from Qwen3.6-27B (Apache 2.0), but the full Isaac model, including its architecture details, has not been published. You can access it via Pokee's API or through enterprise deployment (VPC, on-premises, on-device).
Q: Can you run 10 million tokens of context on an RTX 4090? A: Not confirmed. The full 10M context has been demonstrated on a single NVIDIA B200 (data-center class with 192 GB HBM3e). Pokee's launch tweet mentions "starting from RTX 4090 or equivalent" but this likely refers to smaller-context or quantized deployments, not the full 10M window. Edge deployment on Intel Arc Pro B70 and Qualcomm Snapdragon X2 Elite is reported but context lengths on these platforms are not specified.
Q: How does Pokee-Isaac compare to Llama 4 Scout for long context? A: Both claim 10 million token context windows. Isaac is a 28B dense model with a proprietary non-decoder-only architecture, text-only, with published RULER scores at 10M (93.3%, vendor-run). Scout is a 109B MoE model (17B active) with open weights, native multimodal (text + image), and fits on a single H100 at Int4. Scout has not published RULER results at 10M tokens. Isaac is better for local agentic deployment in restricted environments; Scout is better if you need open weights, multimodal, or coding.
Q: Does Pokee-Isaac support coding tasks? A: Not well. The technical report explicitly states coding is not a training priority for this version and that it is not directly evaluated. Terminal-Bench 2.1 tests shell execution (system administration, file operations), not code authoring. Pokee says coding is "the most commercially significant of the domains we did not prioritize" and that closing the gap is a priority for the next version.
Q: What does "non-decoder-only" architecture mean? A: Most modern LLMs (GPT, Claude, Gemini, Qwen) are decoder-only transformers — they generate text token-by-token using self-attention. A "non-decoder-only" model could incorporate encoder components, state-space models (like Mamba), linear attention, or other architectures. Pokee has not disclosed what specific approach Isaac uses, which makes independent validation difficult. The report's prefill throughput numbers (rising from 42K to 137K tokens/s as context goes from 1M to 10M) suggest the model is not doing standard full-attention KV caching.
Q: What is the Pokee-Isaac API pricing?
A: The technical report lists provisional pricing of $0.15 per million input tokens and $1.00 per million output tokens. The API documentation lists two tiers: pokee-isaac at $0.30/$5.00 and pokee-isaac-high-reasoning at $3.00/$15.00 per million input/output tokens. The report notes prices are "provisional and subject to confirmation at launch." New developer accounts include 300 free credits ($3.00 equivalent).
Q: Should I wait for independent benchmarks before deploying Pokee-Isaac? A: For production-critical workloads, yes. All benchmark results are vendor-sourced as of August 5, 2026 (confirmed by BenchLM's independent tracking). For experimentation and prototyping, the 300 free credits are enough to test on your own data. The MCP-Atlas efficiency numbers (9.10 turns per task) and the RULER scores at 10M are the most important claims to verify against your actual workload.
Discussion
0 comments