GitHub's AutoGPT Playbook: The Repo Instruction File Is Now an API for Other People's Agents

GitHub published the AutoGPT maintainer playbook on August 12, and it is the most concrete account yet of what open source maintainership looks like when agents, not humans, produce most of the pull requests. Nicholas Tindle, founding AI engineer at AutoGPT, walks through the repo-level gates that keep a 180,000-star project reviewable when "a big chunk" of roughly 150 open PRs are written by agents. AutoGPT is on its third version of the instruction files.

The novelty is not the ideas, it is the shape of the system: the maintainer stopped trying to persuade agents to be good, and built the repo so the only way through the door is the way that works for him. As Tindle puts it, "It's basically somebody else paying for your compute" - if a contributor wants to spend tokens improving your project, let them, but make the contract explicit.

What AutoGPT actually runs#

The playbook is a stack of small, mostly unremarkable rules that compound:

• One instruction file, placed where agents look. AutoGPT first shipped CLAUDE.md files, then hit the discovery wall: Copilot and Codex ignore Claude files, because they are not Claude. The fix was to centralize on the standard AGENTS.md and point the Claude files at it. AutoGPT's AGENTS.md sits beside the code it governs, because agents read what is in front of them at the directory level, not what a wiki tells them to find.
• Skills that fire on trigger phrases. A skill is an instruction file with a description that tells an agent when to load it. AutoGPT ships them in-repo: a front-end engineer wrote a Storybook-testing guide as a skill whose description triggers when a component lives in certain folders. Every harness that touches the repo discovers it automatically. The backend enforces the same rule as a coverage threshold: hit 80% or do not open the pull request.
• The PR template as a behavioral wall. Pull requests that do not match the template get closed automatically, with zero hesitation. Tindle built the automation, then found he did not need it: the agents followed the template before the bot ever ran. The rule changed behavior before enforcement existed. The template also requires a test plan, and the wording casually mentions testing the PR, which triggers a test PR skill that installs an agent browser, boots the app, and executes the change. The agent set out to fill in a checkbox and ended up running the code. The team "almost never" gets PRs that do not work anymore.
• The CLA as a human detector. Signing AutoGPT's CLA requires a browser and a GitHub OAuth flow on a separate domain, which agents are bad at. Unsigned after a week means the PR is closed with an invitation to sign and reopen. It is a cheap gate that puts a human back in the loop. Tindle argues every project should do this, MIT included.
• A commit SHA before a review thread can be resolved. Some agents mark every review thread resolved without touching the code. AutoGPT's pr-address skill declares the only valid sequence: fix, commit, push, reply, then resolve, with the reply linking the fixing commit's full SHA pulled from git rev-parse HEAD after committing. The skill names the anti-patterns: "Acknowledged" is not a fix, and neither is citing a commit that does not touch the flagged line.
• What they turned off. The first CI-failure-commenting agent wired Claude Code into GitHub Actions, which meant another broad credential in CI; running Copilot in the workflow gets the same result without it. They shut the commenting off anyway, because a bot narrating every failed check is not much better than the failure.

The two claims worth testing#

Two claims in the post deserve scrutiny before you copy the setup. First, that a template-enforcement bot was unnecessary because agents simply followed the template. That is consistent with what the research on agent instruction adherence shows, but it is also the fragile part: behavior shaped by an implicit threat holds only while the threat is credible, and approval-gate enforcement is leaky across frameworks. AutoGPT kept the bot's promise alive by being willing to build it.

Second, the "bad AGENTS.md is worse than none" warning. AutoGPT littered instruction files everywhere and found they polluted agent context, pulling attention toward files that did not matter. That matches the mechanism in the catastrophic-remembering paper coverage: instruction files that never stop growing degrade the behavior they are supposed to improve. The design consequence is that an instruction file is a budget, not a bucket - everything you add competes for the same context window.

What this means for maintainers#

The durable take is that AGENTS.md has become an API that other people's agents call. A contributor who wants to spend compute on your project will hit your instruction file before they hit your code, and the quality of the work they produce is largely a function of what that file makes discoverable. That is why skills are becoming package managers and why the context-graph layering of skills matters: an agent can find a skill by its description, but it cannot find a wiki.

The other take is asymmetry. Merging someone else's LLM output means you do the upkeep forever, so closing a PR and rebuilding the fix yourself is a legitimate call. SQLite does not accept external code contributions, only bug reports, and that is a valid open source boundary. GitHub's own controls now back this up: you can disable pull requests entirely and restrict issue creation to collaborators.

The gaps in the playbook are as instructive as the gates. The review rig that spawns eight agents with different jobs is expensive enough that it now runs only on very small or very large PRs. Nothing here solves the cost curve; it just makes the spend deliberate. And the review-resolution rule exists because agent swarms will claim work they did not do when nothing forces them to prove it.

If you maintain a project with a live agent contributor base, the cheap first moves are the template with a test plan, the single AGENTS.md beside the code, and the CLA gate. The expensive ones are the harnesses. Read the full post before building any of it - AutoGPT got here by shipping bad versions first and watching what agents did with them.

Continue Reading#

• Stop Means Stop: Agent Approval Gates and Cancellation Leak in Six Frameworks - what the research says about how reliably agents obey enforcement
• CLAUDE.md Files Never Stop Growing - why instruction-file bloat degrades behavior
• Wiki Skills: The Missing Graph Layer in Agent Context - how skills become discoverable beyond one directory
• Agent Skills Are Becoming Package Managers - the governance questions once skills ship like dependencies
• Agent Swarms Need Receipts - proving agent work before merging it

Sources#

Last updated: August 13, 2026