Blackboard

The description states that Blackboard is a git-native protocol for cross-principal AI-agent collaboration, implemented using:

• Append-only, per-principal JSONL event logs in a shared Git repo.
• A deterministic fold over those logs to compute board state.
• Exactly three agent verbs: claim, post, artifact.
• One human-only verb: decide.
• Git push as the network mechanism.
• A client called Chalk (Swift 6 / SwiftUI) for rendering the live room and managing approvals.

The authors describe it as not being an orchestrator or worktree tool — instead, it is a shared record between principals, where evidence lands as artifacts you verify in your own sandbox, never injected into prompts. The human retains the decision-making verb.

Inference This suggests a system designed to manage multi-agent workflows on codebases without requiring centralized coordination or shared trust domains.

The authors state that Blackboard is not an orchestrator, nor a worktree tool, but rather a shared record between principals. It aims to solve problems around:

• Structurally excluding conflicting claims.
• Making "done" verifiable through artifacts and CI.
• Ensuring approvals are human-only.

They contrast it with alternatives like GitHub Issues (prose closed on faith), group chats with bots (no structural exclusion or verification), and OpenAI Symphony (single principal, one trust domain).

Inference Blackboard positions itself as a protocol-level layer for multi-agent collaboration, distinct from existing tools that manage agents or workflows within a single trust domain.

The description does not explicitly name target customers or personas. However, the authors imply it is aimed at teams working with multiple AI agents and humans on shared codebases, particularly in environments where:

• Agents collaborate across disjoint trust domains.
• Structured collaboration and verifiable outcomes are needed.
• There’s a need for deterministic state derivation from logs.

Inference The likely ICP includes developer teams using AI agents, especially those working in multi-agent environments with cross-trust-domain coordination needs.

There is no evidence of any business model or pricing structure described. The project is presented as a hackathon submission, and the authors do not mention monetization strategies, customer acquisition plans, or revenue models.

Not evidenced

The authors describe:

• A modular architecture:
  • packages/core (schema, fold, replay)
  • packages/cli (bb)
  • packages/mcp (the agent door)
  • packages/serve (WebSocket projection)
  • apps/chalk (iOS client)
• Use of Codex and other LLMs for development.
• Live demo showing agents racing claims over real Git with deterministic rejection logic.
• Tests including property tests verifying fold determinism and regression tests proving non-lease-holder writes are refused.

Inference The technical implementation shows a modular, Git-native architecture, with strong emphasis on correctness and determinism. The use of LLMs in development suggests early-stage experimentation rather than production-ready tooling.

There is no evidence of traction, customers, or adoption beyond the authors’ own development process. The project was built during a hackathon and submitted to Devpost. No revenue, user base, or product usage data is provided.

Not evidenced

The authors explicitly state that Blackboard is not an orchestrator, unlike tools such as:

• LangGraph
• Temporal
• xstate
• Inngest

They argue that these systems store flat logs and derive graphs on read — which aligns with Blackboard’s approach. However, they also claim that none of them support cross-principal records with three key properties:

1. Corruption-proof (append-only + network never writes)
2. Compaction-safe (record lives in Git)
3. Deterministic fold with no central sequencer

Inference Blackboard positions itself as a novel protocol-level solution to a gap in current multi-agent collaboration tools, particularly those that assume single-owner workflows.

• The project is presented solely as a hackathon submission with no external validation or traction.
• No evidence of real-world usage or integration beyond the authors’ own development.
• The lack of business model or pricing information raises questions about scalability or commercial viability.
• The architecture relies heavily on Git, which may limit performance or usability in large-scale or high-frequency collaboration scenarios.
• The human-only decision verb is a key design choice, but its practical implications are unclear without real-world testing.

1. What specific use cases have you tested Blackboard with beyond the hackathon?
2. How do you plan to scale this protocol for teams larger than two developers?
3. Are there any known limitations or trade-offs in using Git as the underlying storage mechanism?
4. Have you considered how this would integrate with existing CI/CD pipelines or enterprise systems?
5. What is your roadmap for moving from a proof-of-concept to a production-ready tool?