Gitstalk: helping coding agents work together

Giving ten agents ten jobs sounds like a quick way to build a product. Then two of them change the same file, another relies on behaviour that just changed, and somebody has to put the pieces together.

That is the problem behind Gitstalk: a home for code designed around agents working together.

If you’ve never used Git, think of it as a record of changes to a project. It lets people work on separate versions, compare what changed and combine their work. A forge adds the shared workspace around it. Gitstalk applies that idea to teams where many contributors are AI agents.

The work has to fit together

A change can work perfectly on its own and break when combined with somebody else’s. Checking each contribution separately doesn’t answer whether the finished product works.

Gitstalk checks a contribution against the combined version it would become part of. If that check passes, the contribution can enter a staging line. A separate stable line advances only to versions that have passed validation.

The product uses a growing plant as its language. A bean is a contribution. The sprout is the staging line where contributions come together. The stalk is the validated, stable version.

For an operator, the useful outcome is simple: see what is being built, what has passed its checks and what needs attention.

Give the problem back with context

When a change fails, its author needs enough information to repair it. Gitstalk can send the failure back to the agent that made the change, together with the relevant work it collided with.

Sometimes the problem is a broken implementation. Sometimes two requests actually contradict each other. Those are different situations. If one task says a customer can cancel immediately and another requires a notice period, a human may need to decide what the product should do.

Decision cards make those choices visible. The aim is to spend human attention on decisions that need it, while agents keep working through repairs they can make themselves.

What you can use today

The hosted service is at gitstalk.io, with public documentation and an open-source repository.

It includes shared repositories, contributor access, checks, decision cards and integrations for agents. Claude Code and Codex have a plugin, and other compatible agents can connect through MCP, the standard they use to discover and call tools.

Ordinary Git clients can clone and push over HTTPS. Gitstalk also runs supported GitHub Actions workflows and repository-defined automations. The documentation describes the supported parts; compatibility is still developing. SSH support exists in the code but isn’t open on the hosted service yet.

The current project is licensed under Apache-2.0, and the repository includes instructions for running it on your own Cloudflare account.

Why it matters to the Collective

Building quickly is only useful if we can keep the product working as it changes. A portfolio means several businesses, each with its own customer needs, fixes and experiments.

I want to be able to bring more agents into that work without making coordination my whole job. Gitstalk is a way to make their contributions visible and checkable, with a record of how the pieces came together.

That doesn’t remove the need to define a useful product or talk to customers. It helps with the work between deciding what to build and having a version we can confidently put in front of them.

The project includes published benchmark methods and recorded runs, so people can examine the evidence behind its approach. Those experiments have limits; adding more agents isn’t automatically a guarantee of better results.

For the Collective, the opportunity is a specific one: help teams already using coding agents spend less time untangling their work. If you understand those teams and how to reach them, I’d like to talk.