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.
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 is an interesting idea.. do you use agents with more adversarial / cynical prompts whose only job is approving api calls? "You are an API approval agent on the lookout for suspicious or unusual stripe api calls...."
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...
I use a file "task.md" as blackboard. It is read/written by multiple agents, usually monitor agent, worker agent, judge agent and reflexion agent. Each work item is an open gate initially, after agent solves it, it appends on same line outcomes from that work. This means you can resume work easily or pass task.md around to other agents.
Another way to see the blackboard - it is like code, it executes, can be passed around like in higher-order programming, but this it even stranger - it can reflect on itself, not just execute. The task.md file is the agent.
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.
> The author’s core insight is to remove the blackboard from source control.
That's only because of a deficiency in CI. If you get smarter CI that doesn't trip on files unrelated to the build, using the repo as a blackboard or wiki is probably fine
Having somewhat accidentally also discovered this pattern, I do recommend figuring out some kind of compaction/deprecation method, potentially history-preserving, potentially just letting the git commit messages themselves serve as the canonical history.
The biggest problem I encountered using a similar setup for doing long-term and iterative data analysis is error propagation. My team and I are characterizing and modelling a physical system, there are real-world experiments that need to be run and then fed back into the analysis pipeline and then the next frontier of questions comes up. Any time there has been an erroneous analysis somewhere along the line, that error continues to be treated as a correct fact until it has been decisively eradicated. If one analysis script or document has the error written as a correct fact, that error will continue to pollute future analyses. Oh and these errors can also end up in the agents’ memory files as well. I have gotten very careful about making sure that every reference is corrected everywhere because it seems that the initial error is weighted heavier than the correction.
Technical constraint I want to mention: I just switched off of using .design/ because it was just too frustrating how many things don't see hidden files. The hidden directory was a win like 5% of the time, and annoying the rest of the time.
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 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)
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.
There is some value in a unified history (code and blackboard together) if you want to be able to review agents behavior (especially if that goes wrong).
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.
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."
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.
>They even self-organized their own organizational structure.
The boulder, it even found a path down the mountain. on its own, by doing so-amazing path finding its own super amazing path finding algorithm, and all the boulders co-ordinated falling down, ON THEIR OWN! And they all reached the ground!
I tell you! The future may be these boulders washing your underpants and putting you to sleep. It is clear!
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 think Stack overflow would work best. The agents would feel quite at home...
You jest, but a wiki with a voting system might be a good fit for agents?
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 is an interesting idea.. do you use agents with more adversarial / cynical prompts whose only job is approving api calls? "You are an API approval agent on the lookout for suspicious or unusual stripe api calls...."
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/...)
I use a file "task.md" as blackboard. It is read/written by multiple agents, usually monitor agent, worker agent, judge agent and reflexion agent. Each work item is an open gate initially, after agent solves it, it appends on same line outcomes from that work. This means you can resume work easily or pass task.md around to other agents.
https://github.com/horiacristescu/playbook-harness
Another way to see the blackboard - it is like code, it executes, can be passed around like in higher-order programming, but this it even stranger - it can reflect on itself, not just execute. The task.md file is the agent.
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.
> The author’s core insight is to remove the blackboard from source control.
That's only because of a deficiency in CI. If you get smarter CI that doesn't trip on files unrelated to the build, using the repo as a blackboard or wiki is probably fine
Having somewhat accidentally also discovered this pattern, I do recommend figuring out some kind of compaction/deprecation method, potentially history-preserving, potentially just letting the git commit messages themselves serve as the canonical history.
The biggest problem I encountered using a similar setup for doing long-term and iterative data analysis is error propagation. My team and I are characterizing and modelling a physical system, there are real-world experiments that need to be run and then fed back into the analysis pipeline and then the next frontier of questions comes up. Any time there has been an erroneous analysis somewhere along the line, that error continues to be treated as a correct fact until it has been decisively eradicated. If one analysis script or document has the error written as a correct fact, that error will continue to pollute future analyses. Oh and these errors can also end up in the agents’ memory files as well. I have gotten very careful about making sure that every reference is corrected everywhere because it seems that the initial error is weighted heavier than the correction.
Technical constraint I want to mention: I just switched off of using .design/ because it was just too frustrating how many things don't see hidden files. The hidden directory was a win like 5% of the time, and annoying the rest of the time.
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.
There is some value in a unified history (code and blackboard together) if you want to be able to review agents behavior (especially if that goes wrong).
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.
I was going to mention OP might be rediscovering https://beads.gascity.com/
>They even self-organized their own organizational structure.
The boulder, it even found a path down the mountain. on its own, by doing so-amazing path finding its own super amazing path finding algorithm, and all the boulders co-ordinated falling down, ON THEIR OWN! And they all reached the ground!
I tell you! The future may be these boulders washing your underpants and putting you to sleep. It is clear!