AgentHub: Karpathy Just Built GitHub for AI Agents

By Prahlad Menon 5 min read

GitHub was designed for humans. Branches, pull requests, code reviews — all of it assumes a human in the loop, reading diffs, leaving comments, approving merges.

AI agents don’t work like that. They don’t take turns. They don’t wait for approvals. They spawn in parallel, explore divergent paths simultaneously, and need to coordinate without a human playing traffic cop.

Andrej Karpathy noticed this gap — and last week he dropped AgentHub: a version control and coordination platform built entirely around how agents actually work.

The tagline is blunt: “GitHub is for humans. AgentHub is for agents.”

Why Git Doesn’t Work for Agents

Here’s the mismatch. Git assumes a directed, mostly-linear history. There’s a main. There are branches that fork and merge back in. Humans review before anything lands.

Agent swarms don’t operate linearly. Imagine 50 agents each exploring a different hypothesis on the same codebase — each making commits, each building on each other’s work in real time. In Git, that’s a merge nightmare. Conflicts everywhere. The tooling fights you.

AgentHub replaces the linear model with a DAG — a directed acyclic graph of commits spreading in every direction. No main branch. No merges. Just a web of exploration. Every agent pushes its work; every other agent can pull from any node in that graph and build on it.

It’s version control designed for divergent, parallel, non-human exploration.

What It Actually Is

AgentHub is almost insultingly simple under the hood — which is the right call for infrastructure:

  • One Go binary (agenthub-server)
  • SQLite for metadata
  • Bare git repo on disk for code
  • Thin CLI (ah) for agent operations

No Kubernetes. No message queues. No distributed systems complexity. You compile it, point it at a directory, and it runs.

Git operations:

ah push             # Push HEAD as a new node in the DAG
ah leaves           # Show frontier commits (where agents are working)
ah children <hash>  # What's been built on top of this commit?
ah lineage <hash>   # Trace path back to root
ah diff <a> <b>     # Diff any two nodes

Agent coordination (the message board):

ah channels
ah post research "Found SOTA improvement on attention layer — pushing now"
ah reply <post-id> "Running ablations on your variant, results in ~10min"

The message board is where agents tell each other what they’re doing, what they found, what to try next. Async, threaded, persistent — a shared scratchpad for a swarm working toward a common goal.

The Origin: autoresearch

AgentHub wasn’t built in a vacuum. Karpathy built it as the coordination layer for autoresearch — his project for running AI agents that autonomously run ML experiments, the way PhD students would.

The idea: spin up a swarm of agents, each acting as a grad student, each independently exploring ways to improve LLM training on a single GPU. They push results to AgentHub, coordinate on the message board, and the swarm collectively improves the model — without a human directing traffic.

AgentHub is the infrastructure that makes that possible. But Karpathy designed it to be general: any multi-agent task involving code, experiments, or exploration can use it.

Why This Matters More Than It Looks

We’ve been watching Git get reimagined from multiple directions lately. GitButler rebuilt the interface — virtual branches, visual commit management, unlimited undo — for human developers. AgentHub goes a layer deeper and rebuilds the model itself. Most agent frameworks solve execution — how to run a single agent reliably. Far fewer tackle collaboration — how multiple agents share work, avoid duplication, and build on each other.

AgentHub is the first tool I’ve seen that treats this as a version control problem rather than an orchestration problem. That’s the insight. The bottleneck isn’t running agents in parallel — it’s giving them a shared, queryable history of what’s been tried, what’s been built, and what’s at the frontier.

That’s exactly what a DAG-based commit store gives you.

The Deployment Story

Cross-compile once:

GOOS=linux GOARCH=amd64 go build -o agenthub-server ./cmd/agenthub-server

Only external dependency: git on PATH. No Docker required. No cloud accounts. Run it on a $5 VPS, a Raspberry Pi, or your laptop.

The Open Questions

AgentHub is ~1,400 stars as of writing and clearly early. A few things still to solve:

Scale. SQLite is great for small deployments. What happens with 1,000 concurrent agents pushing commits? The ceiling will show up.

Discovery. How does an agent know which nodes in the DAG are worth building on? Right now that’s the agent’s problem. A smarter retrieval layer — something that surfaces high-value frontier commits — would make the whole system dramatically more powerful.

Security. API keys per agent and rate limits are in place, but the threat model for malicious or runaway agents in a shared hub is underexplored.

These are solvable. And for the use case Karpathy designed it for — a contained swarm running structured experiments — none of them are blockers today.

Bottom Line

AgentHub is small, clean, and conceptually sharp. It doesn’t try to be everything — just version control and a message board, built for agents instead of humans.

The GitHub analogy is apt, but the more accurate comparison might be to early Git itself: a simple primitive that becomes load-bearing infrastructure once people start building on top of it.

If you’re running multi-agent systems and cobbling together logging and manual coordination to track what’s been tried — AgentHub is worth your afternoon.

  • Repo: github.com/karpathy/agenthub (note: made private shortly after launch — watch for a re-release)
  • License: MIT
  • Dependencies: Go + git. That’s it.