I've used AI heavily while building software, debugging, writing, researching, and generally figuring things out as I go. But multi-agent systems? Local models? Orchestrating two separate models and letting them pass work back and forth without me stepping in?
What happens if I give one local AI model the job of software developer, another local model the job of code reviewer, and then get out of their way?
The result is hilarious, honestly. I expected the experiment to either fail immediately or produce something surprisingly competent. Instead, it did both.
One agent would be the Builder. Its responsibility was to read a product request, inspect the current workspace, and create or modify the application.
The second agent would be the Reviewer. It would receive the original task, inspect what the Builder created, review the implementation, and either approve it or request changes.
I called the project RelayLab, because the agents essentially relay the project between each other. (duh)
The orchestrator itself is just Python. For the first version, I intentionally kept it constrained — partly because I wanted to keep the test simple, and partly because I had no clue what I was doing. The agents couldn't run arbitrary shell commands or touch the rest of my computer. The Builder could only propose file writes and deletions inside an isolated experiment workspace. Every round was also logged so I could inspect exactly what happened afterward.
CPU usage shot to 100%, the machine became almost unusable, and I got my first lesson in running multiple local models. The issue wasn't just model size — Ollama was keeping both models loaded between turns, which meant the second model couldn't fit cleanly into GPU memory and started spilling work onto the CPU.
That forces each model to unload after its turn — like the good little AI it is. Instead of two AI coworkers fighting over the same VRAM, the process became:
Seeing 100% GPU in ollama ps while a completely local model was actively building an application was genuinely one of those little moments where the technology suddenly felt much more real. There's an unexplainable joy about running local AI models rather than using something like ChatGPT or Codex. This is all happening right now, on my computer?
Truth be told, I spend a lot of time using AI products. But running the actual models locally and watching them become parts of a system I wrote myself felt completely different.
Ollama happily let me download several gigabytes of models. ollama list worked perfectly. Then I tried running one:
My Ollama installation was incomplete — which is particularly funny, because from the outside everything looked fine. The models existed. The service existed. The CLI existed. The component responsible for actually performing inference did not.
After reinstalling Ollama properly, the models finally started running. RelayLab itself hadn't even had its first agent conversation yet, and I had already learned considerably more about local inference than I expected.
For my first real test, I deliberately avoided writing an extremely detailed specification. I gave the system this:
The Builder received that prompt. It generated an index.html. Lil ole RelayLab wrote the file.
At this point I was sitting there watching two local models iterate on software without me writing the implementation. And yes, that was extremely cool.
Seems reasonable. Except small local language models do not particularly care about your beautifully designed enum. The Reviewer returned something else.