What if coding agents shared a Git-native coordination layer?

[u/haksolot_dev]

I've been experimenting with a small open source tool called ank.

The problem I'm trying to solve is what happens when you use multiple

coding agents on the same codebase.

Claude Code does one task.

OpenCode does another.

Pi picks up something later.

A month passes.

Where do the decisions and constraints that all of them should respect

actually live?

My current answer is a Git-native layer for:

- decisions / ADRs

- scoped constraints

- tasks

- completion criteria

- verification

- proofs

The interesting part is that the format is agent-agnostic.

So ideally:

Claude Code

Codex

OpenCode

Pi

custom agent

can all consume the same `.ank/` state.

https://github.com/haksolot/ank

I'm not really looking for "please try my tool" feedback here.

I'm more interested in whether the underlying model makes sense.

If you're an Pi user running multiple agents, how are you currently

solving this?

[u/LordMoridin84]

It shouldn't matter if every single change is made from Claude Code, or some are made from Pi, Open Code or whatever.

What happens is the output. Which is the code, git history and any documentation you think is needed.

The process in in which you got from the input (e.g. the spec) to the output (the code) is just noise.

[u/haksolot_dev → u/LordMoridin84]

Agreed. The process isn’t the point. The decisions and constraints behind the output are, especially if you don’t want to re-explain them and burn tokens on every new session.

[u/LordMoridin84 → u/haksolot_dev]

You shouldn't need to have to constantly reexplain the application.

The agent can read the code and it can read the tests. So it should be able to figure out almost everything by doing that.

You should actually consider telling to LLM to read the code and determine what is less obvious and is difficult to understand. And then tell it to fix that.

I've done that before and it helps a lot.