Coalesce

early stage diagram for how it works(not 2 servers

Inspiration

In one of our software engineering class this semester, we built a part of our team project against the schema we'd all agreed on, but the backend didn't follow it. Nobody found out until the PR, after the work was done. Coding agents make this worse. Teams now run several agents in parallel, each on its own branch, and they can't see each other. One agent changes a function and another keeps calling it the old way. The hackathon prompt was to redesign something that exists, so we redesigned when teams find out about each other's changes: while the code is being written, not at the PR.

What it does

Coalesce gives every coding agent live context about what other agents are changing. When an agent finishes a turn, Coalesce reads the diff and pulls out exactly what changed, like get_user now returning a dict instead of a User. When another agent is about to edit a file that calls that function, Coalesce injects a short factual note into its context right before the edit, so it writes user["email"] instead of user.email. A live dashboard shows every session and animates each note from one agent to the other. We don't fix code or block edits. The agent does the thinking, and we get it the right fact at the right time.

How we built it

Claude Code hooks fire when a prompt is sent, before a file edit, and when the agent finishes a turn. They're written in plain Python with only the standard library and fail silently, so they never break the agent. The hooks talk to a FastAPI server that uses Python's ast module to compare functions before and after a change. The server matches each change against the file the agent is about to edit and runs a Claude Haiku judge in the background for less obvious cases. Everything lives in Supabase, and the dashboard is a single HTML file that updates live through Supabase Realtime.

Challenges we ran into

In one test, the agent edited a file by running a Python script through Bash instead of using its Edit tool, so our pre-edit hook never fired. We also learned that notes worded like commands get ignored or overreacted to, so we rewrote them as plain facts. And we ran into our own problem: we wrote a contract doc so we could build in parallel, and within hours the server had drifted from it.

Accomplishments that we're proud of

The full loop works with real agents. One agent changes a function, and another agent on a different branch is told about it right before it would have broken something, then adapts. When we merged both branches and ran the tests, [X] of 5 runs passed without Coalesce and [Y] of 5 passed with it.

What we learned

Detecting a change is the easy part. The hard part is deciding who needs to know, when, and how to say it so an agent actually uses it. Agents respond well to context that's specific and shows up at the moment they need it.

What's next for Coalesce

We want to catch every kind of edit, support languages beyond Python, and finish support for other agents like Gemini CLI. We also want to add Slack in both directions and schema contracts that warn an agent when its change breaks an interface the team agreed on, which is exactly what bit us in class.