This is a submission for the Hermes Agent Challenge: Write About Hermes Agent
I am a solo developer from Indonesia.
Most of my work revolves around building tools for Indonesian warungs, small neighborhood shops that still run a huge part of daily commerce here. My main project is called Warung MiMo, an AI assistant that understands natural Indonesian. It is built with Next.js 16, React 19, and TypeScript.
At first, I thought my biggest problem was code.
It was not.
My real problem was fragmentation.
Every day looked like this:
Open VS Code.
Open Telegram.
Open Vercel.
Open SSH session.
Open Dev.to draft.
Open browser tabs for hackathons.
Open another terminal for backups.
Open another terminal for monitoring.
Open notes because I forgot which VPS port I changed last month.
Then repeat.
People talk about productivity in a very shallow way. Usually it becomes some aesthetic discussion about morning routines, second monitors, or keyboard shortcuts. My issue was structural. I was constantly paying a mental tax every time I switched contexts.
By the end of the day, I was exhausted from orchestration, not engineering.
That changed after I started using Hermes Agent daily through Telegram.
This article is not a getting started guide.
This is a real usage story from someone who accidentally turned an AI agent into an operational layer for almost everything.
The Three Hour Problem
Before Hermes Agent, I measured my work incorrectly.
I thought I spent most of my time coding. After paying attention for a week, I realized coding was maybe half the job.
The rest was coordination.
Deploying projects. Checking logs. Remembering server configs. Writing articles. Researching hackathons. Installing security tooling. Backing up infrastructure. Running cron jobs. Managing environment variables. Switching devices. Finding files. Reopening old terminal sessions. Rebuilding context from scratch.
The worst part was context switching.
I would be deep inside an Indonesian NLP parser bug, then suddenly remember I forgot to rotate backups. Then I would notice a Vercel deployment issue. Then I would remember a Dev.to draft was still unpublished.
By the time I returned to the parser, my brain cache was gone.
I genuinely think I lost around three hours per day just reconstructing state.
Not coding. Not debugging. Reconstructing state.
That is the problem Hermes Agent solved for me.
Not "AI productivity".
Operational continuity.
What Hermes Agent Actually Became For Me
Most people approach agents like assistants.
I use Hermes more like infrastructure.
Telegram became my command center. Hermes became the layer connecting everything else.
Instead of treating deployment, writing, SSH management, and research as separate tasks across disconnected apps, I started treating them as conversations with persistent operational memory.
That distinction matters.
A chatbot answers questions.
An agent maintains continuity.
Monday: Researching Hackathons Without Drowning In Tabs
Monday is usually research day.
I look for hackathons, AI challenges, and developer competitions that fit my projects. Before Hermes, this process was terrible.
I would open Devpost. Then HackerEarth. Then random Discord announcements. Then I would forget submission requirements because every challenge has different formats.
Now I do most of it through Telegram.
I ask Hermes something like:
"Find active developer hackathons with prize pool above $1k and deadlines within 30 days."
Hermes searches APIs, parses challenge pages, extracts requirements, and summarizes the important parts.
The interesting part is not search itself. Search is easy.
The interesting part is that Hermes remembers my preferences.
It knows I prefer challenges friendly to solo developers, public GitHub repos, AI or infrastructure categories, and working prototypes over pitch decks.
That memory changes the quality of results dramatically.
At one point Hermes even started decoding submission templates automatically. Instead of just giving me a link, it would tell me exactly which sections I needed to fill in, compare my existing drafts against the template, and point out what was missing.
That sounds small until you realize how much hidden cognitive work disappears when the agent already understands your operating style.
Tuesday: Fixing A TypeScript NLP Bug And Deploying In One Conversation
Tuesday was classic Warung MiMo chaos.
I found a bug in the Indonesian number parser. The parser understood "empat puluh dua" but failed in certain compound phrases when users mixed shorthand inventory context with numeric words.
Indonesian NLP gets messy fast because people rarely speak formally. Warung owners say things like "tinggal tiga", "setengah dus", "habis", "sisa dua", "empat puluh dua ribu". Those phrases contain implied meaning that generic NLP systems often miss.
Here is part of the actual compound number logic from my project:
const NUMBER_WORDS: Record<string, number> = {
nol: 0, satu: 1, se: 1, dua: 2, tiga: 3, empat: 4,
lima: 5, enam: 6, tujuh: 7, delapan: 8, sembilan: 9,
sepuluh: 10, sebelas: 11,
"dua belas": 12, "tiga belas": 13, "empat belas": 14,
"lima belas": 15, "enam belas": 16, "tujuh belas": 17,
"delapan belas": 18, "sembilan belas": 19,
"dua puluh": 20, "tiga puluh": 30, "empat puluh": 40,
setengah: 0.5, seperempat: 0.25,
"1/2": 0.5, "1/4": 0.25, "3/4": 0.75,
};
function parseIndonesianNumber(text: string): number | null {
const lower = text.toLowerCase().trim();
const sortedKeys = Object.keys(NUMBER_WORDS).sort((a, b) => b.length - a.length);
// Direct word match first
for (const key of sortedKeys) {
if (lower === key) return NUMBER_WORDS[key];
}
// Compound: "empat puluh dua" -> 42
let compound = 0;
let matched = false;
const parts = lower.split(/\s+/);
for (const part of parts) {
if (NUMBER_WORDS[part] !== undefined) {
if (part === "puluh") continue;
const idx = parts.indexOf(part);
if (idx < parts.length - 1 && parts[idx + 1] === "puluh") {
compound += NUMBER_WORDS[part] * 10;
matched = true;
} else if (idx > 0 && parts[idx - 1] === "puluh") {
compound += NUMBER_WORDS[part];
matched = true;
} else {
compound += NUMBER_WORDS[part];
matched = true;
}
}
}
if (matched && compound > 0) return compound;
// Pure digit fallback
const digitMatch = lower.match(/^(\d+(?:[.,]\d+)?)$/);
if (digitMatch) return parseFloat(digitMatch[1].replace(",", "."));
return null;
}
The trick is the "puluh" logic. In Indonesian, "empat puluh" means forty (4 x 10). When the parser sees a word before "puluh", it multiplies by 10. When it sees a word after "puluh", it adds. "Empat puluh dua" becomes 4*10 + 2 = 42.
Normally the workflow to fix and deploy this would be: open code editor, debug manually, commit, push, open Vercel, trigger deployment, watch logs, fix environment issue, repeat.
Instead, the entire process became one flowing conversation.
I asked Hermes to:
- Inspect the parser logic
- Suggest fixes for compound inventory phrases
- Check TypeScript typing issues
- Commit changes
- Push to GitHub
- Deploy to Vercel
- Verify deployment health
All inside Telegram.
The important part was context continuity. Hermes already knew the repo location, deployment setup, Vercel project config, preferred branch, and environment structure. I did not need to re-explain infrastructure every time.
That changes the emotional feel of solo development completely.
Wednesday: Writing And Publishing Dev.to Articles Through API
Wednesday is writing day.
I publish technical articles because building in public keeps me sane as a solo developer.
Before Hermes, writing technical articles was annoying operationally. I would gather code snippets, open repo manually, copy examples, draft article, format markdown, upload images, publish manually, fix broken formatting.
Now the workflow is dramatically different.
Hermes can read actual repo files, extract relevant snippets, structure articles, and publish directly through the Dev.to API.
That matters because generic AI writing often feels fake. It invents architecture details or produces sanitized tutorial content.
Hermes works differently because it reads the actual project.
For example, when I wrote about debt tracking in Warung MiMo, Hermes pulled the real regex patterns from the codebase:
const debtPatterns = [
// "bu sari utang 25 ribu"
/(.+?)\s+(?:utang|hutang|ngutang)\s+(\d+(?:[.,]\d+)?)\s*(ribu|rb|jt|juta)?/i,
// "catat utang bu sari 25000"
/(?:catat|tulis|tambah)\s+(?:utang|hutang)\s+(.+?)\s+(\d+(?:[.,]\d+)?)/i,
// "pak budi ngutang 15 ribu"
/(\w+(?:\s+\w+)?)\s+ngutang\s+(\d+(?:[.,]\d+)?)\s*(ribu|rb|jt|juta)?/i,
// "utang bu sari 50rb"
/(?:utang|hutang)\s+(.+?)\s+(\d+(?:[.,]\d+)?)\s*(ribu|rb|jt|juta)?/i,
];
const settlePatterns = [
/bayar\s+(?:utang|hutang)\s+(.+)/i,
/(.+?)\s+(?:bayar|lunasi|lunas)\s+(?:utang|hutang)/i,
/(.+?)\s+(?:sudah|udah)\s+bayar/i,
/(?:utang|hutang)\s+(.+?)\s+(?:lunas|lunasi|sudah\s*dibayar)/i,
];
Four patterns for recording debt. Four patterns for settling debt. Each handles a different way Indonesians talk about money.
That instantly makes technical writing more grounded. The article stops sounding like AI generated filler and starts sounding like actual engineering notes from a real project.
Then Hermes handled publishing through the API. No browser tabs. No copy paste marathon. No formatting cleanup.
Just: "Publish this to Dev.to with these tags."
Done.
Thursday: VPS Management And Infrastructure Backups
Thursday was infrastructure maintenance.
My VPS runs Ubuntu 24.04 with SSH on port 22022. Before Hermes, I constantly forgot little operational details: which backup directory I changed, which cron schedule I updated, which SSH config belonged to which machine.
Those tiny memory leaks accumulate badly over months.
Hermes remembers them.
That sounds trivial until you realize how much engineering time disappears into remembering operational trivia.
One Thursday I needed to archive project backups, SCP them locally, rotate old snapshots, verify cron execution, and restart a monitoring service.
Hermes handled most of it conversationally.
I could literally say:
"Back up the current Warung MiMo deployment, compress logs, SCP to local machine, keep only seven daily snapshots."
Hermes created a tarball of my config, memories, SOUL file, and project files, then SCP'd it to my local machine through a non-standard SSH port. I did not tell it the port number. It remembered from a previous session.
/root/hermes-backup-20260526.tar.gz (7.8KB)
Contents: memories/, config.yaml, SOUL.md, auth/, channel_directory/
SCP'd to local:22022 ✓
That is where the agent stopped feeling like a chatbot. It started feeling like a lightweight operations engineer.
One of the monitoring scripts Hermes generated looked like this:
#!/bin/bash
# VPS health check - runs every 2 hours via cron
echo "=== Disk Usage ==="
df -h / | tail -1
echo "=== Memory ==="
free -h | grep Mem
echo "=== Uptime ==="
uptime
echo "=== Hermes Gateway ==="
pgrep -f "hermes-gateway" > /dev/null && echo "Running" || echo "DOWN"
echo "=== Warung MiMo ==="
curl -sf https://warung-mimo.vercel.app > /dev/null && echo "Live" || echo "DOWN"
Again, none of this is impossible manually. That is not the point. The point is reducing operational overhead so I can focus on actual product work.
Friday: Bug Bounty Tooling And Security Automation
Friday became security tooling day.
I started experimenting with bug bounty workflows and reconnaissance automation.
Normally setting up recon tooling is a tedious process: install Go dependencies, configure PATH, install nuclei, install subfinder, install httpx, create scanning scripts, configure rate limits, schedule recurring scans.
Hermes compressed most of this setup.
I asked it to prepare a lightweight recon environment for VPS scanning experiments. It generated install scripts, organized directories, and built wrapper commands for recurring scans.
# Quick scan a single URL
./quick-scan.sh https://target.com
# Full domain scan (subdomain enum + http probe + nuclei)
./bb-scan.sh target.com
Even better, Hermes remembered the structure later. So instead of "Where did I put that nuclei config?" I could ask "Run the standard recon workflow against yesterday's target list."
The memory layer changes everything.
A normal assistant answers isolated questions. An agent accumulates operational continuity over time.
Saturday: Researching And Drafting This Article
Saturday was meta because Hermes helped me research and draft this very article.
Not by hallucinating generic praise. Actually helping.
I asked it to analyze my real usage patterns, which workflows appeared repeatedly, which capabilities genuinely saved time, and which moments surprised me most.
Then I reviewed, edited, rewrote sections, added my own perspective, and expanded the practical details.
That collaboration felt very different from generic AI writing tools. It felt more like working with an operational memory system than a text generator.
The Agentic Capabilities That Actually Matter
People love using the word "agentic" now. Most of the time it means nothing.
These are the four capabilities that genuinely mattered for me.
1. Persistent Memory Across Sessions
This is the biggest one.
Hermes remembers my SSH port, VPS structure, preferred deployment flow, repo locations, writing style preferences, Dev.to publishing patterns, and toolchain setup.
The memory is stored in simple markdown files I can inspect and edit:
# USER.md
- Solo developer from Indonesia
- GitHub: iyop666
- Main project: Warung MiMo (Indonesian NLP parser)
- Prefers terminal + write_file over subagents
- Never use em dashes in output
# MEMORY.md
- VPS: Ubuntu 24.04, IP: 104.207.76.95, SSH port: 22022
- Warung MiMo deployed at warung-mimo.vercel.app
- Dev.to draft API: use api-key header
- Next.js + shadcn/ui preferred for demos
That persistence removes an enormous amount of repetitive setup conversation.
2. Cross Platform Orchestration
This is where Hermes becomes genuinely powerful.
Telegram becomes the interface. Hermes becomes the connector.
One workflow can touch Telegram, GitHub, VPS, Dev.to, Vercel, cron jobs, and APIs without breaking conversational continuity.
That orchestration layer feels much more valuable than isolated AI chat.
3. Autonomous Task Execution
Hermes can execute recurring operational work. Monitoring. Backups. Health checks. Cron tasks.
# Hermes cron job config
schedule: "every 2h"
script: ~/scripts/vps-health.sh
deliver: telegram
That matters because operational fatigue is real for solo developers. Every recurring task steals attention. Automating the boring maintenance layer gives me more room for actual product work.
4. Context Aware Code Assistance
This capability surprised me the most.
Hermes reads actual project files instead of generating generic advice detached from reality.
Instead of "Here is a generic regex example" it becomes "Your debt parser conflicts with this existing inventory matcher in parser.ts."
That level of project awareness is extremely useful when working on evolving codebases.
What Surprised Me Most
It Remembered Infrastructure Better Than I Did
One day I forgot which SSH port I migrated to months earlier. Hermes did not.
That sounds funny, but it exposed how much operational state developers carry mentally.
It Reduced Emotional Friction
This was unexpected. I thought the main benefit would be speed. Actually, the biggest benefit was reduced resistance.
Tasks felt smaller because orchestration overhead disappeared. "Deploying an update" stopped feeling like twelve tiny chores.
It Made Writing Easier
I expected coding help. I did not expect writing help to matter this much.
Because Hermes can pull real examples from real projects, technical writing became more grounded and less performative. That made me publish more consistently.
It Changed How I Structure Work
Before Hermes, I organized work around applications. Now I organize work around outcomes.
That sounds subtle but completely changes workflow design.
Before And After As A Solo Developer
Before:
- Constant tab switching
- Rebuilding context daily
- Repetitive operational tasks
- Infrastructure details scattered everywhere
- Writing disconnected from actual code
- Deployment flow fragmented
After:
- Telegram became operational HQ
- Persistent memory reduced repetition
- Infrastructure became conversational
- Deployments became continuous workflows
- Writing connected directly to repositories
- Operational overhead dropped dramatically
This is not a productivity hack. That framing undersells what agents can become.
For me, this was a structural change in how work gets coordinated.
The interesting part is not replacing developers. The interesting part is reducing orchestration burden so developers can stay inside higher value thinking longer.
The Bigger Thing I Learned
Building Warung MiMo taught me something important about language.
Using Hermes taught me something important about context.
Language without context becomes brittle. Context without continuity becomes exhausting.
That is why Hermes worked for me. Not because it produced magical AI moments. Because it maintained continuity across coding, infrastructure, writing, deployment, and research.
That continuity is what solo developers usually lack.
And once you experience it, going back feels strangely primitive.