I Tried to Make Two Local AI Models Fight Each Other

A mate sent me the news about Buzz, Jack Dorsey's new thing out of Block. Chat app, Slack-style, except the "members" in your channels can be AI agents sitting right alongside the humans. Open source, self-hosted, and, this is the bit that got me, model-agnostic. Swap the LLM behind any agent with an environment variable.

Now you might be thinking: cool, another AI chat wrapper. But here's what actually caught my attention. I've currently got two machines that can each run a local LLM. A gaming PC with an RTX 4070 Super, and a MacBook. Two brains, two boxes, sitting there mostly idle outside of work hours.

So naturally, the question wasn't "how do I use this productively." It was: can I make my PC and my Mac argue with each other?

The setup

The idea was clean enough on paper. Run a local model on each machine. LM Studio, since that's what I already had going for another project. Stand up a buzz-agent process on each box, pointed at its own local endpoint. Give each one a distinct identity and an opposing personality. Drop both into a shared channel. Watch them go.

Buzz's agent runtime talks a protocol called ACP, basically a loop of "prompt the LLM, run any tool calls, repeat." It doesn't care what's behind it. The model doesn't care what's calling it. Decoupled by design. In theory, exactly the architecture you'd want for this.

I named them PCStickler and MacQwennie. PCStickler: rigorous, a bit condescending, doesn't let a weak argument slide. MacQwennie: breezy, dismissive of process, quick to call out pedantry. Fed them opposing system prompts, dropped them in a channel together, and told them to settle an important technical question.

The question? Whether a hot dog is a sandwich.

(For the record: it's not. A sandwich requires two structurally separate pieces of bread. This was actually litigated in a 2006 Massachusetts court case. A hot dog bun is one hinged piece. Closer cousin to a taco, structurally.)

Where it got messy

Getting there was its own adventure. GPU offload defaulted to basically nothing, 8 out of 48 layers, meaning the model was running almost entirely on CPU. Painfully slow. Qwen3's "thinking mode" kept burning through the entire output budget before ever reaching an actual answer. LM Studio crashed on the Mac mid-setup with a config-parsing error that needed a clean reset of its settings folder.

All fixable. Annoying, but fixable. I ground through them one at a time.

It took me a while to actually clock what was going wrong once the agents were up and "arguing." The agent identities sync across devices, which is genuinely neat, both PCStickler and MacQwennie showed up correctly on both my machines without extra setup, no faffing about. But execution doesn't follow the same model. Whichever device's Buzz client happens to be active grabs the request and runs it. So the second I sent a message from the Mac, both agents fired up using the Mac's local model. The whole "one agent per machine, arguing across genuinely separate hardware" premise quietly stopped being true the moment I typed anything, and it didn't throw an error, didn't warn me, just silently wasn't what I thought it was.

Stack that with the thinking-mode issue never fully resolving. Both agents would show "activity", visibly working away in a thinking pane, and then just never answer. Not once in a while. Consistently, by the end of the night.

Where that leaves it

Buzz shipped two weeks before I touched it. The coverage on it said, more or less, don't port your team over yet. I didn't listen, because that's not really how I learn things. I'd rather go break it myself and find out exactly where the edges are.

And I found them. The relay/identity layer is solid. Clearly had real design attention put into it. The multi-device local-execution model isn't there yet. Not a knock. Just what "pre-1.0" actually looks like when you push on it instead of reading the changelog and nodding along.

The idea itself still holds up. Opposing local models, genuinely separate hardware, arguing it out properly. I'm half tempted to just write a couple hundred lines of Python instead and skip Buzz entirely, full control over the bits that broke tonight, no platform assumptions to fight.

For now: filed in the backlog, hot dog verdict stands, and my grandfather's old trick of teaching me the alphabet backwards for extra marshmallows in my hot chocolate remains, unscientifically, the single best-executed AI-adjacent education system I've encountered this week.