Bounty Watcher: An Autonomous AI Agent That Finds Paid Gigs While You Sleep

Two shell scripts. A cron scheduler. Hermes Agent as the delivery layer. Zero cloud costs. Freelance opportunities delivered to your Telegram every few hours.

What I Built

Bounty Watcher is an autonomous agent pipeline running on Hermes Agent that scans freelance bounty platforms 24/7, filters out noise, deduplicates, and delivers only relevant opportunities — straight to Telegram.

It covers two platforms:

Superteam Earn — crypto/solana bounties with cash rewards
GitHub Issues — open source bounties across the ecosystem

The agent has been running in production for weeks on an Android phone via Termux. It costs nothing to operate beyond the LLM tokens used for occasional reasoning tasks — which, in this architecture, is close to zero.

Category Submission

Build With Hermes Agent — Hermes Agent is the orchestrator: it schedules, monitors, delivers, and provides the agentic intelligence for filtering and prioritization.

How Hermes Agent Powers This

Architecture

+---------------------------------------------+
|               Hermes Agent                   |
|                                              |
|  +----------+  +----------+  +-----------+  |
|  |  Cronjob |  |  Cronjob |  |  Memory   |  |
|  |  (6h)    |  |  (3h)    |  | (dedup)   |  |
|  +----+-----+  +----+-----+  +-----------+  |
|       |             |                        |
|  +----v-----+  +----v-----+                 |
|  |Superteam |  |  GitHub   |                 |
|  | Script   |  |  Script   |                 |
|  +----+-----+  +----+-----+                 |
|       |             |                        |
|       +------+------+                        |
|              v                               |
|       +-------------+                        |
|       |  Delivery   |                        |
|       |  (Telegram) |                        |
|       +-------------+                        |
+---------------------------------------------+

Hermes Agent plays three roles:

Scheduler — The cronjob tool runs shell scripts on a fixed cadence (every 6h, every 3h). The scheduler handles retries, timezone management, and deterministic delivery routing.
Filter — Scripts use relevance scoring with curated keyword lists (Solana, DeFi, Rust, Python, bounties, etc.) to surface only matching opportunities. The scripts maintain a local cache to track seen issues and highlight new ones.
Messenger — Output is delivered directly to Telegram. When a script finds nothing new, it produces empty output — and Hermes Agent's cron system sends nothing. Silent by design. No spam.

Why No-Agent Crons?

Both bounty watchers use no_agent: true. This is a deliberate design choice:

Zero LLM cost — scripts run purely in shell/Python, no tokens consumed for data collection
Deterministic — same input always produces the same filtered output
Fast — execution completes in under 2 seconds per scan
Silent when empty — the watchdog pattern: script outputs text only when there's something to report

The Superteam Scanner

This script queries the Superteam Earn API, filters bounties by agentAccess status, and prioritizes by deadline proximity:

# Core filtering logic
RELEVANCE = [
    'solana', 'agent', 'defi', 'crypto', 'trading', 'blockchain',
    'smart contract', 'usdc', 'usdt', 'API', 'web3', 'rust', 'python',
    'typescript', 'nft', 'token', 'dex', 'amm', 'oracle', 'bridge',
    'validator', 'staking', 'airdrop', 'spl', 'jupiter', 'raydium',
    'sdk', 'CLI', 'cli tool', 'automation', 'bot', 'scraper',
    '$', 'reward', 'prize', 'earn', 'grants',
]

SKIP = ['translation', 'translate', 'typo', 'watchlist', 'parity']

# Relevance scoring
all_text = title_lower + ' ' + ' '.join(labels)
score = sum(1 for kw in RELEVANCE if kw.lower() in all_text)

if score == 0:
    continue  # Skip irrelevant

Key features:

Deduplication via persistent cache
AGENT_ALLOWED filtering — highlights bounties that explicitly permit AI-assisted submissions
Deadline awareness — sorts by hours remaining, skips expired
Human-only overflow — shows high-value human-only bounties ($1000+) as context

The GitHub Scanner

Uses GitHub CLI to search for bounty-labeled issues, then applies the same relevance engine.

Real Results

After weeks of running, the watchers have surfaced:

Superteam: 15-25 active bounties per scan, 3-5 with AGENT_ALLOWED status
GitHub: 5-10 relevant issues per scan, filtered from 30+ raw results
Signal-to-noise: ~30% of fetched results pass the relevance filter
Novelty detection: 2-4 new bounties per day

How to Deploy It Yourself

Prerequisites

Hermes Agent installed (pip install hermes-agent)
GitHub CLI (gh) authenticated
A Telegram bot connected to Hermes Agent

Step 1: Clone the repo

git clone https://github.com/AtlasNexusOps/hermes-bounty-watcher.git
cp hermes-bounty-watcher/scripts/* ~/.hermes/scripts/

Step 2: Schedule the crons

hermes cron add "every 360m" \
  --name "Superteam Bounties" \
  --script ~/.hermes/scripts/superteam_bounties.sh \
  --no-agent \
  --deliver origin

hermes cron add "every 180m" \
  --name "GitHub Bounty Scan" \
  --script ~/.hermes/scripts/github_bounties.sh \
  --no-agent \
  --deliver origin

Step 3: Let it run

That's it. You'll start receiving formatted bounty digests in Telegram every few hours.

What Makes This a Strong Hermes Agent Build

Hermes Agent is the backbone, not just a wrapper
Production-proven on modest hardware (Android/Termux)
Practical value — finds real paid opportunities
Composable — swap API endpoints and keywords for any platform
Cost-efficient — no-agent crons = zero LLM tokens for data collection

Future Directions

Multi-platform expansion (Gitcoin, OnlyDust, Bountycaster)
Agent-powered daily briefings
Automated proposal drafting

Built with Hermes Agent, running on an Android phone, delivering value every day.

推荐订阅源

DEV Community