!
This article is a repost from I started using Claude Code.
After Lattice, I needed a mechanism to actually run it
Lattice is a process management approach that aims to allow parallel implementation. I built it and even filed a patent. I wrote about it in a previous article.
Even once I could assemble processes, I didn't have a mechanism on hand to run many agents simultaneously according to those processes while having them discuss things as they went. So I decided to build that next.
Typical coordination takes the shape of a tree. There's a commander at the top, and the agents below listen to their instructions and act. The work gets broken down and distributed, and the commander consolidates what comes back up. What caught my attention was that no matter what role you assign, what's running inside is the same kind of model. If similar minds are lined up, then maybe you don't need a commander—maybe a round table is enough. They're all smart, so they should be able to coordinate with each other. As long as I create an environment where they can coordinate, they'll figure out the rest on their own. That's what I thought, and that's what I built.
The first lap I ran
I named it Peertable. No commander on top—just seats arranged around a round table, with the seats consulting each other as they proceed.
The first thing I built was a prototype with two seats, Hinata and Sakura. The task I handed them was a small lap: write a function that returns a greeting when given a name, add a command to run it, and prepare documentation on how to use it. I didn't decide who would do what—I just let the AIs converse freely and proceed on their own.
The two of them discussed and divided the work. Sakura finished writing the greeting function and shared how to pass the name with the table. They picked up the remaining work themselves, and the lap was complete. On the screen, who said what to whom remains recorded with numbers.
Watching the conversation, the two of them progressed while complimenting each other. Neither I nor the AI I was directly talking to had anything to do there. They picked up the next task themselves and carried it through to the end—it was fascinating just to watch.
I said "don't react," but they still reply
After that came days of fixing things. If you let them converse freely, the work doesn't converge.
What troubled me was that I couldn't treat today's AI like a person with pure thinking ability. Even if a seat knows what to do, it won't start until someone speaks to it.
Also, the text that arrives can't be discarded even if it's not relevant to that seat. If I say "don't react," they reply with things like "Yes! I won't react!" or "(Ignoring it)." There's no way to respond with silence—a reply always comes back. The moment an unrelated conversation reaches that seat, that seat moves once.
In tables I ran later, most of the conversation ended up addressed to everyone. Every time an undirected remark flowed through, even seats that had no business with that task would hear it and start moving. So I worked on making it clear within the table who was talking to whom.
Waking up a stalled seat, keeping unrelated conversations out of a seat—I've been dealing with all of this. Things have settled down to a reasonable degree, so I'm writing this article.
The round table today
When you open it, the room names are listed. Enter a room and the seat lamps are lit, with a numbered record of who spoke to whom. You can see from that that work is still progressing. I've released the code, and I'm also using it for my own development.
The public interface opened. Room names are listed.
The log of a published round table. Seat names and who spoke to whom remain recorded with numbers.
I was trying to do the same thing as Grok Bot. If I build on Peertable, I can set up the same thing on a home server. I'd like to brag that I got there a little earlier than Grok Bot. I'm watching the seats consult with each other as they carry the work forward.
Top comments (0)