The agent fleet has a bill, and today's pool itemizes it.

A Swift-and-Metal inference engine that runs Gemma 4 26B-A4B — 4-bit, instruction-tuned, ~14.3 GB installed — in about 2 GB of resident memory on any Apple Silicon Mac. Apache-2.0, 1.7k stars, and 832 points with 294 comments on Show HN. It ships a native Mac app, a CLI, and an experimental OpenAI-compatible loopback server; you build from source, and a streaming installer fetches and repacks the weights on first run. The numbers are measured, not projected: 5.1–6.3 tokens/sec on an M2 MacBook Air, 31–35 on an M5 Pro.

The trick is treating the SSD as slow memory with an opinion about what to read next. Only ~3.9B of the 26B parameters are active per token, and where llama.cpp and Ollama mmap the file and let the OS page blindly, TurboFieldfare issues explicit parallel pread calls for exactly the experts the router selected — the author measured that single change at 0.5 to ~4 tokens/sec. Experts get reused (~41% on the next token), so a 16-slot cache hits 59–69% and SSD traffic settles around 250–320 MB per generated token. The thread did the QA: SSD wear is a non-issue (the engine only reads), and the author supplies his own anti-hype line — if you have 14 GB of RAM free, MLX runs the same model at 75 tokens/sec and you should use MLX. This exists for the memory you don't have.

Reach for it when you want private, local drafting on the 8 GB Air everyone said was a thin client. Delete the assumption that 26B-class local inference starts at 16 GB. Tradeoffs: exactly one model (the technique is MoE-specific and Gemma-tuned), text-only, macOS 26+ for the 2.4× prefill path, 5–6 tokens/sec on an M2 is dictation speed rather than agent speed, and a fanless Air will throttle on sustained runs.

A hosted API gateway (YC S26, Launch HN at 66 points) with OpenAI- and Anthropic-compatible endpoints that fans each request out to several models at once, watches them decode, cancels the losers mid-response, and charges you for the one that finished the job. You get a single model's unmodified output — racing, not synthesis, which is the design line between this and OpenRouter's Fusion. Custom predictor models, trained on what the founders describe as hundreds of billions of tokens, score progress turn-by-turn inside agent loops; because everything runs in parallel, worst-case latency is the slowest model, not the sum. $20 of trial credit to test it.

The routing thread gets a third mechanism. Echo (07-24) allocated each request across a pool from outside; Cactus Hybrid escalated inside one checkpoint; Tokenless races. The headline claim — Claude Fable 5 quality at half the cost — comes from τ³-Banking, a benchmark they run themselves, and the founders volunteer that it trails frontier models on DeepSWE coding. That makes six consecutive editions carrying a vendor-measured number nobody has reproduced; the streak is now a pattern, so it gets named rather than footnoted.

Reach for it when high-volume, non-coding agent traffic has made per-answer cost matter more than model identity. Delete the hand-rolled fallback chain and the static model-picker config. Tradeoffs, straight from the thread: every raced model receives your full input, so fan-out cost scales with context; switching models breaks provider prompt caches exactly where long agent chains earn them; silent quality regression is the failure mode a confidence predictor can't rule out; and your traffic now transits a third party that is fifteen days out of Launch HN.

Rivet's agentOS is a library that gives each agent a Linux-shaped VM inside your backend process: npm install @rivet-dev/agentos, Apache-2.0, 4.2k stars, versions landing on npm this week. Guest code runs in a V8 isolate; compiled tools — coreutils, grep, the usual suspects — run as WebAssembly; a trusted sidecar process brokers every syscall, and no host filesystem, socket, or process is ever exposed. Cold starts around 4.8 ms and ~22 MB per agent, with a persistent POSIX filesystem (S3 and Google Drive mounts), cron, durable workflows, and human-in-the-loop approvals in the box. Runs Pi and OpenCode today, Claude Code and Codex in beta, custom agents over ACP. Disclosure: this is not the "AgentOS" that crossed our pool on 06-09 — different product, same name; after yesterday's org-rename disguise, the collision now runs the other direction.

The sandbox shelf now has three postures. Rent the agent a machine (Superserve, box — 07-22); put a ceiling on your own OS (nono, yesterday); or shrink the sandbox until it fits inside the process you already run, which is agentOS's move and the only one whose marginal cost rounds to zero. The 254× figure is the vendor's own — but unusually, the methodology is published: against Daytona, the cheapest microVM provider they could find, on Hetzner ARM, assuming one agent per sandbox and 70% host utilization. A headline multiplier with its assumptions written down is rare enough to note.

Reach for it when your product runs hundreds of short-lived agents and per-agent microVM pricing is the thing between you and shipping. Delete the one-container-per-agent Docker rig or the sandbox vendor's invoice. Tradeoffs: a syscall broker plus V8 isolation is a software boundary, not the hardware line a microVM draws — your threat model decides whether that's acceptable; the API is explicitly in preview; the agent you most likely run is still beta-tier; and the discount assumes you self-host.

A TypeScript CLI (MIT, zero runtime dependencies, 92 stars, Show HN at 39 points) that gives parallel Claude Code agents what human teams pay GitHub for: a merge queue. Agents work in numbered worktree "lanes," landings serialize FIFO onto an integration branch, a configurable check command gates every landing, installed git hooks block direct pushes, build-lock keeps two heavy builds from running at once, and each lane gets its own dev-server port. It plugs into Claude Code's native WorktreeCreate hook. The author's setup is the pitch: four to five parallel agents on a fanless 8 GB MacBook Air, roughly 90 commits a day, zero CI spend — the queue exists because simultaneous builds on that hardware were "the fast lane to a force quit."

This is the first tool in our pool that treats the agent swarm as a team needing team infrastructure rather than a collection of processes needing sandboxes. The thread asked the right question — who reviews 90 commits a day? — and the honest answer is: the check command, not a human. Commenters suggested jj's stacked-commit model over worktrees entirely, and the author conceded the design is shaped by resource constraints, not preference.

Reach for it the day your second concurrent agent starts losing push races to your first. Delete the cloud CI minutes you're burning on a solo repo, or the ritual of force-quitting a wedged laptop. Tradeoffs: single-machine by design, the gate is automated checks only (a human review step is your problem to add), rebase conflicts abort rather than attempt resolution, and one slow check command throttles every lane behind it.

The kicker, because every pick above deletes a line item on the strength of a multiplier someone else measured — 254×, half the cost, 2 GB — and this is the tool that grades those claims on your own traffic. npx langwatch claude wires an open-source collector into Claude Code and itemizes each session: tokens and cost per session, cache hits and writes as separate token classes, every bash command and MCP call as a span, file edits with durations, full terminal replays in the dashboard, and — the sharpest feature — theoretical-versus-billed, meaning what your Max-plan flat rate would have cost at API prices. #4 on Product Hunt at 191 votes.

The founder's framing is the why-now: you know what Claude Code costs per seat; you can't say which sessions burned the budget, which model did the work, or whether your cache was earning its keep — and the subsidized flat-rate pricing that makes not-knowing affordable is not permanent. It also pairs with the day's best essay, The Productivity Mirage (261 points, dropped as an essay): the argument that AI tooling's productivity gains are unmeasured folklore. Instrumenting the spend side is the half of that measurement you can install today.

Reach for it when multi-seat or multi-agent Claude Code usage has turned your invoice into one opaque number. Delete the ad-hoc token-log script and the cost spreadsheet. Tradeoffs: sessions — terminal replays included — land in LangWatch's hosted dashboard by default, which is your shell history in someone else's cloud; free-for-individuals is a team-plan funnel from an observability vendor; and it meters cost, not value — the Mirage essay's other half stays unmeasured.

Also worth knowing. Kedge (Show HN, 62 points) is an ex-Fly.io engineer's full-stack platform where echo '# Hello world!' | ssh kedge.dev is a deploy: hardware-isolated Linux VMs with forkable snapshots, scale-to-zero, a global SQLite layer and shared filesystem, per-second pricing ($15/vCPU-month, $5/month free credit). Hosted and closed, which is why it's down here — but deploy-over-ssh is the least ceremonial ship path anyone has demoed in months. hwatu (AGPL, Rust, 61 stars) is a verification browser built for agent fleets: load a page, evaluate JS, and screenshot in one tool call at ~35 ms median where Playwright spends five calls; pixel-diff scoring with heatmaps, animation as numbers, and a hwatu focus handoff that turns the headless session headed when a CAPTCHA needs a human — built explicitly so parallel agents stop stealing your window focus. Linux/WebKitGTK only. The on-device dictation shelf is officially a category: Qwen Scribe (Apache-2.0, 118 stars, Qwen3-ASR at 0.6B/1.2 GB or 1.7B/3.4 GB, build-from-source and unsigned) landed the same day ProductHunt carried Phantom Voice and SKI (voice control for Claude Code and Codex) — and Yap re-crossed via its own PH launch a day after being our 07-28 spine. Kimi K3-256k is Moonshot serving K3 at 256k context for half the quota of the 1M tier — the vendor is now economizing on serving its own 2.8T-parameter model, while what it costs anyone else to serve remains the open question from 07-27. And Kuna, an experimental "agent-first" decompiler whose code an LLM largely wrote, reports perfect control-flow structuring on 44.4% of functions against IDA's 45.7% — the agent-authored-artifact thread from yesterday's kicker, arriving in reverse engineering.