Commons Copilot

The Problem

A room full of smart people. No one knows who to talk to. That's the recurring failure mode of hackathons, residencies, and salons: the highest-signal collaborator is usually three seats away, and the room never sees its own overlap. The person who needs a frontend dev is sitting next to the person with idle Vercel credits, and neither of them knows it.

The fix everyone tries first is a Slack channel or a Notion board. Both end up as graveyards. Posts go in, nothing comes out, and someone has to play dispatcher to make any of it useful.

The Insight

If the room could see its own signals, it could match itself. The participants already know what they need, what they can offer, and what they're building. The missing piece is a shared surface where those signals are legible, and a small set of agents that read the surface and propose the overlap without anyone playing manual dispatcher.

The substrate that made this build possible is Intent Space, a coordination model from Memetic Software built on Promise Theory: agents post, scan, and enter contained spaces without routing or central assignment. The room is the only shared state. Each agent owns its own cursor and decides locally what to act on. Commons Copilot is what happens when you put a hackathon-room problem on top of that substrate.

The Solution

Commons Copilot is a hackathon-room app built on Intent Space. Anyone can post one of three signal types: Need help, Can help, or Building. Tagged and timestamped. Five independent agents read the room continuously and propose matches, name emerging clusters, challenge vague intents, and keep a running narrative of how coordination is forming. When two signals fit, the agents open a focused child space for the pair to work in.

How It Works

1. Step 01

   Post a signal

   Participants post a Need, Offer, or Building intent into the shared room with free-form text and a few tags.

2. Step 02

   Agents scan independently

   Five agents loop against the same Intent Space, each tracking its own cursor. No queue, no router, no central planner.

3. Step 03

   Matches surface in public

   Matchmaker proposes pairings with visible rationale. Skeptic challenges vague intents. Town Crier names emerging clusters. The reasoning is part of the room.

4. Step 04

   Open a child space

   Accepted matches spin up a focused child space so the pair can work without dragging the whole room into their thread.

The Product

Architecture

Why This Is Not a Dispatcher

Intent Space's design philosophy is "pull, not push": no routing, no assignment, no central authority. The most common question on a multi-agent build like this is whether the loop runner is just a hidden orchestrator. It isn't. The runner is a supervisor. It starts loops, it does not assign work. Every agent owns its own cursor, persisted independently. Agents decide locally: scan, optionally act, then post.

The proof is operational. You can start each agent in its own terminal, kill the supervisor entirely, and the behavior is identical. The room is the only shared state. That property is the point of building on Intent Space rather than rolling our own coordination.

Build Process

Built start to finish in roughly two hours at the Sky Valley × Tribute Labs Multi-Agent Hackathon at Betaworks, alongside Maik Luu Bach and Arnab Sikdar (Team Lisbon). The constraint was tight: ship a real multi-agent system that demonstrates multi-agent design, not a chatbot in a trench coat. The substrate was Memetic Software's Intent Space; Commons Copilot is the hackathon-room application sitting on top.

The split that made it work: Intent Space adapter and a deterministic seed timeline first, agents on top. The seed timeline meant we could rehearse the on-stage path without depending on any model API. Wild Mode let us prove the same architecture worked with real LLM calls when judges asked.

Two hours from blank repo to a deterministic stage demo, a backstage operator dashboard, and a participant-facing room.

Key Design Decisions

• Pick a substrate, don't reinvent it: Memetic's Intent Space already solved no-router multi-agent coordination on Promise Theory principles. Building on it meant the architectural work was done; we focused on the application.
• One shared log, many readers: Every agent reads the same Intent Space. The room is the coordination mechanism. Removing the queue removed an entire class of bugs.
• Per-agent cursors: Each agent's cursor lives at agentName + spaceId on disk. Agents can be killed and restarted without losing position. The system survives partial failure cleanly.
• Visible rationale: Matchmaker doesn't just propose a pair, it posts the reasoning into the room. Skeptic doesn't reject silently, it explains what was vague. The agents' work is part of the room's memory, not hidden behind an API.
• Demo Mode + Wild Mode: Stage demos break when they depend on live model calls. A deterministic seed timeline let us run the on-stage path reliably; Wild Mode proved the same code path worked against real LLMs.
• Picasso-styled UI over generic AI dashboard: Flat, minimal, hand-drawn shapes instead of the usual chat-bubble-and-token-counter aesthetic. The product is about a room of people, not a product about agents.

Outcomes

• 2nd place at the Sky Valley × Tribute Labs Multi-Agent Hackathon at Betaworks.
• Submission posted to the live Spacebase1 commons through the project's Python tooling.
• Public repository at github.com/VJDiPaola/commons-copilot with a working local demo.

What It Demonstrates

• Picking the right substrate: Used Memetic's Intent Space instead of rolling a custom router. The hard coordination work was already done. We focused on the five agents and the room view that made it useful.
• Two-hour scope discipline: Adapter first, mock seed timeline second, agents last. The build hit a working stage demo because the load-bearing pieces were sequenced right.
• Deterministic stage demo + live mode: The same code path runs reliably on stage and against real LLMs, without changing the architecture.
• Operational legibility: A backstage dashboard for judges and operators, separated from the participant-facing room. Each surface optimized for who's looking at it.