Forem: Alexandre Lasly

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

Alexandre Lasly — Sat, 16 May 2026 00:26:25 +0000

This is a submission for the Hermes Agent Challenge

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 — close to zero in this architecture.

Demo

The agent delivers formatted bounty digests directly to Telegram every few hours:

🏆 Superteam Bounties — filters by AGENT_ALLOWED status, deadline proximity, and tech relevance
🐙 GitHub Bounty Scan — scores issues by keyword relevance, extracts bounty amounts from labels

When there are no new results, the script produces empty output and Hermes Agent sends nothing. Silent by design.

Code

Full source available at: AtlasNexusOps/hermes-bounty-watcher

My Tech Stack

Hermes Agent — scheduling, delivery, and orchestration
Bash + Python — data fetching, filtering, deduplication
GitHub CLI — issue search and metadata extraction
Superteam Earn API — bounty listings
Telegram — delivery channel
Android/Termux — production runtime (ARM64, always-on)

How I Used Hermes Agent

Hermes Agent is the backbone of this project — not a wrapper, not an afterthought. Here is exactly how it powers every layer:

1. Cron Scheduling (cronjob tool)

The cronjob tool schedules both scanners on fixed cadences:

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

The --no-agent flag means scripts run directly (zero LLM tokens). Hermes handles retries, timezone management, and deterministic delivery routing.

2. Watchdog Pattern (script collects, script filters, agent delivers)

This is the architecture that makes the project cost-efficient:

Script → API fetch → Python filter → dedup cache → output
                                                        ↓
                                            Hermes Agent delivers to Telegram
                                            (silent when output is empty)

Zero LLM cost for data collection — scripts run in shell/Python
Deterministic — same input always produces the same filtered output
Silent when empty — watchdog pattern: only notifies when there is something new

3. Relevance Scoring Engine

The filtering logic uses curated keyword lists to surface only matching opportunities:

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",
]

all_text = title_lower + " " + " ".join(labels)
score = sum(1 for kw in RELEVANCE if kw.lower() in all_text)

4. Why Hermes Agent and Not a Regular Cron?

A regular cron job would just dump raw API output into a chat. Hermes Agent provides:

Delivery routing — --deliver origin ensures output goes back to the right Telegram chat
State management — the agent maintains the cron lifecycle (pause, resume, remove, list)
Memory — persistent cache for deduplication across sessions
Composability — cron jobs can chain (context_from), allowing future expansion (e.g., a summarization job that reads the scanner output)
Script-only mode — no_agent: true lets us bypass the LLM entirely for mechanical data collection while still benefiting from the delivery infrastructure

5. Production Results

After weeks of continuous operation:

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 flagged as new

How to Deploy It Yourself

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

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

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

Running Hermes Agent on Android: A Production AI Agent in Your Pocket

Alexandre Lasly — Sat, 16 May 2026 00:25:30 +0000

This is a submission for the Hermes Agent Challenge

No server. No cloud bill. Just a phone, Termux, and an AI agent that ships code.

When I first heard about Hermes Agent, the open-source agentic framework from Nous Research, I did what any reasonable developer would do: I tried installing it on my laptop. It worked. Then I asked myself — what if I could run it on my phone, always on, always ready?

Turns out you can. And it is surprisingly practical.

The Setup: Android + Termux

Termux gives you a functional Linux environment on Android. With it, you get bash, Python, Node.js, git — everything you need. Installing Hermes Agent is a one-liner:

pkg install python git
pip install hermes-agent
hermes setup

The setup wizard walks you through picking a provider (I use DeepSeek), configuring tools, and connecting messaging platforms. Within 10 minutes, I had a fully operational AI agent running on a Samsung phone.

Why Run an Agent on Your Phone?

Three reasons:

Always-on. Your phone is already on 24/7. No separate device, no VPS, no cloud bill.
Messaging-native. Hermes Agent connects to Telegram natively — you interact with it like a contact. Wake up, check your messages, ask your agent what happened overnight.
Capable. Despite running on ARM64 with limited RAM, Hermes performs real agentic work: multi-step reasoning, tool orchestration, file manipulation, git operations, web search, and cron scheduling.

How an AI Agent Let Me Work on an Entire GitHub Portfolio — From My Phone

This is where Hermes Agent truly shines. Over the past weeks, I built and deployed an entire professional portfolio site — portfolio design, HTML/CSS edits, Git versioning, GitHub Pages deployment, README documentation, and even a separate open-source project — all through my agent, without touching a laptop.

The agent did not just execute commands. It owned the workflow:

Repository creation — gh repo create, initialize, push to main
Content edits — semantic find-and-replace via the patch tool, not fragile line numbers
Commits — meaningful commit messages in French and English, contextual to the change
Deployment — push to main → GitHub Pages auto-deploys. Live in seconds.
Cross-repo work — jumping between atlasnexusops.github.io (portfolio) and hermes-bounty-watcher (tool project) without losing context

The agent maintained persistent memory of the repo structure, file paths, and even my stylistic preferences ("use purple gradients, not green"). It remembered that I prefer French commit messages for the portfolio and English for open-source repos. That is something no CLI can do.

A real session: from idea to live site in minutes

Me: Remplace bot par IA agentique professionnelle dans le portfolio

Hermes: [searches for bot across the repo, finds line 223 in index.html, patches the exact string, commits with "Remplace bot par IA agentique professionnelle", pushes to main]

Hermes: Fait. C est en ligne.

Zero copy-paste. Zero SSH. Zero context switching. The agent had persistent knowledge of the repo structure, found the exact string, applied a semantic patch (not fragile line numbers), committed with a meaningful bilingual message, and pushed to main. GitHub Pages deployed within seconds.

Later that same session:

Me: Maintenant on supprime les coordonnees du footer et tu peux mettre mon nom en footer Alexandre Lasly

Hermes: [navigates to footer section, removes contact links, adds name, commits, pushes]

Hermes: Fait.

The whole GitHub surface area

Over multiple sessions, the agent managed:

Action	Tool
Create repo + push	`terminal` (gh CLI)
Edit HTML/CSS	`patch` (semantic replace)
Write new files	`write_file`
Search codebase	`search_files` (ripgrep)
Read with context	`read_file` (paginated)
Git commit + push	`terminal` (git)
Schedule cron jobs	`cronjob`
Deliver updates	`send_message` (Telegram)
Remember preferences	`memory`

Every GitHub operation — from init to deploy — went through the agent. No laptop. No IDE. Just Telegram messages on a phone.

Cron: The Secret Weapon

Hermes Agent is cron system deserves special attention. You define a job once, and it runs on schedule — fully autonomous:

hermes cron add "every 6h" \
  --script ~/.hermes/scripts/superteam_bounties.sh \
  --no-agent \
  --deliver origin

The --no-agent flag means the script runs directly (zero LLM tokens) and its stdout is delivered verbatim. Silent when there is nothing to report.

Lessons Learned

Memory is underrated. Hermes Agent is persistent memory means it remembers your preferences, project structure, and past fixes.
Skills are living documentation. When you solve a complex workflow, save it as a skill.
No-agent crons are efficient. For repetitive data collection, skip the LLM entirely.
The phone is not a toy. An Android phone becomes a production-grade AI workstation.
Agents own workflows, not just commands. The difference between a CLI wrapper and an agent is memory, planning, and context retention across sessions.

Try It Yourself

pkg install python git -y
pip install hermes-agent
hermes setup

Connect a Telegram bot, schedule a cron, send a message — you will have an AI co-worker in your pocket within the hour.

Hermes Agent is open source. Runs anywhere you can install Python — including the phone in your hand right now.