Two models, four seats

I spent a day tearing the squad down to the studs and rebuilding it on models I own, and the thing I keep coming back to isn't the speed. It's that Lucy came off the meter.

Until today, Lucy — the coder, the only agent that writes files — ran on a frontier model behind a paid API. It was good. But it wasn't mine, and a squad that depends on someone else's server for its hands isn't sovereign, it's a tenant. So the real question was never "how do I make it faster." It was "can an owned model on my own Mac actually do the work." I tested it the only honest way — I ran real code against real tests and executed the output — and the answer came back yes. Lucy now runs on a local coder, on my box, offline-capable, matching what it replaced on the coding that matters. That's the whole point of this project in one swap.

The rest is what I learned making the other three seats fast.

The lesson was: pick the right-shaped model, don't juice the wrong one. The planner and researcher — Ada and Scout — had been running on a dense 27-billion-parameter model. Dense means every parameter fires for every token, so it was slow: about 25 tokens a second. I spent real effort trying to speed it up with the tricks I'd learned elsewhere — speculative decoding, skipping dead layers — and clawed back maybe 50 percent. Then I swapped it for a mixture-of-experts model in the same family: 35 billion parameters on paper, but only 3 billion active per token. It runs at 129 tokens a second. Same quality of reasoning, five times the speed, and the juice tricks I'd been grinding on added almost nothing — because the speed was already there in the architecture. I'd been trying to make a slow model fast when I should have picked a fast one.

So the squad is two models now, covering four seats:

• Lucy (writes code) and Echo (checks it) share one coder. Lucy passed a real coding suite; Echo caught every bug I planted and cleared the correct code — a verifier that's only useful if it doesn't wave bad work through.
• Ada (plans) and Scout (researches) share the fast reasoner. On judged planning and research tasks it held up where it counts.

And here's the number I didn't expect to care about: power. I measured it — the sudo-gated GPU wattage on the serving Mac, during a real sustained generation. The reasoner does 129 tokens a second on about 29 watts. The coder, about 26. Not the whole laptop — just the compute doing the thinking. A dim lightbulb. The entire reasoning half of my squad got roughly five times more energy-efficient per token in the same swap that made it faster, because a model that only wakes 3 billion of its parameters per token simply does less work.

That's the shape of the thing I'm building. Not the biggest model — the right one for each job, small enough to own, run on hardware I control, at a power budget I could cover off a solar panel if I had to. The frontier labs are racing to serve enormous models from data centers. I'm doing the opposite, on purpose: a crew of specialists, each sized to its task, living on one machine on my desk, drawing less than a reading lamp.

Two models. Four seats. Nobody's meter.