DEV Community: saheelwagh

Meet your fitness coach that lives on Hermes

saheelwagh — Mon, 01 Jun 2026 06:37:51 +0000

This is a submission for the Hermes Agent Challenge: Build With Hermes Agent

What I Built

A small backstory on my coding origins

I learnt coding by secretly studying from a python book pdf on my Computer Scientist father's work laptop. That very day I wrote a program that inputs a user's name and prints: "You are mad {name}!" and had a lot of fun pranking my brother using that script.

Since then, there have been very few moments where coding felt as magical, because the more you understand syntax, the more you understand the magic underneath your code.

That is, until you meet a genius piece of magic such as Hermes.

My app idea

I built a Fitness coach inside Hermes that learns and adapts based on your daily feedback. According to your goals, performance, and time allocated, it adjusts your current plan. For the purpose of this hackathon I tested it via terminal ui (tui) but I plan to release the polished version on chat apps such as telgram and whatsapp for painless daily checkins.

Demo

Code

Github link

My Tech Stack

Hermes + node.js. Kept it simple for this quick dive.

How I Used Hermes Agent

Building an AI application that feels truly personal requires more than just a clever prompt; it requires state, memory, and the ability to adapt over time. During a recent hackathon, I set out to build an autonomous AI fitness coach. Not just a chatbot that spits out generic workout templates, but a system that onboards a user, sets a multi-month timeline, generates habit blocks, and adjusts daily based on feedback.

To achieve this, I used Hermes, an agentic framework designed for stateful, long-running applications. Here is a breakdown of how I built it, the challenges faced, and why Hermes was the perfect tool for the job.

Why This App is a Perfect Fit for Hermes

Most LLM interactions are stateless. You ask a question, you get an answer, and the session ends. A fitness journey, however, is a deeply stateful process. It spans weeks or months and requires constant recalibration.

Hermes excels here because of its Skill Architecture. In Hermes, "skills" act as the agent's internal database and long-term memory. Instead of relying on the LLM to hopefully remember the user's goals across a 64k context window, I structured the coach's memory into strict JSON schemas:

user_fitness_profile: The foundational constraints (goals, phase, available days).
master_timeline_skill: The 3 to 6-month master arc.
habit_block_skill: 21-day executable units.
weekly_workout_plan: The actual scheduled days.

When a user logs a /checkin saying a session was "Too easy", the Hermes Evaluation Agent reads these skills, decides on an adjustment, and surgically rewrites the weekly_workout_plan for the next day. Hermes handles the file I/O and state persistence autonomously, allowing the LLM to act as a true reasoning engine.

Experiences & Lessons Learned

1. Strongly Typed State is Non-Negotiable

Early on, I realized that if the LLM hallucinates the structure of the fitness plan, the entire application loop breaks. I created a skills.ts file with strict TypeScript interfaces for every step of the journey. By enforcing these schemas in the system prompts, Hermes consistently generated valid, parsable JSON that cleanly mapped to my application's logic.

2. The Rate Limit Reality: Batching vs. Conversational

Initially, I designed the onboarding flow to be highly conversational, asking the user 8 questions one by one. I quickly hit the Gemini API Free Tier rate limits (Resource Exhausted: 429). Hermes is an agentic framework, meaning it often makes multiple API calls (thoughts, tool usage, generation) per user interaction.

The Fix: I pivoted the architecture to a batched approach. I combined the questionnaire into a single, multi-part prompt. The user selects their timeline and phase in one go. This drastically reduced API calls, saved tokens, and bypassed the rate limits entirely without sacrificing the personalized feel.

3. Hardcoding the "Rules of the Game"

LLMs are great at reasoning, but terrible at strict constraints. Instead of asking the LLM to invent a workout split, I hardcoded the domain logic into the prompt:

Lean Bulk -> 4-day Upper/Lower or 4-day Full Body
Aggressive Bulk -> 6-day Arnold
Recomposition -> 3-day Full Body

Hermes reads the user's state, applies these hard rules, and maps the days accordingly. This prevents bad prescriptions (like recommending a 6-day split to someone on an aggressive cut, which would lead to under-recovery).

Extending the Coach using Hermes

The current iteration is a solid Sprint 1, but the Hermes framework makes extending this app incredibly straightforward:

1. From Terminal to Telegram (and beyond)

Hermes has built-in gateway support. Transitioning this coach from my local terminal to a public Telegram bot doesn't require rewriting the core logic. By simply providing a Bot Token and starting the hermes gateway, the exact same stateful agent can interact with users via their phones. We can even use cron jobs to trigger automated /checkin prompts at 8 PM every night. If this idea picks up I want to deploy it as a paid app on whatsapp and telegram

2. Contextual Awareness via MCP (Model Context Protocol)

Life happens. People get injured or go on work trips. By utilizing Hermes's MCP support, the coach could integrate with a user's Google Calendar. If it sees a "Conference in Vegas" next week, the external_event_handler skill can preemptively adjust the master_timeline_skill, shifting heavy workout days around the travel schedule.

3. Adding Knowledge with RAG

Currently, to save context, the weekly plan only schedules the types of days (e.g., "Upper 1"). By hooking up a local vector database via Hermes tools, the coach could query a library of exercises, form videos, and rep ranges, injecting specific, customized workouts into the daily sessions just-in-time.

Conclusion

Building a fitness coach with Hermes proved that agentic frameworks are the key to moving beyond simple chatbots. By combining strict state management (Skills), hardcoded domain rules, and LLM reasoning, you can build applications that truly learn, adapt, and guide users over the long term.
Honestly, the only major limitation on such an app when using Hermes is the LLM tokens that you can spend. Outside of which Hermes in itself is a perfect fit for such feedback loops within the app. I look forward to exploring this library in depth and enjoy this feeling of creating what feels like magic using Agentic ai.

Hermes Agent: Your Digital Sous-Chef

saheelwagh — Mon, 01 Jun 2026 06:23:10 +0000

This is a submission for the Hermes Agent Challenge

The chef who can't find his knives

Imagine hiring a Michelin-star chef for your restaurant, only to discover their spatial memory resets every time they take off their apron.
Every single morning, they walk in with world-class culinary skills, but you still have to spend the first hour showing them where you keep the spatulas, reminding them the menu is vegan, and explicitly telling them to avoid the broken fryer. They cook a flawless dinner, clock out, and the next day, you have to start the kitchen tour all over again.

That is what it feels like to chat with a state-of-the-art LLM.

It is brilliant, capable, and lightning-fast, but before you can get any actual work done, you have to:

paste in your project structure,
remind it that you prefer functional components, and
explicitly ban it from using a deprecated library.

It does the work perfectly. Then you close the window, and all that context is instantly wiped away.

Using raw models means managing a brilliant worker who requires a massive onboarding manual every single morning. But as we move toward autonomous agent frameworks like Hermes Agent (by Nous Research), the paradigm is shifting. We are moving away from repetitive chat interfaces and toward a persistent operational environment—a kitchen that actually remembers how you like to cook.
The Brilliant Sous-Chef.

Imagine you run a high-end, fast-paced restaurant, and you just hired a new sous-chef.

On day one, they don't just start blindly chopping vegetables. First, they pin a couple of sticky notes above their prep station: "Chef prefers ingredients organized left-to-right,"
and
"Never use cilantro in the house salsa."
You never have to tell them these basic rules again.

During the dinner rush, you hand them a chaotic task:
figure out how to prep and bake a highly complex, seven-step pastry they’ve never seen before.
They struggle a bit. They test a few oven temperatures, mess up a batch, but eventually, they nail it perfectly.

Here is where the magic happens.

After the shift, the sous-chef doesn't just go home.

They stay late, pull out the kitchen’s master recipe binder, and write a brand-new, highly detailed recipe card. They note the exact temperature, the sequence of folds, and add a warning: "Do not skip the 10-minute chilling phase, or the butter will leak."

The next time you ask for that pastry, they don't experiment. They don't ask questions. They pull their own recipe card, execute it flawlessly on the first try, and delegate the basic prep work to the junior line cooks so the dish gets done twice as fast.

Translating the Kitchen to the Codebase:

Hermes operates exactly like this sous-chef. It uses a highly specific local file architecture to transition from a generic AI into a customized operational partner.

Here is how the kitchen maps to the framework:

1. The Sticky Notes (USER.md & MEMORY.md)

This is Hermes’ passive context layer. Stored locally in your ~/.hermes/ directory, these files act as the sticky notes on the fridge. USER.md holds your identity and preferences, while MEMORY.md holds facts about your environment and ongoing projects. Hermes automatically injects these notes into its system prompt at the start of every session, meaning it remembers your database schema and coding style forever.

2. The Living Recipe Binder (The SKILL.md Loop)

This is Hermes' defining feature: a closed-loop learning system. When Hermes solves a complex problem—like untangling a messy Docker deployment through trial and error—it reflects on its own success. It automatically authors a SKILL.md file detailing the exact steps, the shell commands used, and the pitfalls it avoided. The next time you give it a similar task, it bypasses the reasoning phase entirely, loads the custom playbook, and executes the proven procedure.

3. The Junior Line Cooks (Subagents)

When you hand Hermes a massive task, it doesn't try to do it all in one frying pan. It spins up focused subagents. It can delegate a web search to one subagent to read documentation, while another writes a unit test, merging their work together for the final output while staying under its strict 90-turn execution cap.

Beyond Chat: The Mechanics of an Autonomous Kitchen.

To understand why Hermes is so much more than a chatbot, we have to look at the three mechanics that let it actually run the kitchen:

1.Tool Use (The Chef's Hands):

A standard LLM is like a brilliantly written cookbook. If you ask it how to make a sauce, it gives you the recipe, but you have to whisk the eggs. Hermes has hands. When you ask it to check a server, it physically reaches into the environment, runs the curl command in your terminal, reads the JSON response, and reports back.

2.Planning (Mise en place):

If a customer orders Beef Wellington, a chaotic cook throws raw beef and flour into a pan and hopes for the best. Hermes uses mise en place. Before it touches a single file, it stands at the prep station and writes a chronological dependency list. It knows it cannot write the import statement before installing the library.

3.Multi-Step Reasoning (Taste and Adjust):

A rigid machine follows a recipe blindly. If the broth is already too salty, it adds more salt anyway. Hermes operates on an active feedback loop—it tastes the sauce. If it runs a script in the sandbox and hits a nasty syntax error, it doesn't freeze. It reads the error log, realizes the environment is missing a dependency, dynamically adjusts the plan to run npm install, and tests again.

The longer Hermes stays in your "kitchen," the thicker its recipe binder gets. By giving the agent a durable memory and the ability to write its own tools, Hermes stops being a generic chatbot and becomes a compounding asset that actually gets smarter the longer you work together.

From Chatbots to Digital Chiefs of Staff: The 4 Stages of Agentic AI Evolution

saheelwagh — Mon, 01 Jun 2026 05:56:48 +0000

This is a submission for the Hermes Agent Challenge

Issues with Agentic development over the years

We have incredibly powerful foundational models, but we spend an absurd amount of time wrangling them—re-pasting context, writing brittle orchestration scripts, and dealing with agents that suffer from total amnesia the moment we close the terminal.

The release of Hermes Agent (by Nous Research) marks a distinct shift in how we interact with intelligence. We are moving away from AI as a tool you query and toward AI as an environment you cultivate.

To understand why a self-improving framework like Hermes is such a massive deal, we have to look at the evolutionary steps that got us here.

The 4 Stages of AI Evolution

Stage 1: The Stateless Chatbot (The Amnesia Era)

Examples: Early ChatGPT, Claude Web UI
Input: Prompt
The Paradigm: Content (text, code)
The Bottleneck: Total amnesia. Every time you open a new session, you pay an "amnesia tax." You have to re-explain who you are, what your project is, and what rules it needs to follow. It’s like hiring a genius consultant who hits their head and forgets you exist every time they leave the room.

Stage 2: The Context-Aware Copilot (The Reactive Era)

Examples: GitHub Copilot, Cursor, Codeium
Input: Prompt + Context
Output: Content (Text, code etc)
The Paradigm: The AI now lives inside your workspace. It can read your current file, understand your directory structure, and predict your next line of code.
The Bottleneck: It is completely reactive. A copilot doesn’t do anything until you press a button or start typing. It has deep context, but zero autonomy. It is a passenger, not a driver.

Stage 3: The Orchestration Graph (The Hardcoded Era)

Examples: LangChain, CrewAI, AutoGen
The Paradigm: Developers realized they needed AI to execute multi-step processes autonomously. We started building agentic frameworks where you define specific "personas" and wire them together in a graph (e.g., Agent A searches the web -> Agent B writes the code -> Agent C runs the test).
The Bottleneck: The agent's capability is strictly bounded by what you hardcoded. It is a rigid assembly line. Furthermore, when the script finishes, the memory resets. It doesn't learn from its mistakes; if it fails at a task on Monday, it will fail the exact same way on Tuesday unless you rewrite the Python script.

Stage 4: The Self-Improving Daemon (The Hermes Era)

Examples: Hermes Agent
The Paradigm: The AI operates as a continuous, long-running daemon on your local machine or server. It has persistent memory, native access to your file system and terminal, and crucially, a closed-loop learning system. It doesn't just execute tasks; it evaluates its own successes and writes its own playbooks.

What Hermes Agent Actually Changes

Hermes Agent flips the foundational assumption of agent development. Instead of building a complex graph of logic that the agent blindly follows, you give the agent a workspace and let it build its own logic.

Here is what Hermes provides that shatters the limitations of previous tools:

1. Procedural Memory (The `SKILL.md` Loop)

This is the killer feature. If you ask a Stage 3 agent to fix a complex Docker deployment, it will use its reasoning, hit some errors, adjust, and eventually fix it. But when you ask it again tomorrow, it starts from scratch.

When Hermes Agent solves a novel, complex problem, it reflects on its own trajectory. It extracts the successful pattern and writes a YAML-frontmattered SKILL.md file saved to your local directory. The next time you give it that task, it bypasses the reasoning phase entirely, pulls up its custom playbook, and executes perfectly. It is an AI that writes its own tools.

2. Persistent State (`MEMORY.md` & `USER.md`)

Hermes defeats the "amnesia tax." It uses a bounded, agent-curated memory system. As you work with it, it passively writes facts about your workflow to a local USER.md profile and project details to MEMORY.md. These files are automatically injected into the system prompt at the start of every new session. If you tell it once, "I prefer functional components over classes," it remembers forever.

3. Untethered Autonomy (Crons & Gateways)

Copilots are tethered to your IDE. Chatbots are tethered to a browser tab. Hermes is a daemon. Because it supports native messaging gateways and a natural language cron scheduler, you can text Hermes on Telegram while you are at a coffee shop: "Review the PRs on my main repo, and if the tests pass, merge them." You can tell it: "Run a web scrape of HackerNews every morning at 7 AM and Discord message me the top AI trends." It executes proactively, in the background, without you ever opening a terminal.

The Takeaway

The era of starting from scratch every time you prompt an LLM is ending.

Frameworks like Hermes represent a shift from using an AI to employing an agent. You are no longer interacting with a static set of weights; you are cultivating a digital Chief of Staff whose playbook gets thicker, faster, and more personalized the longer you leave it running.

Worklog companion with Gemma4

saheelwagh — Mon, 25 May 2026 06:55:22 +0000

This is a submission for the Gemma 4 Challenge: Build with Gemma 4

What I Built

I built a cli based distraction log that tracks your workday and with the help of gemma suggests breaks and productivity tips/

Demo

Code

Github:

saheelwagh / gemmacli

How I Used Gemma 4

The app lets you log your distractions as you work. It uses a simple terminal based ui that stays out of your way.
At the end of your work session, it combines your notes with a custom algorithm and prompts Gemma to suggest if you should work or take a break. At the end of the day, it lets you review your work and get improvement tips from gemma.

Gemma is used in this project instead of other AI services because :

Work details might be private or confidential that can't leave local machine.
Distraction notes can contain sensitive personal feelings
Local deployment of gemma allows the app to run offline and distraction free.

Bottled water or your own well? a new choice unlocked by Gemma

saheelwagh — Mon, 25 May 2026 06:42:12 +0000

This is a submission for the Gemma 4 Challenge: Write About Gemma 4

Our society developed around water. Rivers were the cradles for every ancient civilisation. Almost every major city in historical or current existence is in proximity to a river system. However, our current water supply is centralised and metered. It comes through a network of dams and pipelines. While we get water that is treated and fit for human consumption, we have to pay for every drop. Sometimes we do not need all that extra treatment, like for washing cars. It could be more efficient to have your own water hole.

Now imagine a society that never knew free water. Its first introduction was through pipes controlled by corporations. This is how the majority of people first encooutnered ai in thwith the relase of GPT. For Foor them all encounters with ai have been through metered usage.

The release of Gemma 4 unlocks the digging of local borewells in a way. It allows anyone to use litres of water at their own discretion. For some specialised use cases, the water will still need paid metered usage and complex treatment. The way drinking water needs strict chemical treatment, some ai use cases need specialised hardware facilities or complex algorithms only available in bigger models available commercially. But this new solution provides an effective way to cut not only the cost per user but also the load on global systems when it comes to operations that can be done with such a local pool of water (knowledge). Thus Gemma 4 is the next unlock in consumer and enterprise ai usage.

DEV Community: saheelwagh

Meet your fitness coach that lives on Hermes

What I Built

A small backstory on my coding origins

My app idea

Demo

Code

My Tech Stack

How I Used Hermes Agent

Why This App is a Perfect Fit for Hermes

Experiences & Lessons Learned

1. Strongly Typed State is Non-Negotiable

2. The Rate Limit Reality: Batching vs. Conversational

3. Hardcoding the "Rules of the Game"

Extending the Coach using Hermes

1. From Terminal to Telegram (and beyond)

2. Contextual Awareness via MCP (Model Context Protocol)

3. Adding Knowledge with RAG

Conclusion

Hermes Agent: Your Digital Sous-Chef

The chef who can't find his knives

That is what it feels like to chat with a state-of-the-art LLM.

Imagine you run a high-end, fast-paced restaurant, and you just hired a new sous-chef.

After the shift, the sous-chef doesn't just go home.

Translating the Kitchen to the Codebase:

Here is how the kitchen maps to the framework:

1. The Sticky Notes (USER.md & MEMORY.md)

2. The Living Recipe Binder (The SKILL.md Loop)

3. The Junior Line Cooks (Subagents)

Beyond Chat: The Mechanics of an Autonomous Kitchen.

1.Tool Use (The Chef's Hands):

2.Planning (Mise en place):

3.Multi-Step Reasoning (Taste and Adjust):

From Chatbots to Digital Chiefs of Staff: The 4 Stages of Agentic AI Evolution

Issues with Agentic development over the years

The 4 Stages of AI Evolution

Stage 1: The Stateless Chatbot (The Amnesia Era)

Stage 2: The Context-Aware Copilot (The Reactive Era)

Stage 3: The Orchestration Graph (The Hardcoded Era)

Stage 4: The Self-Improving Daemon (The Hermes Era)

What Hermes Agent Actually Changes

1. Procedural Memory (The SKILL.md Loop)

2. Persistent State (MEMORY.md & USER.md)

3. Untethered Autonomy (Crons & Gateways)

The Takeaway

Worklog companion with Gemma4

What I Built

Demo

Code

saheelwagh / gemmacli

How I Used Gemma 4

Bottled water or your own well? a new choice unlocked by Gemma

1. Procedural Memory (The `SKILL.md` Loop)

2. Persistent State (`MEMORY.md` & `USER.md`)