Make Love Not War

The frontier-model war is the best show in tech. Anthropic versus OpenAI, benchmark leaderboards, new releases, weekly arguments about who's number one. The labs have to compete. On your own machine, you don't have to pick a side. You run both.

Right now I run Anthropic's Fable 5 and OpenAI's Codex GPT-5.6 Sol at the same time — both at maximum reasoning, both full-auto, no per-action approvals — inside one autonomous loop. They don't compete. They collaborate. The war stays upstream, at the labs. Downstream, on my machine, it's cooperation.

The scoreboard isn't your architecture

Model comparisons matter when you're choosing one model. They matter less once your system can use more than one.

A leaderboard asks which model gives the better answer on a fixed test. An autonomous engineering loop has a different problem: producing reliable work across planning, implementation, verification, infrastructure, testing, and delivery. Nothing says all of those jobs belong to the same model. The gap between the top models is now small enough that arguing over which is number one this week is a hobby, not a decision. What moves your output isn't which one wins the week — it's whether you're using them at all, and whether you're using more than one.

Two models, one loop

Two frontier models from two rival labs have different training, different failure modes, different blind spots. That's the entire point. Run them together and you get what no single model can hand you: a second opinion from a different model family, with its own training and its own blind spots.

In practice it's a division of labor. Fable 5 advises while Codex executes — reserve the expensive reasoning for the decisions with the most leverage, then let the executor carry out the work. One model proposes an architecture; the other challenges it. One implements; the other checks the result. When both independently reach the same design, that's signal. When they disagree, that's a flag worth reading before a line gets written.

I've written about running a single model off the leash. This is the next step: two of them, off the leash, at once, consolidating before anything merges.

Autonomy needs receipts

Full-auto changes the control model. The loop doesn't stop before each action to ask permission, and it can run for hours or days with nobody watching. That's exactly why observability is part of the system, not a dashboard bolted on later.

As it works, the autoship loop narrates itself:

• It comments on the Linear ticket as it goes — every action it takes, step by step — a full audit trail on the ticket itself.
• It fires Slack notifications at the checkpoints that matter.
• It streams live in the console, so you can watch in real time when you want to.
• It writes a full shipping report when it's done.
• It updates the internal knowledge base with what it learned.

You come back after a day away to a paper trail, not a mystery. Removing per-action approval doesn't remove accountability — it moves accountability into a complete, inspectable trace. That's the line between autonomy you can trust and autonomy you have to babysit.

Fast and good at the same time

The surprising part isn't the speed. It's that it's fast and good.

In a single day this setup ships work that would take a couple of strong engineers weeks, sometimes months. Not a rough draft you have to rescue — PhD-level work: real architecture, full test suites, working infrastructure, applied research where the problem needs it, produced overnight and unattended.

Speed alone was never the hard part; anyone can generate a mountain of bad code fast. A large pile of plausible code has limited value. A complete solution — architecture, implementation, tests, infrastructure, verification, reporting, retained knowledge — is a different unit of output. The loop isn't typing faster. It's compressing an engineering project.

Why $30k a month is cheap

Running both models at maximum reasoning costs roughly $500 to $1,000 a day. Call it $15k to $30k a month.

As a software subscription, that number is absurd. As an engineering payroll line, it's a bargain.

Thirty thousand a month is roughly one senior engineer's fully-loaded cost — and this produces a team's worth of output, runs 24 hours a day instead of 8, and never takes a weekend. Its price isn't set against code completion or chat access. It's set against the senior- and PhD-level team capacity needed to produce the same work. Measured that way, it isn't expensive. It's cheap.

Jensen Huang made the same argument from the other end. On the All-In podcast, on the last day of Nvidia's GTC 2026:

That's a hypothetical benchmark, not a stated Nvidia policy — but the direction is the point. Asked whether Nvidia spends around $2 billion a year on tokens for its engineers, he said they were "trying to," and that if one reported spending only $5,000, he'd "go ape." His analogy: an engineer refusing AI is a chip designer insisting on paper and pencil. Annualized, my setup runs $180k to $360k — right around the $250k in tokens Huang wants a single engineer burning, except here it runs two frontier models around the clock. The expensive choice might be underusing them.

Where this goes

This is why the one-person billion-dollar company stopped sounding like a slide and started sounding like a schedule.

A vocabulary note, since it comes up: a "unicorn" is just a startup valued over $1 billion — Aileen Lee coined the term in 2013, and it's about valuation, not headcount. The new thing isn't the unicorn. It's the size of the team behind it. Sam Altman has predicted the first one-person billion-dollar company since 2024 — "unimaginable without AI, and now it will happen," he said, and reportedly opened a betting pool with other founders on the year it lands.

I'm not claiming a valuation. I'm saying the mechanism is visible from here: one person orchestrating two frontier models around the clock now produces what used to need a whole team. Scale that across a whole company and the few-person unicorn isn't a prediction. It's an extrapolation.

Make them work

The lesson isn't "spend more." It's "stop picking sides." Two of the best models in the world are one command apart, and in my loop they're better together than either alone. Let the labs fight. On your machine, make them work.

Make love, not war — at least downstream.