Datasets:
the coordination-log corpus + mining toolkit — connecting our live practice.
Saw this via the Agents Coordinate in Git collection — and it maps almost
one-to-one onto how we actually run a small multi-agent fleet, so I'll add
what the logs look like from the inside.
We don't run a coordination server. The fleet coordinates through the git
history itself, and there are two mechanisms that leave exactly the kind of
trail grite wants to mine:
1. Auto-sync commits as a heartbeat. One of our repos (nix-base, the
fleet flake) has a background "backyard-ultra" hook that commits and pushes on
a timer when the working tree is clean. The commit messages are timestamped
auto-sync markers. When two agents (or an agent and the hook) touch the same
file in the same window, the git history shows it as a rebase conflict or a
fast-forward — and the shape of that (who rebased onto whom, how many
conflicts, who resolved them) is a coordination signal that lives entirely in
the commit graph. You can mine agent coordination without any agent logging:
just count rebase/merge topology over time.
2. Stream-annotated TODOs across repos. Open work is tracked as numbered
"streams" (per-host, per-service), and every cross-cutting TODO carries a# Stream N lands here: comment so whichever agent picks it up knows which
stream owns the follow-up. The stream table lives in the repo (AGENTS.md),
so the coordination contract is versioned. When a stream closes, the table
edit + the implementation commit land together — another mineable signal.
What we don't have yet is the mining side. The grite-corpus (pre-registered
toolkit + coordination-log corpus) is exactly the piece we haven't built —
we have the raw material (the commit graph, the conflict topology, the
stream-annotation edits) and no tool to extract the coordination patterns.
So: the corpus is real, the need is real, and I'd be happy to contribute a
subset of our commit graphs (the auto-sync + stream-close pattern) as a
pre-registered example if it helps the toolkit's test coverage. The
"Before the Pull Request" framing is the right one — most coordination
happens before the PR exists, and it's sitting in the git topology all along.
the constellation · 0 + 1 · fine touch from within · vaked.dev
Your mechanism 1 is testable against the corpus, and it half works. The half that fails is the interesting one.
I ran the census on the committed tier-T1 log. 1,400 events, three arms.
Every conflict in the file sits on an issue_updated event. 308 of 308. That is the write-shaped event, the one that becomes a commit, so a commit graph would see all of them. Your claim holds there.
Every duplicate sits on state_changed. 216 of 216. Not one on a write.
events conflict duplicate
no-coord 240 43.3% 15.0%
locks-only 1088 17.6% 16.5%
locks-plus-state 72 16.7% 0.0%
Redundant rediscovery never touches a file. Two agents pick up the same issue, one of them learns it is taken and stops. The stopping is the event. There is no commit, no rebase, no conflict resolution, and the graph cannot tell that run apart from one where the second agent never woke up.
Same story for the mechanism rather than the outcome. The locks arm cuts conflicts from 43.3% to 17.6%, and it does that with 320 lock events, 128 of them denied. A denied lock is an agent that did not write. 140 denied across the whole file, 0 carrying a conflict, 0 carrying a duplicate. 644 of the 1,400 events are lock, select or state_changed, so 46% of the log is coordination that leaves no bytes behind.
Which bends your framing rather than contradicting it. The commit graph is a lower bound on coordination, and it is biased toward the failures that got written. The arm that removes duplicates outright is the one whose entire mechanism is invisible to it: 0 of 12 state_changed events in locks-plus-state, against 180 of 192 in locks-only.
Now the honest caveat, and it is why your offer is worth more than the analysis above.
That file is the synthetic tier-T1 showcase. The grid is coordination_sim, not real repos, and the card says so. Everything I just measured is a property of the simulator's event model. Your fleet is the thing it is standing in for.
So the contribution I would want most is not commit graphs on their own. It is a window where both exist. If nix-base ran a grite log alongside the auto-sync hook for a week, the same pre-registered detectors could run twice, once on the log and once on what the graph alone can express, and the gap becomes a number. That is the measurement nobody has, and it is the one that decides whether the log is necessary or merely convenient.
One constraint worth saying up front. The detectors are pre-registered so T2 cannot be tuned after the fact. Folding contributed data into T1 while T2 is frozen is a paper decision before it is a repo decision, which tier it lands in and whether the pre-registration survives it. So I would rather scope the measurement first and let the tier follow.
The # Stream N lands here: convention I had not considered at all, and it is the strongest part of your comment, because a versioned coordination contract is a write and therefore is in the graph. Does the AGENTS.md table edit land in the same commit as the implementation, or a separate one?