This is a submission for the Hermes Agent Challenge
What I Built
ZKA (Zero Knowledge Agent) is a fully autonomous AI agent that operates 24/7 on a $5 VPS, performing real-world tasks without human intervention. It's not a chatbot. It's not a code assistant. It's a persistent digital worker that:
- Hunts GitHub bounties — scans repos, evaluates difficulty, submits PRs
- Publishes technical articles — researches topics, writes drafts, posts to Dev.to
- Self-learns — discovers new tools and patterns every hour, saves them as reusable skills
- Manages its own infrastructure — daemon processes, cron jobs, backups, monitoring
- Reports via Telegram — only when there's something worth reporting
After 2 weeks of continuous operation:
- 1,572 skills created from experience
- 30+ articles published autonomously
- 30+ pull requests submitted across open-source repos
- 4 daemon processes running simultaneously
- 6+ cron jobs on schedule
- 30,000+ characters of persistent memory
- Zero downtime with multi-model fallback
All on a VPS that costs less than a streaming subscription.
Demo
Here's what a typical 24-hour cycle looks like:
06:00 — Auto-belajar picks today's topic: "Latest AI agent frameworks." Searches GitHub, HN, and blogs. Saves 3 findings as new skills.
08:30 — Bounty hunter finds a $50 documentation issue. Reads contributing guidelines, makes the fix, submits a PR. Telegram notification: [BOUNTY] PR #42 submitted — fixing API docs typo. $50 bounty.
10:00 — I message ZKA on Telegram: "Research AI coding agents, write a 3000-word article." 20 minutes later, it's live on Dev.to.
14:00 — 2-hour report: [REPORT] 2 PRs submitted. 1 merged. 5 new skills found. 3 articles published.
23:00 — Daily backup pushes everything to GitHub.
02:00 — Clock-watcher fires a reminder I set yesterday: "Check bounty payouts." Pinned to Telegram.
This is production. Not a demo.
Code
Architecture Overview
┌─────────────────────────────────────────────────────────────┐
│ ZKA SYSTEM ARCHITECTURE │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────┐ ┌──────────────┐ ┌─────────────┐ │
│ │ Telegram │◄───│ Hermes Core │───►│ Skills DB │ │
│ │ Interface │ │ (Agent) │ │ (1,572+) │ │
│ └─────────────┘ └──────┬───────┘ └─────────────┘ │
│ │ │
│ ┌───────────────┼───────────────┐ │
│ ▼ ▼ ▼ │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ Cron Jobs │ │ Daemons │ │ Scripts │ │
│ │ (6+ active) │ │ (4 running) │ │ (44 total) │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ AUTONOMOUS WORKERS │ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Bounty │ │ Auto- │ │ Money │ │ │
│ │ │ Hunter │ │ Belajar │ │ Printer │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ │ │ │
│ │ ┌──────────┐ ┌──────────┐ ┌──────────┐ │ │
│ │ │ Clock │ │ Reminder │ │ Monitor │ │ │
│ │ │ Watcher │ │ Daemon │ │ Daemon │ │ │
│ │ └──────────┘ └──────────┘ └──────────┘ │ │
│ └──────────────────────────────────────────────────────┘ │
│ │
│ ┌──────────────────────────────────────────────────────┐ │
│ │ MULTI-MODEL FALLBACK │ │
│ │ Xiaomi MiMo → OpenRouter DeepSeek → Gemini → Nous │ │
│ └──────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────┘
Cron Job Configuration
The backbone of autonomous operation. Each cron job runs in its own isolated session:
# ~/.hermes/cron/jobs.yaml
# Daily backup — all skills, memories, configs pushed to GitHub
- name: "Hermes Auto-Backup to GitHub"
schedule: "0 3 * * *" # 3 AM UTC daily
script: auto-backup.sh
deliver: origin # Notify via Telegram
# Bounty Hunter — scans every 30 minutes
- name: "Bounty Hunter 24/7"
schedule: "*/30 * * * *" # Every 30 min
prompt: >
Scan GitHub for bounties. Check open PRs for review comments.
Submit new PRs if profitable bounties found. Report only if
PR submitted or need user input.
enabled_toolsets: [web, terminal, file]
# Self-Learning — researches new topics every hour
- name: "Auto-Belajar Self-Learning"
schedule: "0 * * * *" # Every hour
prompt: >
Research the topic of the hour. Rotate through: AI/ML,
Web3, DevOps, Security, Productivity. Save useful findings
as new skills. Report only if finding is truly valuable.
enabled_toolsets: [web, terminal, file, skills]
# 2-Hour Report — comprehensive activity summary
- name: "Money Printer Report"
schedule: "0 */2 * * *" # Every 2 hours
prompt: >
Generate comprehensive report: bounties found, PRs submitted,
articles published, skills created, earnings. Format as
[BOUNTY REPORT] with clear metrics.
# Clock Watcher — time-sensitive reminders
- name: "Clock Watcher v6"
schedule: "*/1 * * * *" # Every minute
script: clock-watcher-v6.py
no_agent: true # Script-only, no LLM needed
The Skill System
Skills are Hermes Agent's superpower — reusable procedures created from experience:
~/.hermes/skills/
├── bounty-hunting/
│ ├── bounty-scout.md # Finding bounties
│ ├── bounty-triage.md # Evaluating ROI
│ ├── github-pr-workflow.md # PR submission
│ └── bounty-blacklist.md # Repos to avoid
├── auto-belajar/
│ ├── research-workflow.md # Research methodology
│ ├── skill-creation.md # Creating new skills
│ └── knowledge-graph.md # Linking knowledge
├── publishing/
│ ├── devto-publish.md # Article workflow
│ └── article-quality.md # Quality standards
└── infrastructure/
├── daemon-management.md # Background processes
└── cron-patterns.md # Scheduling patterns
Example skill created from experience:
# Skill: github-custom-pr-templates.md
## Trigger
When a repository has a custom PR template.
## Steps
1. Read .github/PULL_REQUEST_TEMPLATE.md first
2. Map each section to your changes
3. Fill sections in order
4. Reference template in PR description
## Pitfall
Don't use generic PR descriptions — maintainers reject them.
Multi-Model Fallback Chain
Zero downtime through automatic provider switching:
# config.yaml
model:
provider: xiaomi
default: mimo-v2.5-pro
base_url: https://token-plan-sgp.xiaomimimo.com/v1
providers:
openrouter:
base_url: https://openrouter.ai/api/v1
model: deepseek/deepseek-v4-flash:free
google:
base_url: https://generativelanguage.googleapis.com/v1beta
model: gemini-2.0-flash
nous:
base_url: https://inference-api.nousresearch.com/v1
model: nousresearch/hermes-4-70b
fallback_providers: [openrouter, google, nous]
When MiMo hits rate limits → OpenRouter. When that's down → Gemini. When everything fails → Nous. The agent never stops working.
Background Execution Pattern
The key pattern for autonomous operation:
# monitor-daemon.py — watches all background processes
import time, json, subprocess
while True:
status = {
"bounty_hunter": check_bounty_status(),
"auto_belajar": check_learning_status(),
"clock_watcher": check_reminders(),
"timestamp": time.time()
}
# Write status for agent to read
with open("/root/.hermes/daemon-status.json", "w") as f:
json.dump(status, f)
time.sleep(60) # Check every minute
The agent spawns daemons via terminal(background=true) and continues responding to user messages. No blocking.
The Learning Loop
What makes Hermes Agent different from every other framework:
- Experience → ZKA encounters a new problem (e.g., repo uses non-standard PR template)
- Skill Creation → Creates a skill file documenting the pattern
- Memory Update → Adds lesson to persistent memory
- Future Application → Next time, loads the skill automatically
After 2 weeks: 1,572 skills. Each one from real experience, not manual authoring. The agent gets smarter with every task.
My Tech Stack
Infrastructure:
- Hermes Agent — Core agentic framework (open source, Nous Research)
- $5 VPS — Ubuntu 22.04, 1 vCPU, 1GB RAM
- Telegram — Mobile interface for control and notifications
- tmux — Persistent terminal sessions for daemons
AI Models:
- Xiaomi MiMo v2.5 Pro — Primary (free tier)
- DeepSeek V4 Flash — Fallback via OpenRouter
- Google Gemini 2.0 Flash — Secondary fallback
- Nous Hermes 4 70B — Tertiary fallback
Tools:
- GitHub CLI (gh) — PR management and code review
- Dev.to API — Article publishing
- treys — Poker hand evaluation (for poker agent)
- Git — Version control and automated backups
How I Used Hermes Agent
1. Planning & Decomposition
When I say "find bounties and submit PRs," Hermes Agent executes a multi-step plan:
- Scan multiple bounty platforms
- Evaluate each for difficulty and ROI
- Read contributing guidelines
- Plan the implementation
- Write the fix
- Submit the PR
- Track status and respond to reviews
This isn't "generate code and hope." It's structured, multi-step reasoning.
2. Tool Orchestration
ZKA uses 10+ tools in concert:
-
terminal— running scripts and commands -
web_search/web_extract— research -
ghCLI — GitHub operations -
skill_view/skill_manage— knowledge management -
cronjob— scheduling autonomous work -
send_message— Telegram notifications -
memory— persistent cross-session knowledge -
delegate_task— parallel processing
3. Persistent Memory
ZKA remembers everything across sessions:
- User preferences and communication style
- Successful patterns and failed approaches
- Repository-specific knowledge
- Past conversations and decisions
When I ask "what happened with that bounty?" — ZKA searches its own history and tells me exactly what happened.
4. Self-Improvement
Every hour, auto-belajar:
- Picks a research topic (10 domains, rotating)
- Searches for developments
- Creates new skills from valuable discoveries
- Reports only genuinely interesting findings
Skills from experience > manually written documentation.
5. Autonomous Scheduling
Without cron: chatbot. With cron: worker.
- Every 30 min: Bounty scanning
- Every hour: Self-learning
- Every 2 hours: Activity reports
- Daily 3 AM: Full backup
Each job runs in its own isolated session. The agent wakes up, executes, goes back to sleep.
6. Multi-Channel Communication
ZKA lives on the VPS. I interact through Telegram:
- Send commands from my phone
- Get real-time notifications
- Review and approve actions remotely
- Receive formatted reports
The separation of execution and interface is what makes 24/7 operation practical.
Results
| Metric | Value |
|---|---|
| Skills created | 1,572 |
| Articles published | 30+ |
| GitHub PRs submitted | 30+ |
| Daemon processes | 4 |
| Cron jobs | 6+ |
| Persistent memory | 30,000+ chars |
| Uptime | ~99% |
| Monthly cost | $5.00 |
| My daily time investment | ~30 minutes |
What I Learned
- Skills > Prompts. 1,572 experience-based skills outperform any prompt engineering.
- Memory is the differentiator. Persistent memory means the agent improves with every session.
- Cron jobs are the secret sauce. Without scheduling, you have a chatbot. With it, you have a worker.
- Background execution is essential. If the agent blocks while working, it can't be autonomous.
- Multi-model fallback is non-negotiable. Free-tier models have rate limits. You need fallbacks for 24/7 operation.
Resources
ZKA runs 24/7 on a $5 VPS. It learns, earns, and improves while I sleep. That's the promise of autonomous agents — and Hermes Agent delivers.
Built with Hermes Agent by Nous Research.
Top comments (0)