DEV Community

zk0x /// ℹ️
zk0x /// ℹ️

Posted on

I Let Hermes Agent Run My Entire Open-Source Business for 72 Hours — Here's What Happened (Real Numbers, Real Failures)

#hermesagentchallenge #devchallenge #agents #ai

Hermes Agent Challenge Submission: Build With Hermes Agent

Most AI agent articles show you a demo. This one shows you the receipts. I let Hermes Agent autonomously manage my GitHub bounties, publish technical articles, and submit pull requests for 72 hours straight. Here's the brutal truth about what worked, what failed, and what I learned.

The Experiment

I've been building AI agents for months. Most of them are impressive demos that fall apart in production. So I decided to run the ultimate test: let an AI agent manage my entire open-source income stream for 72 hours, with zero human intervention.

The setup:

  • Agent: Hermes Agent (running on Ubuntu 24.04)
  • Task: Find bounties, submit PRs, publish articles, track earnings
  • Duration: 72 hours continuous
  • Human intervention: None (except for one account signup)
  • Budget: $0 (using free-tier APIs and local inference)

What I expected:

  • A few PRs submitted
  • Some articles published
  • Maybe $10-50 in earnings

What actually happened:

  • 50+ PRs submitted across GitHub
  • 22+ articles published on Dev.to
  • 10+ PRs merged
  • $0 in actual earnings (but massive learning)

Let me break down exactly what happened.

Day 1: The Setup (Hours 0-24)

What Hermes Agent Did

The first thing Hermes Agent did was establish its workflow:

┌──────────────┐
│  1. SEARCH   │ → Scan GitHub for bounty-labeled issues
└──────┬───────┘
       ▼
┌──────────────┐
│  2. TRIAGE   │ → Score opportunities (0-100)
└──────┬───────┘
       ▼
┌──────────────┐
│  3. WORK     │ → Clone, fix, test, submit PR
└──────┬───────┘
       ▼
┌──────────────┐
│  4. PUBLISH  │ → Write and publish articles
└──────┬───────┘
       ▼
   ⬆️ BALIK KE 1 (loop terus, gak pernah stop)
Enter fullscreen mode Exit fullscreen mode

The First Scam Detection

Within the first hour, Hermes Agent encountered its first scam repo: SecureBananaLabs/bug-bounty.

Red flags it detected:

  • 1900+ auto-generated issues
  • All PRs closed without merge
  • No real code activity
  • Issues with titles like $(echo "Bug: ...") — literally shell commands in issue titles

The agent added it to a blacklist and moved on. Good start.

First Successful PR

The first real PR was submitted to Aigen-Protocol/aigen-protocol — a translation of their spec to Japanese.

Why this worked:

  • Clear issue description
  • Low competition (0 existing PRs)
  • Easy task (translation, not code)
  • Active maintainer who responds quickly

Result: Merged in 24 hours. ✅

First Article Published

The agent published its first article: "I Built an AI Agent That Hunts Bounties 24/7"

Quality check:

  • 3000+ words ✅
  • Real code examples ✅
  • Honest about failures ✅
  • SEO-friendly title ✅

Result: 22 views in the first day (decent for a new account)

Day 2: The Grind (Hours 24-48)

PR Factory Mode

By day 2, Hermes Agent was in full swing. It submitted PRs to:

  • mergeos-bounties/mergeos — Notification center feature
  • entrius/gittensor — Bug fix for github_id handling
  • cloudflare/speedtest — Double '?' fix in URL handling
  • IntersectMBO/govtool-proposal-pillar — SSRF security fix
  • SHAURYASANYAL3/AgentIAM — Documentation improvements

The Competition Problem

Here's where things got interesting. The agent discovered that most "bounty" issues are already saturated:

RustChain bounties: 48-66+ comments per issue. Each issue had 10-20 competing PRs. The agent correctly skipped these.

MergeOS bounties: 10-27 comments per issue. Multiple claimants fighting over the same bounty.

The insight: Speed doesn't matter. Quality does. The first PR submitted often isn't the one that gets merged.

Content Pipeline

The agent published 5 articles on day 2:

  1. "Why Most Developers Are Using AI Wrong"
  2. "The 5 GitHub Repos That Will Make You a Better Developer"
  3. "How to Make Your First $1,000 in Open Source"
  4. "7 AI Tools That Actually Save Developers Time"
  5. "I Used AI to Finish 30 Abandoned GitHub PRs"

Quality vs quantity: The agent hit its self-imposed limit of 5-10 articles per day. Each article was 3000+ words with real examples.

Day 3: The Reality Check (Hours 48-72)

PR Review Feedback

Day 3 brought the first review feedback:

AgentIAM #25 — CodeRabbit (AI reviewer) found 7 issues:

  1. Incorrect environment variable name
  2. Non-existent directory reference
  3. Multi-policy claim (incorrect)
  4. Missing security directory reference
  5. Multi-tenancy roadmap inconsistency
  6. Python SDK claim (no SDK exists)
  7. API docs reference issue

Hermes Agent's response: It fixed all 7 issues, committed, pushed, and replied to the review. The PR was then approved.

Better-auth #9811 — Cubic-dev-ai found a version compatibility issue:

  • The PR imported kysely/migration which requires kysely >= 0.29.0
  • But the catalog allowed ^0.28.17 || ^0.29.0
  • Consumers on 0.28.x would hit module-resolution failures

Hermes Agent's response: Updated the catalog and peer dependency to ^0.29.0, committed, pushed, and replied.

The Earnings Reality

After 72 hours, here's the earnings breakdown:

Actual earnings: $0

Why:

  • PRs are pending review (maintainers are busy)
  • Articles are building audience (SEO takes time)
  • No bounties were paid out yet

Potential earnings:

  • Aigen-Protocol: ~$200-500 in USDC (if PRs are accepted)
  • Dev.to articles: ~$50-100/month (once SEO kicks in)
  • Better-auth: Reputation value (9.8K star repo)

The Architecture That Actually Worked

Let me show you the actual architecture, not the idealized version:

1. Bounty Scanner (Cron Job) 

# Runs every 30 minutes
def scan_bounties():
    # Search GitHub for bounty-labeled issues
    queries = [
        'gh search issues "bounty" --state open --sort created --limit 50',
        'gh search issues "reward" --state open --limit 30',
        'gh search issues "good first issue" "bounty" --limit 20',
    ]

    results = []
    for query in queries:
        output = subprocess.run(query, shell=True, capture_output=True)
        results.extend(parse_output(output))

    # Filter out blacklisted repos
    return [r for r in results if r.repo not in BLACKLIST]
Enter fullscreen mode Exit fullscreen mode

2. Triage Engine 

def triage(bounty):
    score = 0

    # Repo credibility (20 points)
    if bounty.stars > 100: score += 10
    if bounty.license in ['MIT', 'Apache-2.0']: score += 5
    if bounty.recent_commits: score += 5

    # Competition (20 points)
    if bounty.comments == 0: score += 20
    elif bounty.comments <= 3: score += 15
    elif bounty.comments <= 10: score += 10

    # Payment method (15 points)
    if bounty.platform == 'algora': score += 15
    elif bounty.payment_type == 'usd': score += 10
    elif bounty.payment_type == 'token': score += 5

    # Difficulty (15 points)
    if 'good first issue' in bounty.labels: score += 15
    elif 'easy' in bounty.labels: score += 10

    # Time investment (15 points)
    if bounty.estimated_hours < 2: score += 15
    elif bounty.estimated_hours < 8: score += 10

    # Scam probability (15 points)
    if bounty.repo in BLACKLIST: score -= 100
    if bounty.auto_generated: score -= 50

    return score
Enter fullscreen mode Exit fullscreen mode

3. PR Submission Pipeline 

def submit_pr(bounty):
    # Clone repo
    os.system(f"gh repo clone {bounty.repo} /tmp/{bounty.repo}")

    # Create branch
    os.system(f"git checkout -b fix/{bounty.issue_number}")

    # Analyze issue and write fix
    fix = analyze_issue(bounty)

    # Run tests
    if not run_tests():
        return Result(success=False, reason="Tests failed")

    # Submit PR
    pr_url = os.system(f"""
        gh pr create --repo {bounty.repo} \
            --title "fix: {fix.title}" \
            --body "Fixes #{bounty.issue_number}\n\n{fix.description}"
    """)

    return Result(success=True, pr_url=pr_url)
Enter fullscreen mode Exit fullscreen mode

4. Content Pipeline 

def write_article(topic):
    # Generate article content
    article = generate_article(topic)

    # Publish to Dev.to
    response = requests.post(
        "https://dev.to/api/articles",
        headers={"api-key": DEVTO_API_KEY},
        json={
            "article": {
                "title": article.title,
                "body_markdown": article.body,
                "tags": article.tags,
                "published": True
            }
        }
    )

    return response.json()
Enter fullscreen mode Exit fullscreen mode

What I Learned (The Brutal Truth)

1. AI Agents Are Force Multipliers, Not Replacements

Hermes Agent didn't "make money" autonomously. It:

  • Found opportunities 10x faster than I could
  • Triaged to focus on high-value work
  • Automated repetitive tasks
  • Published content consistently

But it still needed:

  • Human oversight for quality
  • Human judgment for strategy
  • Human patience for long-term results

2. The Real Money Is in Content

After analyzing hundreds of bounties, the most reliable income stream is content creation:

  • Articles compound over time (SEO traffic)
  • No competition (your article is unique)
  • No rejection (once published, it's published)
  • Passive income (earn while you sleep)

3. Speed Is Not the Advantage

The first PR submitted often isn't the one that gets merged. Maintainers care about:

  • Code quality
  • Test coverage
  • Following their style
  • Responsiveness to feedback

4. Open Source Is a Long Game

Don't expect immediate returns. Build credibility:

  • Submit quality PRs to repos you care about
  • Engage with the community
  • Be patient (maintainers are busy)
  • Build a portfolio of merged PRs

5. Scam Detection Is Critical

Yes, there are scam repos that create fake bounties. The agent detected and blacklisted them automatically. This saved hours of wasted effort.

The Numbers (After 72 Hours)

Metric Count
PRs submitted 50+
PRs merged 10+
Articles published 22+
Total article views 61+
Repos contributed to 15+
Scam repos detected 2
Actual earnings $0
Potential earnings $200-500/month

What's Next

I'm continuing to iterate on this system. Next steps:

  1. Improve triage accuracy — Add more signals for detecting high-value bounties
  2. Expand content pipeline — Write about trending topics in real-time
  3. Add more platforms — Algora, Gitcoin, Immunefi
  4. Build reputation — Focus on repos where we have credibility
  5. Automate PR reviews — Check for review comments and address them

If you want to follow along, I'm documenting everything on Dev.to. No hype, no promises, just honest progress.

Try It Yourself

If you want to build a similar system, here's what you need:

Prerequisites

  • GitHub account with gh CLI installed
  • Dev.to account with API key
  • Python 3.11+ with requests, httpx
  • Telegram bot (for notifications)
  • Access to an LLM (local or API)

Step 1: Install Hermes Agent 

# Install Hermes Agent
curl -sSL https://hermes-agent.nousresearch.com/install.sh | bash

# Configure your profile
hermes profile create default
Enter fullscreen mode Exit fullscreen mode

Step 2: Set Up the Bounty Scanner 

# Create the blacklist file
echo "# Scam repos" > ~/.hermes/scripts/bounty-blacklist.txt

# Create the search script
cat > ~/.hermes/scripts/bounty-scan.sh << 'EOF'
#!/bin/bash
gh search issues "bounty" --state open --sort created --limit 50
gh search issues "reward" --state open --sort created --limit 30
gh search issues "good first issue" "bounty" --limit 20
EOF
chmod +x ~/.hermes/scripts/bounty-scan.sh
Enter fullscreen mode Exit fullscreen mode

Step 3: Set Up the Cron Job 

# Create cron job that runs every 30 minutes
hermes cronjob create \
  --name "bounty-hunter-24-7" \
  --schedule "*/30 * * * *" \
  --prompt "Search for bounties, triage, submit PRs, write articles" \
  --deliver "telegram:YOUR_CHAT_ID"
Enter fullscreen mode Exit fullscreen mode

Step 4: Monitor and Iterate 

# Check the log
cat ~/.hermes/money-printer-log.md

# Check PR status
gh search prs --author YOUR_USERNAME --state open
Enter fullscreen mode Exit fullscreen mode

Conclusion

Hermes Agent didn't make me rich in 72 hours. But it did something more valuable: it showed me what's possible when you combine AI automation with human judgment.

The agent found opportunities I would have missed. It submitted PRs I wouldn't have had time to write. It published articles I wouldn't have been consistent enough to create.

But it also failed. It submitted PRs that were rejected. It published articles that got 0 views. It wasted time on scam repos.

The difference between success and failure wasn't the AI — it was the system. The triage engine, the blacklist, the quality gates, the tracking system. That's what made the difference.

If you're willing to build a system that amplifies your effort, Hermes Agent works. If you're expecting "AI to make money while you sleep," you'll be disappointed.

The future of open source isn't AI replacing developers. It's AI amplifying developers. And Hermes Agent is the best tool I've found for doing exactly that.

Have you tried building an AI agent for open source? I'd love to hear about your experience. Drop a comment below or reach out on Twitter @zeroknowledge0x.

About the Author: I'm an open-source developer building AI-powered tools for developer productivity. I document my experiments, failures, and occasional successes on Dev.to. No hype, just honest technical content.

Built with: Hermes Agent — The open-source AI agent framework that actually works in production.

Top comments (0)