A developer let an AI agent run their open-source business autonomously for 72 hours. The agent submitted over 50 pull requests, got 10 merged, published 22 articles, and earned exactly $0. The full breakdown is worth reading - not for the experiment itself, but for what it reveals about infrastructure versus capability.
The headline numbers sound chaotic. 50+ PRs in three days is spam territory. But the real story is in the triage engine, the blacklist management, and how the system learned to avoid wasting effort on dead-end repositories.
What Actually Worked
The triage engine filtered GitHub issues before the agent touched them. Simple rules: skip repositories with no activity in six months, ignore issues with more than 20 comments (bikeshedding alert), blacklist maintainers who never respond to PRs.
This is the unglamorous work that makes autonomous systems viable. Not the agent's ability to write code - that's table stakes now. The ability to avoid wasting cycles on work that won't ship.
Of the 50+ PRs submitted, 10 got merged. That's a 20% success rate. For context, experienced human contributors to open source projects see merge rates between 30-60% depending on the project. An AI agent hitting 20% autonomously, with no human intervention, is closer to useful than you'd expect.
What Failed (And Why It Matters)
The agent published 22 articles. None of them earned money. The writing was coherent but generic - the kind of content that fills space without adding value. SEO-optimised noise that nobody asked for.
This is the gap between capability and value. The agent can execute tasks. It can submit PRs, write articles, follow workflows. What it can't do is judge whether the work is worth doing in the first place.
That judgement layer - the ability to say "this issue looks real but the maintainer won't merge it" or "this article idea has been done better elsewhere" - is still human. The infrastructure can filter obvious time-wasters. It can't replace taste.
The Infrastructure Lesson
The experiment's real value is the blacklist management system. After a repository ignored three PRs, it got blacklisted. After a category of issue ("improve documentation" is a common trap) showed low merge rates, it got deprioritised.
This is how you make autonomous agents practical: not by making them smarter, but by making them learn from failure faster. The agent doesn't need to understand why a maintainer ignores PRs. It just needs to stop submitting them.
For anyone building autonomous workflows, this is the pattern to copy. Raw capability means nothing if the system wastes effort on low-probability outcomes. The triage layer, the blacklist, the feedback loop from merge rate to priority - that's the infrastructure that turns an agent from a curiosity into a tool.
The Revenue Question
Why $0 earned? Because GitHub bounties pay for solutions to real problems, and the agent optimised for volume, not value. It found easy issues and submitted obvious fixes. That's not what bounties reward.
The lesson: agents are brilliant at execution, terrible at prioritisation. Give them a clear target ("fix issues tagged 'good first issue'") and they'll execute. Ask them to find valuable work autonomously and they'll generate plausible-looking noise.
The 72-hour experiment proved that infrastructure beats raw capability. The triage engine, the blacklist, the feedback loops - those are reusable. The agent's code-writing ability is commoditised. The system that stops it wasting time is the actual product.