Loading
Loading
A 1.7B model that fits in 236 MB runs fine in a browser tab. Then you give it a real prompt and a KV cache larger than the model shows up uninvited. We measured two things that move that wall: 4-bit KV error actually SHRINKS as context grows, and chunked attention is bit-for-bit identical to the single-pass version — which is what makes streaming the cache from host RAM sound rather than hopeful.
Last night the whole thing came alive. FLUX.2 Klein — a 4B image model — ran end to end inside a browser, on our own 2-bit ternary kernels: text conditioning → 4 denoise steps → VAE → pixels. Every stage proven against the production pipeline on real hardware, and then the assembled worker rendered a real image with nothing hand-stitched. Here's the receipts: 6.8e-6, 0.0055, 0.172, and six bugs that all had the same shape.
The last missing stage is live. FLUX.2 Klein — 4B diffusion model, Qwen3 text encoder, VAE — now runs entirely in a browser tab from a typed prompt, with the weights shipped as public GitHub artifacts behind a Cloudflare mirror. The prompt 'a red fox sitting in snow at dawn' no longer needs us at all. Here are the numbers, and the bug that hid in a single flipped bit.
aitherium.com is a Next.js 16 app with 783 page routes and 215 blog posts, statically exported and served from GitHub's CDN. The backend runs on a separate origin — a Cloudflare Worker at the edge and a tunnel into a machine we own. Two build targets, one codebase, one line of config each. Here is the whole thing, with the commands to check every claim from outside.
DeepSeek-V4-Flash with speculative decoding runs on a single ARM64 machine, delivering 28–30 tokens per second. A heterogeneous memory hierarchy spans three tiers. Nineteen capability gates verify nothing is silent. Red Hat's CPU-GPU rethink is proven here, in arithmetic.
FLUX.2 Klein is a 4-billion-parameter diffusion transformer. We're porting it to run in a browser tab — no install, no account, no cloud — on our own 2-bit ternary kernels. Here's the engineering: golden vectors dumped from the real pipeline, a weight conversion that turned out to be mathematically free, a GPU driver proven against a CPU reference at 0.59%, and the one generated file that made correct code look broken. Every number in this post is a measurement.
Y Combinator open-sourced QM and called it a multi-agent harness. It's a shared chatbot with cron jobs. Aither ADK is what happens when you actually solve the problem.
We already had GitHub-as-storage — the chunked release-asset backend that mirrors weights up to 5.7 GB per file. This week we added the missing half: a poll-based debounced watcher that turns any directory into a self-healing git mirror. Every write is a micro-commit. Files too big for git get pointerized through the LargeFileStore. Restore is `git clone`. And on the way there we caught a Dockerfile bug that had been silently shipping stale code.
Four open-source repos that are actually one system: an agent SDK that treats the model as configuration, 55 operational skills written from a live fleet, KV-cache compression at 3.8–7.1×, and PowerShell automation you can search instead of memorise. Every page they ship is generated from the code itself.
We took every Request for Startups from Y Combinator's last three batches, every company they actually funded against them, and audited them against what already runs here. Then we sent 62 hostile agents to destroy our own answers. They killed 46 of them. Here is what survived.
We shipped a world-model engine into the heart of AitherOS: a JEPA that predicts what happens next in latent space, measures its own surprise, and turns that surprise into curiosity, curriculum, and self-improvement. One model line now learns ARC puzzles, codebases, and agent sandboxes through a single API — it re-ranks code search by what it finds surprising, schedules its own training on what it doesn't yet understand, and closes the loop with models that write their own training data. Here's the technology, the results, and where it goes next.
Model capability is not the bottleneck anymore. The bottleneck is that a brilliant agent starts every session knowing nothing about the trap that ate your last one — so it re-derives it, confidently, at full speed. Skills are the fix: compressed operational memory that loads at the moment it matters. Here are all 62, MIT-licensed, distilled from 27,939 prompts across 210 days of running a real platform — what each one is for and what it saves you.
Hosted search APIs sell you a constant: the same latency forever, billed per query, on someone else's index. AitherSearch is a slope. It runs a four-tier latency ladder over a corpus it builds itself, on our own hardware, and every question it answers makes the next one cheaper — 15–40ms on anything it has seen the shape of, versus the 62ms P50 that was just announced as the fastest agent search on Earth.
A 236 MB language model now loads in a browser tab, answers correctly, and drives an on-page agent — no server, no account, no token. As of this week our WebGPU runtime runs every Bonsai size, from the 1.7B a phone can hold to the 27B, each verified against llama.cpp on byte-identical weights. Here are the numbers, with their variance, and what an agent can actually do on one bit per weight.
Garry Tan's gstack hit 89.7K stars in two months. Its own power users keep 6 of 35 commands. The one part everyone loves is the part that isn't a prompt. Here's what that tells you.
We put NVIDIA's NV-Embed-v2 — the 8-billion-parameter model that topped the MTEB retrieval leaderboard — on the DGX Spark, sharing 121 GB of unified memory with a 27B reasoning model at full 131k context and a 12B vision model. Here are the measured numbers: the 2.4× separation margin over our production embedder, a score matrix that matches NVIDIA's published example to two decimal places, and a 5.7-second model load.
We put Bonsai on an Android phone's Linux VM and wired it to the browser — one command, no account, no API key, no compiler. Getting there meant an installer that resolves its own missing libraries, detects that glibc 2.36 is too old, and builds itself a Debian 13 to run in. Here is what actually broke.
Someone ran Bonsai-27B on a 16 GB Mac mini at 21 tok/s. We believed our 5090 did 200. Four rounds of benchmarking later the honest answer is that single-stream decode is ~98–152 tok/s, the aggregate number is not measurable on a server the fleet is using, and the thing actually costing us throughput is not the GPU.
Technical deep dives and build updates. No spam, no fluff.
Subscribers get first priority when invites open.