DEV TOOLS Signal 302 2 feeds carried it
Agentic engineering team accidentally builds blackboard coordination system in Git repo
↗
Illustration only Photo by Eugen Str on Unsplash
A Thoughtworks experiment in hyper-agentic development led to agents self-coordinating via Git commits and shared plans stored in the repository.
This accidental discovery demonstrates how agentic systems can dynamically coordinate work without explicit orchestration. For engineers, it suggests Git repositories may already contain latent coordination structures that agents can exploit, potentially reducing the need for external workflow tools in agent-heavy environments.
Written by elseif from the cluster below · every claim links back to a sourceThe three things worth knowing
Agents used Git commits and shared plans to track progress and dependencies without explicit coordination code.
The blackboard pattern emerged from enforcing frequent rebases and storing plans in the monorepo.
This approach allowed agents to dynamically integrate components like cost models and verifiers as they became available.
THE READ
What the cluster adds up to.
During a Thoughtworks experiment testing hyper-agentic engineering practices, a team of 10 engineers observed unexpected coordination behavior among AI agents working in a shared Git monorepo. The agents began using commit messages and plan documents stored in the repository to track each other's progress and dependencies. This behavior emerged after the team enforced a discipline of frequent rebasing and continuous integration, which inadvertently made all agents' work visible to each other in near real-time.
The coordination mechanism resembled a blackboard system, where agents post updates to a shared space that others can observe and react to. In this case, the Git repository served as the blackboard, with agents writing their plans and progress updates as files that other agents could read. When one agent marked a task as complete, dependent agents could immediately see the implementation details and begin their own work. This eliminated the need for explicit handoffs or synchronization points in the codebase.
This accidental discovery has practical implications for agentic development workflows. It suggests that Git repositories may already contain sufficient structure for agent coordination without requiring additional tooling. The approach worked particularly well for integrating dependent components, such as when a search algorithm needed to wait for a verifier component to be implemented. However, the coordination was entirely ad hoc and emerged from specific constraints rather than being designed intentionally.
The experiment raises questions about how to deliberately design such coordination patterns in agentic systems. While the blackboard pattern proved effective for this specific use case, it may not scale to more complex scenarios or larger teams. The team noted that the approach worked because all agents shared the same specification and worked in the same repository, which may not be true in real-world development environments. Additionally, the coordination was entirely reactive rather than proactive, which could lead to inefficiencies in more complex workflows.
Written by elseif from the cluster below · checked for specifics the sources never containedTHE CLUSTER