Raccoon MCP

Raccoon MCP (I love raccoons!) is a local coordination server that helps AI agents work together across multiple repositories while keeping execution, communication, and review structured and recoverable.

Inspiration

Lately, most of my development work has shifted to orchestrating coding agents, configuring their workflows, and reviewing the code they produce. Many of my projects have several connected repositories: backend, mobile app, web platform. So usually a feature begins with a backend change, then requires corresponding updates in a mobile application and a web platform.

That workflow is rarely linear. Client agents need to learn what changed on the backend, implementation feedback may trigger another backend revision, and every result still needs both independent agent review and human review. It is technically possible to manage everything in one large AI session with full access, but the context quickly becomes overloaded, audits stop being truly independent, and important workflow steps are easy to lose.

I wanted a small, understandable coordination layer that made this process explicit without trying to replace the agents themselves.

What it does

Agents working in each repository connect to Raccoon MCP (I really love them! both raccoons and agents) as orchestrators for one shared project. Together they can create a feature plan, assign repository-owned work items, spawn tracked child agents to execute them, exchange durable questions and implementation artifacts, and recover the current state after a session restart.

The workflow separates three child-agent roles:

• Executors implement repository-owned work.
• Butlers investigate technical questions about their local repository.
• Auditors review completed implementations from a fresh, independent context.

Audit findings can create a bounded remediation and re-audit cycle, while the human remains responsible for product decisions and final review.

How I built it

The server is written entirely in Rust and was developed with Codex 5.6-sol. It implements MCP over Streamable HTTP and stores coordination state in SQLite.

Features, work items, worker runs, repository requests, messages, artifacts, leases, and events are all persisted. Events wake agents when relevant state changes, while durable queries remain the source of truth. Optimistic revisions, scoped claims, idempotency keys, and explicit worker lineage keep concurrent orchestration predictable.

Challenges

The hardest part was not moving messages between agents; it was defining reliable lifecycle rules. The server must recover when an orchestrator disconnects, prevent two workers from modifying the same item, preserve artifact provenance, keep audits independent, and avoid endless audit/remediation loops.

Another challenge was balancing strictness with local-development ergonomics. Long waits need finite timeouts without ending the overall workflow, leases must detect abandoned actors without limiting task duration, and SQLite access must remain lightweight under several agents working concurrently.

What I learned

I learned that effective multi-agent development depends less on adding more autonomy and more on making responsibility, evidence, and completion criteria explicit. Durable state is more reliable than chat memory and a clean audit context materially improves review quality

Built With

• codex
• rust
• sqlite