πΌοΈ POCKET-Image β the POCKET series goes visual: character-perfect text in any language, on-device
A new model in VIDRAFT's POCKET family. POCKET put 35B-class models on phones and no-GPU PCs. POCKET-Image carries the same "big capability, small hardware" idea into image generation β and fixes the one thing nearly every image model gets wrong: text.
What it is: β’ 100% accurate text, any language β where global models produce gibberish β’ Any background from a prompt β text is optional (empty β a pure image) β’ No GPU, no NPU β runs on plain CPU + RAM via the POCKET-Core engine β’ Measured footprint: 8.6 GB (RTX 3050/4060) Β· 4.5 GB (offloaded, 6 GB cards) Β· 13.4 GB (MacBook, 16 GB+) β’ Windows Β· macOS Β· Linux Β· fully local, no cloud
Built on the open, commercial-friendly Z-Image (Apache-2.0) foundation.
Honest note: the text is the guaranteed-correct part β the surrounding scene is ordinary generation, so a busy foreground can crowd the letters. We say so; clean backgrounds stay razor-sharp.
πΌοΈ POCKET-Image β the POCKET series goes visual: character-perfect text in any language, on-device
A new model in VIDRAFT's POCKET family. POCKET put 35B-class models on phones and no-GPU PCs. POCKET-Image carries the same "big capability, small hardware" idea into image generation β and fixes the one thing nearly every image model gets wrong: text.
What it is: β’ 100% accurate text, any language β where global models produce gibberish β’ Any background from a prompt β text is optional (empty β a pure image) β’ No GPU, no NPU β runs on plain CPU + RAM via the POCKET-Core engine β’ Measured footprint: 8.6 GB (RTX 3050/4060) Β· 4.5 GB (offloaded, 6 GB cards) Β· 13.4 GB (MacBook, 16 GB+) β’ Windows Β· macOS Β· Linux Β· fully local, no cloud
Built on the open, commercial-friendly Z-Image (Apache-2.0) foundation.
Honest note: the text is the guaranteed-correct part β the surrounding scene is ordinary generation, so a busy foreground can crowd the letters. We say so; clean backgrounds stay razor-sharp.
POCKET now speaks Gemma 4 β a 26B model that loads in every app, and runs on your PC with no GPU
We're adding a Gemma-4 sibling to POCKET: POCKET-26B, built from Google's Gemma-4-26B-A4B (Apache-2.0). Our flagship POCKET-35B is a Qwen-family MoE and needs a recent llama.cpp; POCKET-26B trades a little size for the thing people kept asking for β it just loads, everywhere, today: Ollama, LM Studio, PocketPal, MLX, any stock llama.cpp. No fork, no bleeding-edge runtime, no CUDA, no cloud.
It's a sparse Mixture-of-Experts (25.2B total, ~4B active per token), so the work per token stays small β a real 26B that generates on a CPU with no graphics card.
Two things make it stand out:
1) Universal compatibility. Gemma 4 is a standard, widely-supported architecture, so POCKET-26B runs on the tools you already have β no waiting for your app to add a new model type.
2) Quality that survives compression. Measured GPQA-Diamond (198 q, greedy): β’ Full base: 67.7% β’ POCKET-26B Q4_K_M (17 GB): 67.7% β lossless β’ POCKET-26B Q2_K (11 GB): 67.2% β near-lossless, at 11 GB
Live, on a CPU-only box (our demo Space β POCKET-26B vs Bonsai-27B, same machine, same stock llama.cpp): POCKET-26B β 19 tok/s vs Bonsai β 6 tok/s β about 3Γ faster generation, no GPU. (Honest notes: shared CPU box, sequential race; a dedicated machine is faster.)
Where it fits in the family: β’ POCKET-35B (Qwen MoE) β bigger, top-tier, needs a recent llama.cpp. β’ POCKET-26B (Gemma 4) β loads in any app, quality-robust when compressed. The demo runs the Q4_K_M build; Q2_K (11 GB) is the smallest footprint. For a true β€8 GB phone, the 5 GB POCKET-KR (Qwen) is still the pick.
π± POCKET β a 35-billion-parameter model that runs on your iPhone, and on your PC with no GPU
We're releasing POCKET, VIDRAFT's flagship Darwin-36B-Opus compressed for on-device use. No fork, no CUDA, no cloud β it runs on stock llama.cpp. It's a sparse Mixture-of-Experts model (256 experts, only 8 active per token), so the file can be large while the work per token stays small. That's what lets a 35B model run on a phone, and generate fast on a CPU with no graphics card.
Measured (POCKET-35B IQ1_M vs Bonsai-27B Q1_0): β’ CPU generate (Xeon, 16 threads): 27.0 vs 10.1 tok/s β 2.69Γ faster β’ GPU generate (H100): 197 vs 89 tok/s β 2.22Γ faster β’ GPU prompt processing (H100): 753 vs 1816 β 0.41Γ (Bonsai wins this one β MoE prefill wakes every expert, so sparsity stops helping there. We say so.) β’ Quality (HellaSwag, 400 q): 61.0% vs 60.0% β a tie (confidence intervals overlap)
On a real consumer laptop β MacBook M3 Pro (18 GB) β POCKET wins every axis, prompt processing included: β’ Metal generate: 25.4 vs 12.8 β 1.99Γ β’ CPU generate: 13.8 vs 4.4 β 3.13Γ β’ Metal prompt: 240.7 vs 73.4 β 3.28Γ
One more quiet fact: the same-size, quality-oriented rival Ternary-Bonsai-27B (7.2 GB) fails to load in upstream llama.cpp at all β it needs the PrismML fork. POCKET runs on the tools you already have: LM Studio, Ollama, PocketPal, MLX.
A small gift for anyone building or studying foundation models.
Most "open" models hand you the weights and stop there. With Aether-7B-5Attn we wanted to hand over the whole thing β so you can actually learn from it, reproduce it, and build on it: the data recipe, the training code, every hyperparameter, the complete logs, and the intermediate checkpoints. All Apache-2.0, reproducible byte-for-byte.
What you can do with it: π Rebuild it from scratch, or fork the recipe for your own model π¬ Study a real heterogeneous-attention MoE β 49 layers place 5 attention mechanisms on a 7Γ7 Latin square, arranged as a clean, attributable ablation π Trace training dynamics across the released checkpoints (110k / 115k / 162k)
It's a modest 6.59B model, and an honest one β the limitations (no KV-cache in this build, small scale) are written right in the card. We're not claiming it's special. If any piece of it saves you time or teaches you something, that's exactly what we hoped for. π€
"Frontier models need a datacenter GPU" rests on a hidden assumption: that the model reads ALL its parameters every token. Decode is memory-bandwidth bound β sweep 34B params/token and an 8 GB card dies at 1β2 tok/s.
So we ran ONE 34.7B reasoning model β Ourbox-35B-JGOS, a sparse Mixture-of-Experts β as the identical weights across the whole hardware spectrum. All measured:
Why it works: Ourbox holds 34.7B params but only ~3B are active per token (256 experts, top-8). Since decode is bandwidth-bound, a dense 34B moves ~16.7 GB/token while Ourbox moves ~1.45 GB β ~11Γ less traffic. Put the experts in system RAM, keep attention/router/shared on the GPU, and a 34.7B reasoner runs on an 8 GB laptop β or no GPU at all.
Sparsity alone, proven (same laptop, same quant, ~same footprint): Ourbox-35B (A3B) 20.01 tok/s vs Qwen2.5-32B (dense) 5.36 β 3.7Γ from sparsity alone, ~2Γ the best dense-32B on any 8 GB machine. Not a toy: GPQA Diamond 86.4% (maj@8).
Try it live (same prompt, GPU vs GPU-less CPU, live tok/s). Honest scope: one machine's measurements; the CPU path proves it RUNS without a GPU, not that it beats one.
π We ran genuine quantum key-recovery on 'real IBM quantum hardware' β and pushed the frontier well past the largest hardware demos we're aware of (which sat at N=4).
Using Simon's algorithm on ibm_kingston, we recovered the secret key of two symmetric-cipher structures: β’ EvenβMansour β N=5 β N=10 β’ 3-round Feistel (DES-family) β block 6 β 8
Each verified against an 'independent control key', using error mitigation only (no QEC).
π§ Honest scope: this is not a quantum speedup (the effective difficulty tracks the classical birthday bound ~2^{n/2}), not a break of real AES/RSA, and not 16-round DES (ours is 3-round). The recovery method is reserved for a forthcoming paper; formal record status is pending peer review.
AI is usually framed as "how smart is the model / how many GPUs did you buy." The real bottleneck is elsewhere β how efficiently you use the GPUs you already have.
Training happens once; inference runs the entire time users use your product. So a service's economics come down to cost per token. Inference acceleration uses software to pull several times more out of the same GPU β the effect of plugging in one more "virtual GPU."
VIDRAFT's VKAE, measured (B200, same-harness, no quality loss):
Qwen3.5-35B-A3B (MoE): 25.7 β 601 tok/s (23.4Γ) Darwin-36B-Opus (in-house MoE): 25.0 β 280.8 (11.2Γ) 10,000+ tok/s peak aggregate under concurrency The key: it's reproducible β model + serving shipped as one container.
docker pull vidraft/qwen35-vkae:601 Don't take our word for it β run it yourself. The mechanism will be released as a paper.
π§ Does your LLM know when it's about to be wrong?
Most leaderboards measure accuracy. We measure metacognition β whether a model catches its own errors. Benchmark + leaderboard + adapters, all open. π
The surprise: even a K-AI #1 model (JGOS-31B-Citizen) is the strongest on multiple-choice traps (trap_rate 0.005 β ~2 misses in 400) yet blind to its own free-form mistakes (self-confidence AUROC = 0.5, pure random). A tiny base-frozen adapter recovers that signal.
Two independent axes (never compared across a row): β trap_rate β does it fall for tempting trap options? (lower = stronger) β‘ adapter gain Ξ β how much a lightweight adapter catches errors the model itself misses. (higher = more adapter value)
π― Chitos β The Security Scanner That Actually Proves It
Most security scanners hand you a suspect list and walk away. That gap between detection and proof is where attackers live β and it's exactly the gap that Chitos was built to close.
Chitos is the successor to Mythos, a static analyzer built for quick code health checks. Mythos was good at pattern matching β spotting dangerous sinks, mapping CWEs, producing readable reports. But static analysis has a structural ceiling. A rule that sees eval(user_input) can tell you that looks dangerous. It cannot tell you whether the input is reachable, whether sanitization three layers up covers this path, or whether there's a live exploit chain for your exact framework version. Chitos was built to answer those questions.
π Phase 1 applies 50 language-agnostic rules across Python, JavaScript, Go, Java, C/C++, Rust, PHP, YAML and more β covering injection sinks, deserialization gadgets, credential leakage, broken crypto, and prototype pollution. Every candidate is re-verified before reaching the report. Findings that can't be substantiated are excluded, not handed to you as noise.
π¬ Phase 2 dispatches an autonomous web-search agent to hunt live CVE databases, exploit advisories, and public PoC repositories. It formulates hypotheses, verifies them, and synthesizes a structured threat narrative. This phase needs a user-supplied Claude API key β Phases 1 and 3 run entirely free.
π― Phase 3 is where Chitos diverges from everything else. Against targets you own or are authorized to test, it fires real payloads β XSS, SQLi, path traversal, command injection β mutates on block, captures hard evidence, and connects every proven finding into a kill-chain showing which vulnerabilities to remediate first.
No installation. No account. No code sent to third-party APIs.
π³ The RoboCasa Kitchen Leaderboard What does it take for a robot to handle kitchen chores the way a person does? It has to see (Vision), understand instructions (Language), and actually act (Action) β and VLA (Vision-Language-Action) models are emerging as the answer. They're the bridge between large multimodal models and real-world embodied control.
RoboCasa Kitchen is a leading robot-learning benchmark in which a single-arm robot (Franka Panda) performs 24 atomic manipulation tasks β picking up cups and bowls, opening drawers and doors, turning faucets, pressing buttons, and more β inside a photorealistic simulated kitchen. Because the layout and object placement are randomized every episode, it tests genuine generalization rather than memorized motions. The score (success rate, SR) is the average fraction of the 24 tasks completed as instructed, measured over multiple seeds so results aren't down to luck.
The catch: this benchmark has no official leaderboard, and protocols (number of demonstrations, evaluation setup) differ from paper to paper, leaving scores scattered. Lining the numbers up naively quickly turns into an apples-to-oranges comparison.
This leaderboard fixes that by collecting published scores with their sources and comparing only what is genuinely comparable. It's split into three tables:
π Kitchen 24-task (matched) β head-to-head under identical conditions (per the RLDX-1 Technical Report). This is the core ranking you can actually trust. β Other protocols β self-reported under different setups (e.g. fewer demos). Not directly comparable, so kept separate. π€ GR1-Tabletop β a different, humanoid-based variant suite, separated to avoid confusion.
Any researcher can submit their own model's score directly, and submissions are reviewed before they appear on the board. Every number links to its source paper, so you can verify it yourself.
π― Chitos β The Security Scanner That Actually Proves It
Most security scanners hand you a suspect list and walk away. That gap between detection and proof is where attackers live β and it's exactly the gap that Chitos was built to close.
Chitos is the successor to Mythos, a static analyzer built for quick code health checks. Mythos was good at pattern matching β spotting dangerous sinks, mapping CWEs, producing readable reports. But static analysis has a structural ceiling. A rule that sees eval(user_input) can tell you that looks dangerous. It cannot tell you whether the input is reachable, whether sanitization three layers up covers this path, or whether there's a live exploit chain for your exact framework version. Chitos was built to answer those questions.
π Phase 1 applies 50 language-agnostic rules across Python, JavaScript, Go, Java, C/C++, Rust, PHP, YAML and more β covering injection sinks, deserialization gadgets, credential leakage, broken crypto, and prototype pollution. Every candidate is re-verified before reaching the report. Findings that can't be substantiated are excluded, not handed to you as noise.
π¬ Phase 2 dispatches an autonomous web-search agent to hunt live CVE databases, exploit advisories, and public PoC repositories. It formulates hypotheses, verifies them, and synthesizes a structured threat narrative. This phase needs a user-supplied Claude API key β Phases 1 and 3 run entirely free.
π― Phase 3 is where Chitos diverges from everything else. Against targets you own or are authorized to test, it fires real payloads β XSS, SQLi, path traversal, command injection β mutates on block, captures hard evidence, and connects every proven finding into a kill-chain showing which vulnerabilities to remediate first.
No installation. No account. No code sent to third-party APIs.
π³ The RoboCasa Kitchen Leaderboard What does it take for a robot to handle kitchen chores the way a person does? It has to see (Vision), understand instructions (Language), and actually act (Action) β and VLA (Vision-Language-Action) models are emerging as the answer. They're the bridge between large multimodal models and real-world embodied control.
RoboCasa Kitchen is a leading robot-learning benchmark in which a single-arm robot (Franka Panda) performs 24 atomic manipulation tasks β picking up cups and bowls, opening drawers and doors, turning faucets, pressing buttons, and more β inside a photorealistic simulated kitchen. Because the layout and object placement are randomized every episode, it tests genuine generalization rather than memorized motions. The score (success rate, SR) is the average fraction of the 24 tasks completed as instructed, measured over multiple seeds so results aren't down to luck.
The catch: this benchmark has no official leaderboard, and protocols (number of demonstrations, evaluation setup) differ from paper to paper, leaving scores scattered. Lining the numbers up naively quickly turns into an apples-to-oranges comparison.
This leaderboard fixes that by collecting published scores with their sources and comparing only what is genuinely comparable. It's split into three tables:
π Kitchen 24-task (matched) β head-to-head under identical conditions (per the RLDX-1 Technical Report). This is the core ranking you can actually trust. β Other protocols β self-reported under different setups (e.g. fewer demos). Not directly comparable, so kept separate. π€ GR1-Tabletop β a different, humanoid-based variant suite, separated to avoid confusion.
Any researcher can submit their own model's score directly, and submissions are reviewed before they appear on the board. Every number links to its source paper, so you can verify it yourself.
