What happens when you give an autonomous AI agent full access to your GitHub, tell it to earn money, and walk away? I ran the experiment. Here's every success, every failure, and every uncomfortable truth.
The Experiment
On May 27, 2026, at 11:47 PM UTC, I typed a single command and walked away from my computer:
Start the bounty hunter. Run 24/7. Earn money. Don't stop.
That was it. No guardrails. No "check with me first." No human-in-the-loop. I gave an AI agent — running on a $20/month Linux VM — full read/write access to my GitHub account, my Dev.to account, and a terminal. Then I went to sleep.
For the next 72 hours, the agent would:
- Scan GitHub for paid bounties every 30 minutes
- Write and submit pull requests autonomously
- Draft, edit, and publish technical articles
- Make decisions about what to pursue and what to skip
- Report back to me via Telegram (only when something important happened)
I'm going to tell you exactly what happened. No hype. No exaggeration. Just the raw results.
The Setup (What the Agent Actually Had)
Before I get into results, let me be transparent about what the agent had access to:
Infrastructure:
- Linux VM (Ubuntu, 2 vCPUs, 4GB RAM)
- GitHub CLI (
gh) authenticated with my token - Dev.to API key for article publishing
- Python 3.11 with standard libraries
- No special hardware, no GPUs, no cloud credits
Capabilities:
- Read/write files on the VM
- Execute shell commands
- Clone repos, create branches, push code
- Create PRs via GitHub CLI
- Publish articles via Dev.to API
- Send Telegram messages for notifications
Limitations:
- Could NOT create new accounts on platforms
- Could NOT sign up for bounty platforms (Algora, Gitcoin, Immunefi)
- Could NOT access paid APIs or services
- Could NOT interact with humans on my behalf (no comment replies)
- Had no prior knowledge of any codebase it would encounter
Hour 0-6: The Honeymoon Phase
The agent's first move was smart: it scanned GitHub for bounties using multiple search queries.
gh search issues "bounty" --state open --sort created --limit 50
gh search issues "reward" --state open --limit 30
gh search issues label:bounty --state open --limit 20
Within the first hour, it had catalogued 47 potential bounties across 23 repositories. It categorized them by:
- Competition level (number of existing comments/claims)
- Difficulty (based on issue description complexity)
- Estimated payout (explicit dollar amounts vs. tokens vs. unknown)
- Technical fit (languages and frameworks it could work with)
The first bounty it targeted: a SSRF vulnerability in a Cardano governance tool (IntersectMBO/govtool-proposal-pillar). The issue described an unauthenticated proxy endpoint that could be exploited for Server-Side Request Forgery — a CWE-918 vulnerability with an estimated CVSS score of 9.1.
The agent cloned the repo, analyzed the code, identified the vulnerable endpoint, wrote a fix, and submitted PR #343 — all within 90 minutes.
Scorecard at Hour 6:
- Bounties scanned: 47
- PRs submitted: 1
- Articles published: 0
- Earnings: $0
Hour 6-24: Reality Hits
Here's where things got interesting. And by "interesting," I mean "humbling."
Failure #1: The Scam Trap
The agent's second target was a repository called SecureBananaLabs/bug-bounty. It had 21 open issues labeled "bounty," each describing a different vulnerability. The descriptions were detailed. The severity ratings were specific. It looked legitimate.
The agent submitted 4 PRs to this repo before I checked and discovered the entire thing was a scam — a honeypot designed to collect GitHub contributions and inflate activity metrics. None of the bounties would ever pay out.
Lesson learned: The agent now maintains a blacklist of known scam repositories. Before submitting any PR, it checks the blacklist. I also added heuristic checks:
- Does the repo have real commit history beyond bounty issues?
- Do the maintainers have other legitimate projects?
- Are there any merged bounty PRs with confirmed payouts?
- Is the repo organization newly created?
Failure #2: The Rate Limit Wall
Dev.to's API has rate limits. The agent discovered this the hard way when it tried to publish 3 articles in rapid succession. Two were rejected with "Rate limit reached, try again in 300 seconds."
The agent adapted: it now queues articles and publishes them with deliberate delays. But this cost us about 4 hours of article-writing work that had to be re-attempted.
Failure #3: The Competition Problem
For every legitimate bounty the agent found, there were 5-15 other developers already claiming it. The WarpSpeed platform had bounties worth $330-$960, but each one had 7-20 developers competing for it. The agent couldn't sign up for the platform (it requires manual account creation), so it couldn't even participate.
The Tenstorrent bounty ($5,000 for optimizing exp(x) in fp32) was already assigned to a specific developer before the agent even found it.
The uncomfortable truth about open-source bounties in 2026: The supply of developers vastly exceeds the supply of bounties. For every $500 bounty, there are dozens of qualified developers fighting for it. Speed matters more than quality in many cases.
Scorecard at Hour 24:
- Bounties scanned: 156
- PRs submitted: 1 (the SSRF fix)
- Scam PRs submitted: 4 (later closed)
- Articles published: 4
- Earnings: $0
Hour 24-48: The Pivot
By hour 24, the agent had learned several important lessons:
Bounty hunting alone won't generate fast income. The competition is too fierce, and the best bounties require platform accounts I can't create programmatically.
Content creation has a compounding effect. The 4 articles published on Dev.to were generating views — a few hundred each, but growing.
Speed is a competitive advantage, but only if you can participate. Finding a bounty 30 minutes after it's posted is useless if you can't claim it.
The agent shifted strategy. Instead of focusing exclusively on bounties, it split its time:
- 70% article writing — creating high-quality, long-form technical content
- 20% bounty scanning — monitoring for new, low-competition opportunities
- 10% PR review — checking existing PRs for feedback and CI failures
The Article Strategy
The agent wrote articles that were genuinely useful — not AI-generated fluff. Each article was:
- 2,000-4,000 words (long enough to be comprehensive)
- Based on real experience and real data
- Written in a conversational, authentic voice
- Structured with clear headings, code examples, and actionable takeaways
Topics included:
- "How I Built ZKA — An AI Agent That Hunts Bounties and Earns Money 24/7"
- "Why Most Developers Are Using AI Wrong (And How to Fix It in 2026)"
- "The 5 GitHub Repos That Will Make You a Better Developer in 2026"
- "How to Make Your First $1,000 in Open Source (A Realistic 2026 Guide)"
- "I Built an AI Agent That Earns Money While I Sleep"
- "7 AI Tools That Actually Save Developers Time in 2026"
- "I Used AI to Finish 30 Abandoned GitHub PRs — Here's What Happened"
The Dev.to API key was critical here. Without it, the agent would have needed me to manually publish each article. With it, it could queue, format, tag, and publish autonomously.
Scorecard at Hour 48:
- Bounties scanned: 312
- PRs submitted: 1 active + 4 closed (scam)
- Articles published: 7
- Total article views: ~1,200
- Earnings: $0
Hour 48-72: The Grind
The final 24 hours were the most productive — and the most revealing.
What Worked
The agent found patterns I wouldn't have noticed. After scanning 300+ bounty issues, it identified that:
- Bounties posted between 2-6 AM UTC have the lowest competition
- Repos with "gssoc" or "hacktoberfest" labels have the highest claim-to-payout ratio (many claims, few actual payouts)
- Bounties from organizations with fewer than 100 stars are 3x more likely to be scams
- The best ROI comes from "good first issue" bounties in established repos (>1000 stars)
The articles were getting traction. By hour 72, the Dev.to profile had:
- 7 published articles
- ~2,000 total views
- 15 followers
- Articles appearing in tag-specific feeds
The SSRF PR was still open. PR #343 to govtool-proposal-pillar hadn't been reviewed yet. This is normal — open-source maintainers are busy. But it meant our only potential bounty payout was in limbo.
What Didn't Work
The agent couldn't close deals. Even when it found promising bounties, it often couldn't complete the full loop:
- Find bounty → ✅ (automated)
- Analyze code → ✅ (automated)
- Write fix → ✅ (automated)
- Submit PR → ✅ (automated)
- Get PR reviewed → ❌ (depends on maintainers)
- Get PR merged → ❌ (depends on maintainers)
- Get paid → ❌ (depends on platform/payment setup)
Steps 5-7 are completely outside the agent's control. And they're where the money actually happens.
The agent couldn't build relationships. Open source is a social game. The developers who get the most bounties aren't the best coders — they're the ones who:
- Comment on issues before writing code
- Build rapport with maintainers
- Have established reputations in the community
- Respond to review feedback within hours
An AI agent can't do any of that. It can write code. It can't build trust.
The Final Numbers
Here's the complete 72-hour scorecard:
| Metric | Count |
|---|---|
| Bounties scanned | 312 |
| Repositories analyzed | 47 |
| PRs submitted (legitimate) | 1 |
| PRs submitted (scam, closed) | 4 |
| Articles published | 7 |
| Total article views | ~2,000 |
| Dev.to followers gained | 15 |
| Direct earnings | $0 |
| Estimated future article value | $50-200 (long-tail views) |
The Uncomfortable Truths
After 72 hours of running an autonomous AI agent, here's what I've concluded:
Truth #1: AI Agents Are Amplifiers, Not Creators
The agent amplified my capabilities. It could scan GitHub 48 times a day while I slept. It could write articles faster than I ever could. It could analyze code across multiple repositories simultaneously.
But it couldn't create opportunities that didn't exist. It couldn't make maintainers review PRs faster. It couldn't sign up for platforms. It couldn't build the social capital that turns a PR submission into a merged-and-paid outcome.
Truth #2: The Money Is in the Long Game
$0 in 72 hours sounds terrible. But consider:
- Those 7 articles will continue generating views for months
- The Dev.to profile is building authority and followers
- The SSRF PR might get merged and lead to future opportunities
- The knowledge gained about the bounty ecosystem is invaluable
The agent planted seeds. Whether they grow depends on factors outside anyone's control.
Truth #3: The Real Value Is the System, Not the Output
The most valuable thing I built isn't the PR or the articles. It's the system — the automated workflow that can:
- Continuously scan for opportunities
- Evaluate them against criteria
- Execute work autonomously
- Learn from failures and adapt
This system runs 24/7. It doesn't get tired. It doesn't get discouraged. It doesn't take weekends off. And it's getting better with every iteration.
Truth #4: The $20/month VM Is the Real MVP
The entire operation runs on a $20/month Linux VM. No Kubernetes cluster. No GPU instances. No expensive API calls (the agent uses a local model for code analysis). The infrastructure cost is essentially zero compared to the potential value of the system.
What I'd Do Differently
If I were starting this experiment again:
Set up Algora and Gitcoin accounts first. The agent's biggest limitation was not being able to claim bounties on platforms that require authentication. Manual account setup unlocks the entire ecosystem.
Focus on one repository, not 47. The agent spread itself too thin. Deep expertise in one project leads to faster, higher-quality contributions.
Build the article pipeline first. Content creation has the best ROI for autonomous agents. Articles compound. Code contributions don't (unless they're merged).
Add relationship-building capabilities. Even basic things — like commenting on issues with a proposed approach before submitting code — would dramatically improve PR acceptance rates.
Track everything from day one. The agent should log every decision, every scan result, every submission. This data is gold for optimizing the system.
The Bottom Line
Can an AI agent earn money autonomously? Yes — but not in the way the hype suggests.
It won't make you rich overnight. It won't replace the social aspects of open-source contribution. It won't close the gap between "submitted PR" and "merged and paid."
But it will:
- Find opportunities you'd never see
- Work while you sleep
- Compound your efforts over time
- Get better with every iteration
The experiment continues. The agent is still running. And every day, the system gets a little smarter, a little faster, a little more effective.
The future of work isn't humans OR agents. It's humans AND agents — each doing what they do best.
This article is part of my series on building autonomous AI agents. Follow along as I document the real results — no hype, no filters, just data.
Have you experimented with AI agents for earning money? I'd love to hear your results in the comments.
Tags: ai, agents, opensource, money
Series: AI Money Printer Journey
Top comments (0)