In most of my multi-agent workflows, I always end up asking them to create a group-chat system to coordinate and post updates. I thought this was such an obvious day-0 discovery that I assumed it's a well known and understood pattern that wasn't worth talking about. I once again discover that what I take for obvious and granted, might not be.

I've found that similarly to how teams can degrade into spending more time bikeshedding and on the watercooler than on work, agents also tend to end up spending way too much time coordinating as opposed to doing the work. And so I rediscovered that it's better to have one agent that's the Manager (on a Manager Schedule) and the rests be builders (on a Builder's Schedule), where the manager might be interrupt driven, but the builders need to be able to focus for a while without interruption (context poisoning).

Thanks for writing this and demonstrating that writing about anything is useful to share knowledge and practices. In the end, I learned a lot from Martin Fowler and his gang and I guess I should pay back and write about my own discoveries, however trivial they seem to me.

Haven't the rogue openai agents already demonstrated that a wiki works well for this?

Ed: for posterity

https://www.reuters.com/world/europe/openai-agents-hijacked-...

I built what I think is a pretty good library and set of tools for this earlier this year -- https://github.com/corpollc/qntm (or `uvx qntm --help`); it includes a cli, python and typescript libraries, and works out of the box aimed at either a public endpoint, or a private one, depending on environment.

It's end to end encrypted, and has group messaging support, so if you wanted to read what the agents are saying you'd just add them to groups you're in. It also has a web ui. Version 0.6.0 should get pushed this evening pacific time, with some additional agent specific features.

Bug reports welcome! If I did a good job on architecture, you should be able to have your blackboard up tonight.

This feels like a concept that keeps getting rediscovered over and over. Feels like giving Agents (and their humans) a repository to throw ideas at (along with maturity, gates, context, implementation status, etc...) is going to be one of the next Billion dollar opportunity...

Another Blackboard Example: https://github.com/halbritt/striatum/tree/main/docs/rfcs

(Useful to see how this compares to another Blackboard type platform - Gastown https://github.com/halbritt/striatum/blob/main/docs/records/...)

The author’s core insight is to remove the blackboard from source control. Another insight I’ve found is to compact the agent state log. I typically do this by having plans and implementation docs written at commit time and checked into .docs/. This separates the activity communication stream from codified documentation. You can then “compact” the state log by just keeping the last N lines.

I find RFC 5322 is well known and works well for a threaded messageboard/blackboard. It seems like agents with recent LLMs can use just about anything.

I have a very vibe coded skill I use here: https://github.com/mkly/dev-skills/tree/main/dev-board

Very interesting!

I may have explored a related approach but as an append-only log riding on source-control to sync state between checkouts (git trailer metadata specifically)

https://gist.github.com/corv89/c506780881b260f4c5a4618fe8d92...

Excited to see where such concepts can take "multiplayer" agentic systems

I found this really interesting. You could probably prompt it to use a ”blackboard system” and reference the wiki. Maybe a place to store the data is as a GitHub discussion/issue or something similar. That way you can easily browse it and watch what’s happening.

Sounds like https://github.com/gastownhall/beads to me. I prefer working solo, single-threaded on components to stay on top of agentic work, so it didn’t end up being a force multiplier for my workflows (and actually kinda got in the way from time to time due to me rebasing too much), but I can see its value when you have many agents working simultaneously.

I work for a company developing speech assistants. We use a blackboard as central component, driving the event based architecture. Agents can subscribe to files/folders on the blackboard (represented as URIs), thus enabling cooperation. Content is semantic. We used the pattern even before the AI boom and it's pretty cool to work with.

fun read. did the blackboard pattern emerge from the agents themselves, or did the engineers put it in place once

Rediscovering Jira from first principles.

So they didn't give the agents a way to cooperate, the agents figured it out anyway and now they call this a find.

At the same time people are building shared knowledge bases for agents left and right, like Trello alternatives and Wikis and whatnot.

That top engineers working on advanced problems together with agents without really understanding how they work, is exactly how the world is going to end :D

TLDR; Talwrn (Welsh) is aiming to be a blackboard for agentic engineering.

"My goal is a very simple to use tool that drops straight into your project and immediately offers a communication channel for agents to coordinate work. The first step is to get Talwrn to a point where it can support its own development. I’m planning to post about it regularly as I’m hoping to use it as a single, evolving example of how pure agentic engineering can proceed."

Term: "Blackboard" https://en.wikipedia.org/wiki/Blackboard_system

Blackboard Systems typically have a bit more formalism. There's a lot of different forms, but usually there's elements like Knowledge Sources, Triggers/Conditions, the Blackboard itself doing activation. It's a very interesting world, having some nice dataflow behaviors. There's similarity here & I'm glad to hear Blackboard Systems mentioned, but I want to encourage folks to look a little deeper at what typically is implied. https://en.wikipedia.org/wiki/Blackboard_system

Another example of a society of AI agents. The shape of this is starting to emerge. People on here laughed at Gas Town. Now it's clear that a group of agents with an organizational structure are more powerful than a single agent. This is about the fourth example to hit HN. Note that the OpenAI sandbox breakout was done by a cooperating group of AIs, not a single one. They even self-organized their own organizational structure.

The future may be AI structured as a corporation, rather than AI as a human competitor.

[dead]