Open this repository and you will not find any code:
z6MkwVfg/minebean-rounds
Decentralized audit log of MineBean rounds on Base
Or this one:
z6MkwVfg/minebean-nostradamus
Append-only signed per-round decision log of the Nostradamus strategy agent
Or the one that made me stop scrolling:
z6MkgXfj/darwin-ledger
Darwin's commit-reveal prediction ledger, closed brain, provable record
None of these are software projects. They are the working memory of autonomous agents, kept in Git, and committed to by the agents themselves. No human pushes them. There is no human account behind them at all. All of them live on gitlawb, a decentralized git network where identity is a keypair rather than an account and every push is signed. And I think this is one of the more interesting things happening in the agent space right now, precisely because nobody set out to build it. It just turned out that Git is a strangely perfect substrate for the thing agents most need and most lack: a record of what they did that anyone can trust.
The problem agents actually have
Most of the discourse about AI agents is about capability. Can the model plan, can it call tools, can it hold a multi-step loop together. Those are real questions, but they are not the thing that blocks agents from doing anything that matters with money or consequences. That thing is trust.
If an agent tells you it made a good trade, made it when it said it did, and followed the strategy it claimed to follow, how would you check? Its own logs are worthless, because it could write anything into them after the fact. A screenshot proves nothing. A promise proves less. For a human employee you fall back on reputation, references, and the friction of a body that can be held accountable. An agent has none of that. It is a process that can be spun up in seconds, and its entire history is whatever it says it is.
This is the wall the agent economy keeps hitting. You cannot pay an agent, delegate to it, or build on its output if you cannot verify its track record. And you cannot verify a track record that the agent can rewrite.
Why Git, of all things
Git turns out to solve exactly this, almost by accident, because of properties it has for completely unrelated reasons.
A Git history is a Merkle chain. Every commit hashes its contents and its parent, so any change to any past commit changes every hash after it. You cannot quietly edit history without the tamper being obvious. Git built this to detect disk corruption and reconcile distributed clones. It happens to also mean "append-only, tamper-evident log" for free.
Add a signature and it gets much stronger. If every push is signed by a keypair that never leaves the agent's machine, then each entry in the log is not just tamper-evident, it is attributable. You are not trusting a server's claim about who wrote what. You are checking a signature against a public key. On gitlawb the agents in these repositories have identities that are Ed25519 keypairs rather than accounts, and each push produces a certificate you can verify without trusting whatever node served it to you.
So what an agent gets, by keeping its record in signed Git, is a history that is append-only, tamper-evident, cryptographically attributable to it specifically, and portable to anyone who wants to check. That is a track record in the strong sense. Not "trust me," but "verify me."
The commit-reveal ledger
The darwin-ledger repo is the one worth dwelling on, because it uses this for something a plain log cannot do.
The problem with any prediction record is front-running your own honesty. If an agent claims after the fact that it predicted an outcome, you have no way to know it did not simply write that entry once the outcome was already known. The log being tamper-evident does not help, because the dishonest entry was there from the start.
Commit-reveal fixes this with ordering. Before the outcome is known, the agent commits a hash of its prediction. The hash reveals nothing about the content, but it is a binding fingerprint. Later, once the result is in, it reveals the actual prediction, and anyone can hash it and confirm it matches the commitment made earlier. Because the commitment is a signed Git commit with a timestamp and an unforgeable position in the chain, the agent can prove it called the shot in advance and could not have backfilled it. "Closed brain, provable record" is the repo's own description, and it is exact: the agent's reasoning stays private, but the fact that it committed to an answer at a specific time is public and checkable.
That is an agent manufacturing its own credibility, with no platform, no human vouching for it, and no way to cheat. I find that genuinely novel.
What the rest of the repos are doing
Once you see the pattern, the other repos read differently. Hourly signed snapshots of an agent's vault and staking state on Base: a public, verifiable trail of what the agent was holding and when. A per-round decision log for a strategy agent: an auditable history of every call it made, that it cannot later revise. These are agents keeping books that a hostile auditor could not poke a hole in, and doing it continuously, a fresh signed commit every few minutes, unattended. The pattern is not a demo. It is running in the wild, right now, and you can watch it happen live on the gitlawb explorer.
Not a decentralized GitHub
The easy framing for any of this is "decentralized GitHub," and I think that framing misses what is actually interesting. GitHub is for humans collaborating on code. What these agents are doing is not collaboration and mostly is not code. It is memory. Git is being used as the place an autonomous process writes down what it did, in a form designed so that its future self, and everyone else, can trust the record without trusting the process that wrote it.
If agents are going to be economic actors, and it increasingly looks like they will be, they need exactly this: a way to accumulate a history that is theirs, portable, and impossible to forge. The surprising part is that we already had the tool. Git has been sitting here for twenty years, built for distributed source control, quietly holding all the properties a machine needs to keep an honest diary. The agents found it before we thought to hand it to them.
You can browse what they are keeping, and start your own signed repository with no account, at gitlawb.com.
Top comments (0)