DEV Community: Paimon

Nous Research Hermes Agent: Setup and Tutorial Guide

Paimon — Sun, 31 May 2026 05:32:31 +0000

This is a submission for the Hermes Agent Challenge: Write About Hermes Agent

Learn how to install and set up Hermes Agent, the open-source AI agent by Nous Research that remembers, learns, and grows smarter with every task.

OpenClaw launched with a lot of hype and security concerns. After that, there were so many copycats claiming to solve different problems related to OpenClaw. Key among them is security due to the size of the repo. Another major problem was the cost of running the agent. From my own experiences, the cost can go up pretty fast, particularly because even the OpenClaw creator recommends using top-tier models such as Claude Opus 4.6 to prevent prompt injection. Opus 4.6 is not a cheap model, particularly when your agent has to send a lot of context in terms of memories and skills. Enter the Hermes Agent.

I have been following the creators of Hermes Agent on X/Twitter, and one of the things they claim is that their agent is better than OpenClaw at using open-source models. They claim that open-source models can be used effectively if they have the right harness. In this article, I will examine these claims by trying out the agent. I will walk you through the installation steps, how to use it with local and online models, and how to use it in a research project.

What Is Hermes Agent?

Hermes Agent is an open-source OpenClaw alternative by Nous Research, the lab behind Hermes models. After launch, it became very popular, getting over 30K stars at the time of this writing. Hermes Agent is a bit different from OpenClaw in that it can create skills from experience, improve itself, and persist the knowledge across sessions.

Hermes Agent key capabilities

Let’s discuss some of Hermes Agent's key capabilities.
Closed learning loop and self-improving memory
The Hermes Agent has a closed learning loop, meaning that:

It has agent-curated memory with periodic nudges
Craete's skills automatically after performing complex tasks
Improves skills as it uses them

Hermes Agent also stores messaging sessions in a SQLite database with FTS5 full-text search. This enables it to retrieve memories from weeks ago, even if they're not currently in memory.

Hermes also uses an Honcho memory that gives the agent a persistent understanding of users across sessions. This is in addition to the memory.md and user.md files to enhance the agent's understanding of user preferences, goals, communication style, and retain context across conversations.

Context compression and caching

One of the main problems of using these AI assistants is how token-intensive they are. When you pay for each API call, it can quickly become very expensive. Hermes Agent uses dual compression and Anthropics prompt caching to manage context usage across long conversations.

This mechanism also prevents API failures when the context is too big. It works by pruning old results and summarizing conversations using an LLM.

Skills system

Like OpenClaw, the Hermes Agent supports skills. The skills are compatible with agentskills.io and follow a progressive disclosure pattern to minimize token utilization. It ships with bundled skills and also saves its own skills as you use it. All skills are stored in ~/.hermes/skills/, but you can also point the agent to external skills.

Multi-platform gateway

The Hermes Agent supports multiple platforms, including Telegram, Discord, Slack, Signal, and WhatsApp. It also supports voice memo transcription. Since sessions go to the same database, it means that you can start a conversation on your terminal and continue it on Telegram.

Subagents and parallel workstreams

The Hermes Agent has a delegate_task tool that is used to start multiple subagents. Agents have restricted toolsets and terminal sessions. They start a new conversation and have no information about the conversation history; therefore, you have to provide all the information the agent needs to achieve its goal. You can use this to, for example, research multiple topics at the same time and collect summaries, code review, and fix and refactor multiple files at the same time.

MCP support and extended tool access

For any tool missing in Hermes, you can connect to MCPs. You can use this for connecting to APIs, a database, or a company system without having to change the Hermes Agent code. You can use them by:

Installing MCP support on Hermes
Adding an MCP server
Whitelist what the tools expose that the MCP can do
Blacklist dangerous activities, such as deleting customers

RL training and trajectory generation

Hermes Agent includes an integrated RL (Reinforcement Learning) training pipeline built on Tinker-Atropos. This enables training of LLMs on a specific environment using GRPO (Group Relative Policy Optimization) with LoRA adapters.

How Hermes Agent Compares to Standard AI Assistants

Let’s now discuss how Hermes Agent compares to other AI assistants such as OpenClaw and Nanobot.

Like other agents, Hermes Agent users memory.md and user.md for persistent memory. It also goes further by storing each session in a SQLite database, making it possible to reference any conversation in the future.

Like OpenClaw, Hermes Agent also supports a fallback model that will handle the tasks when the primary model is not available.

Like most AI assistants, Hermes Agent can also be deployed inexpensively on a VPS and accessed from popular messaging platforms. However, one of its main selling points, according to the team at Nous Research, is that Hermes agent is a better harness for open source models.

You can also explore other AI assistants, such as NanoBot from our Nanobot Tutorial.

Supported Models and Endpoints

The Hermes Agent is model agnostic. Supported models included:

Models from Nous Portal
OpenRouter via an API key
Anthropic Auth and API key
OpenAI subscription or API key
Gemini You can also use local models via Ollama.

Prerequisites for Running Hermes Agent

Hermes runs on Linux, macOS, and WSL2. It also requires Python 3.11 and Node.js, but most of the dependencies are installed automatically during setup.

Hermes Agent Step-by-Step Tutorial: Building A "Research Agent"

Let’s now discover how to use Hermes Agent to create a research agent that can search the web and send you a daily briefing on Telegram.

Step 1: Install Hermes Agent
Open your terminal and run the one-line installer:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Step 2: Get your interface token
For the Telegram gateway, open Telegram and search for @botfather. Send it /newbot, follow the prompts to name your bot, and it will give you a bot token that looks like 123456789:AAH. Copy it for the next steps.

Next user the @userinfobot to get your Telegram user ID. You will need so that your bot only talks to you.

Step 3: Initialize
Run the setup wizard:

hermes setup

When you choose Full Setup, you will be able to configure everything, including API keys and the Telegram bot.

A menu will be provided so that you can configure all the items as shown below:

If you have an existing OpenClaw installation, it also allows you to migrate it.
Once setup completes, you can verify everything with:

hermes doctor

Step 4: Configuration and model selection
If you followed the steps above, you will already have set up the model, but you can change it anytime by running the command below on the terminal:

hermes model

Step 5: Set up the gateway
The gateway is what lets Hermes reach you on Telegram instead of requiring you to stay in your terminal. Set it up by running:

hermes gateway setup

At this point, you should be able to send messages from Telegram and get responses:

Leveling Up Hermes Agent: The "Multi-Tool" Agent

As you can see from the above response, Hermes used the terminal tool to query Yahoo Finance’s public chart API and parse the response. We can improve its web search capabilities by configuring one of the available web search tools; in this case, let’s use FireCrawl. Head over to their website and obtain an AI key for free.
Next, set up the key:

hermes config set FIRECRAWL_API_KEY your_fire-crawl_key

With that in place, I gave Hermes a task that involved searching multiple pages and summarizing the results. As you can see from the image, it planned 3 tasks and delegeted them.

The other way to run multiple agents with Hermes is to set up profiles. This will allow you to run multiple independent Hermes agents on the same machine, with each getting its own config, API Keys, memory, sessions, gateway, and skills. For example, you can have:

A coding agent
A Personal assistant
A research agent You can create one from scratch or by cloning the existing settings:

hermes profile create work --clone

Run work chat to start talking to the bot:

Each agent gets its own .env so you can set up different Telegram bots. You can set up using work setup

Deployment Options: Running Hermes Agent Beyond Your Laptop

Let’s now discover which deployment options exist for running Hermes Agent apart from using it on your laptop.

Other options include:
Running it on a dedicated computer, which is not your daily driver.
Deploying on a VPS, such as on Modal and Daytona.
Even when deploying on a VPS, it's good to follow these best practices:

Use the container backend
Set explicit allowlists
Use pairing codes instead of user ID
Store secrets securely with proper file permissions
Regularly update your agent using hermes update
Never run the agent as root user
Set appropriate resource limits for CPU, disk, and memory
Monitor logs for unauthorized access attempts

Local and Private: Running Hermes Agent Offline

You can run Hermes Agent offline by setting up a model via Ollama. The code snippet below shows how to run and server qwen2.5-coder:32b via Ollama:

# Install and run a model
ollama pull qwen2.5-coder:32b
ollama serve   # Starts on port 11434

Then configure Hermes to use the model:

hermes model
# Select "Custom endpoint (self-hosted / VLLM / etc.)"
# Enter URL: http://localhost:11434/v1
# Skip API key (Ollama doesn't need one)
# Enter model name (e.g. qwen2.5-coder:32b)

Also, make sure to increase the context window because the model needs to load the system prompt, tools, and return a response.

# Option 1: Set server-wide via environment variable (recommended)
OLLAMA_CONTEXT_LENGTH=32768 ollama serve

# Option 2: For systemd-managed Ollama
sudo systemctl edit ollama.service
# Add: Environment="OLLAMA_CONTEXT_LENGTH=32768"
# Then: sudo systemctl daemon-reload && sudo systemctl restart ollama

# Option 3: Bake it into a custom model (persistent per-model)
echo -e "FROM qwen2.5-coder:32b\nPARAMETER num_ctx 32768" > Modelfile
ollama create qwen2.5-coder-32k -f Modelfile

Hermes Agent Common Pitfalls and Troubleshooting

Let’s now talk about some common problems that you may encounter when using the Hermes agent.

Connection refused errors

Run hermes doctor first. This will tell you if you are missing any provider config, broken environment variables, or misconfigured paths. You can also run the setup command again to enter your API key again because you may have a typo.

Context window limits

Type /compress to trigger manual context compression.

You can also edit ~/.hermes/config.yaml to configure compression defaults.

# In ~/.hermes/config.yaml
compression:
  enabled: true
  threshold: 0.50    # Compress at 50% of context limit by default
  summary_model: "google/gemini-3-flash-preview"  # Model used for summarization

Skill not triggering or being reused

Check if the skill exists. Run this command to confirm that the instructions in the skills are being used.

hermes chat --toolsets skills -q "Use the X skill to do Y"

Gateway not receiving messages
Run hermes gateway status to check if it is running.

If it has stopped, start it with hermes gateway start.

Model endpoint authentication failures

Check ~/.hermes/.env to verify that your API keys are correct. Run hermes model to ensure that the model selected has the correct API key.

Future Outlook

If you have been following the Twitter agents' war, you might have noticed that there are two camps: one is for using agents with APIs, and the other for running agents using local models. The local models camp is very vocal in advocating for Hermes Agent, which they claim is a better harness for local models compared to OpenClaw.

Whichever camp you support, one thing is clear: running agents is not cheap. Therefore, if there is a tool that can run local models and provide performance that is close to a top-tier model, then that tool is worth looking at. Especially now with metered usage across all model providers.

With the current demand for agents, users who want unlimited usage will gravitate towards a tool that can offer the best results. As of this moment, many people on Twitter are claiming that Hermes Agent is that tool. Whether local models actually reduce the demand for APIs remains to be seen, especially because not all users have personal GPUs and are technical enough to set them up for local usage.

[Boost]

Paimon — Sun, 26 Apr 2026 10:15:59 +0000

OpenClaw Challenge Submission 🦞

Paimon

Apr 26

OpenClaw - Here's the best setup guide you'll ever need.

#devchallenge #openclawchallenge

8 min read

OpenClaw - Here's the best setup guide you'll ever need.

Paimon — Sun, 26 Apr 2026 10:15:49 +0000

This is a submission for the OpenClaw Writing Challenge

before you install anything

straight in - you need three things ready before you even touch a terminal.

AI model API key
openclaw works with multiple model providers.
you're not locked to one.
here's what's available right now:
1. and my pick - anthropic (claude) - the best overall for agents. opus 4.6 is the smartest model available and what i recommend for setup. sonnet 4.6 is cheaper and handles everyday tasks well. console.anthropic.com
2. openai (GPT-5.4) - strong alternative. great tool calling, solid all-rounder. a lot of people switched here last week when anthropic cut off subscription access - also where the founder of OpenClaw now works. platform.openai.com
3. google (gemini 2.5 pro) - good for long context tasks. generous free tier to get started. worth having as a backup or starting point if budget is tight. aistudio.google.com
4. *ollama *(local models) - run gemma 4 or other open source models directly on your machine. completely free. not frontier quality but handles routine agent tasks without breaking a sweat
5. *deepseek *- strong reasoning model from china. very competitive pricing. worth looking at if you want a cheaper alternative to opus for complex tasks

my recommendation: start with anthropic (opus 4.6) as your primary. it's the king of models for agent work. load $250 in API credits to get from zero to fully operational without hitting rate limits - new API customers get lower limits by default and putting real money in upfront avoids that bottleneck while you're building. even $50 gets you started if budget is tight.

a groq API key (for voice notes)
this is separate from your main model. groq powers the voice note transcription through the whisper plugin - it's how your agent understands your voice messages on telegram. you'll use this constantly.
it's free. sign up at console.groq.com and grab your API key.
a web search API key
your agent needs to search the internet. here are your options:
brave search - ~$5/month. reliable, fast, best value for money. my recommendation. brave.com/search/api
tavily - has a free tier. built specifically for AI agents. tavily.com
firecrawl - search plus full page scraping in one tool. firecrawl.dev
SearXNG - completely free. self-hosted. more setup work but zero cost forever
my recommendation: brave search. it's been the most reliable and the best bang for your buck in my experience. if you want completely free, tavily's free tier works.

installing openclaw

open terminal and run:

on windows (powershell): iwr -useb https://openclaw.ai/install.ps1 | iex
if you're on a brand new mac mini or mac device, you might need to install homebrew first, using this terminal prompt: /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

once openclaw is installed, run the setup wizard:
openclaw onboard
this walks you through everything step by step. here's what to pick:
provider: select anthropic and paste your API key.

model: select opus 4.6. or whichever model you're choosing - but opus is what i recommend for the setup phase. you want the smartest brain available while you're building the foundations.

communications: you'll be asked to set up a messaging platform. for this guide we're going with telegram - it's honestly the easiest. but you can skip this step if you want. i actually find it easier to do the telegram part manually in its own step later since you need to pair it anyway.
skills to preload: this is where most guides just say "install clawhub" and move on. don't do that. install these:

clawhub - the skill marketplace
mcporter - MCP tool routing
openai-whisper - voice transcription (essential for voice notes)
model-usage - track what your agent is spending
github - if you use git at all, get this in now
nano-pdf - PDF reading and processing additional APIs (notion, elevenlabs, etc): skip all of these. you don't need them yet. hooks: enable all four:

boot-md - loads your config files on startup
bootstrap extra files - sets up your workspace structure
command-logger - tracks what your agent runs
session-memory - remembers context across sessions once you continue through these steps, you should see the option to hatch in TUI. this is the moment your agent comes to life in the terminal chat window. do it.

say hello. give it a name. watch it respond.
that first reply is a proper magic moment. enjoy it.

connecting telegram

now you've got a living agent in your terminal. but you don't want to live in the terminal. you want it on your phone.
here's the move. tell your agent exactly this:
"okay [agent name], we're going to use telegram to finish setting up and onboarding. next i will send you the API key for my telegram bot and you can install the telegram communication skill for me using it."
now go set up the bot:

open telegram and message @botfather
send /newbot
pick a name and username for your bot
BotFather gives you an API key - copy it go back to your agent in the TUI and paste the API key in with the message above (or right after it). your agent will install the telegram plugin for you. once it's done, head to telegram and open your new bot. click start - you'll see a PAIR code. copy that pair code and paste it back to your agent in the TUI. it handles the rest - pairing, syncing, connecting everything. now go back to telegram and send "hi." watch your agent reply. welcome to a much better and cleaner way to communicate with your agent from anywhere and everywhere. this is how i run everything now.

the best and most practical way to set up your agent from birth

now you have telegram connected, we're going to run through the setup that actually matters. in this order:

install kickstart i built a skill called kickstart that saves you the first 4 hours of pain in openclaw. it's free on clawhub. tell your agent: install the kickstart skill by jordymaui from clawhub here's what it gives you:

SOUL.md - your agent's personality file. who it is, how it talks, what it cares about. without this your agent sounds like every other generic chatbot
USER.md - information about you. your name, timezone, preferences, what platforms you use. your agent reads this so it knows who it's helping
AGENTS.md - the operating manual. rules for how your agent behaves, when to speak, when to stay quiet, how to handle memory
TOOLS.md - local notes about your specific setup. camera names, API details, device info - anything unique to your environment
HEARTBEAT.md - a checklist your agent reviews periodically to stay proactive instead of just waiting for you to ask things
kickstart doesn't just create these files - it guides your agent through filling them out properly. go ahead, install it and move to the next step.

install QMD
next up - making sure you have QMD installed.
install the QMD skill from clawhub
QMD upgrades your agent's memory system with semantic search. instead of your agent scanning through flat text files trying to find what you said three weeks ago, it can actually search by meaning. "what did i say about the budget?" just works. without QMD, your agent's memory is a filing cabinet with no labels. with it, everything is indexed and searchable.
your onboarding session
this is the most exciting part and honestly the step that makes the biggest difference.
here's what i always recommend - from brand new beginners to the companies i've consulted for building openclaw systems. send your agent this:
before we do anything else, i need you to understand who i am and what we're building together. create a questionnaire - no more than 20 direct questions - covering who i am, what i do, how i work, what i need from you, and what your role is going to be. keep the questions short and clear. i'm going to answer all of them in one voice note so make sure they flow naturally as a conversation. after i reply, write everything you learn into your memory files so you never have to ask again.
your agent will come back with a list of questions. now here's the important bit:
reply with a voice note. not text. voice.
talk off the cuff. be casual. pause when you need to think. your agent picks up on how you communicate, what you care about, and what's actually on your mind.
if you're not sure what the agent's use case is yet - just say that. talk to it like it's a mate and you're thinking through potential ideas together. there is genuinely no wrong answer here as long as you're open, honest, and giving it real context about your life.
this one voice note will give your agent more useful information than weeks of typed messages. i learned that the hard way.

best practices from 500+ hours of daily use

model routing

don't run everything on opus. it's the best model but you don't need the best for every task.
set up your config so opus handles the complex stuff - reasoning, multi-step tasks, creative work. sonnet or groq handles the routine stuff - calendar checks, simple lookups, monitoring, notifications.
this alone cut my monthly cost in half. your agent routes automatically once it's configured.

keep CLAUDE.md short

this file gets re-injected every single message your agent processes. the leaked claude code source confirmed it. if yours is 2000 words of life story, you're burning tokens and confusing your agent on repeat.
mine is 6 lines. name, role, communication style, three rules. everything else lives in skills and memory files where the agent pulls it when it needs it.

split agents by job

if you're doing more than 3-4 different things, use separate agents. one agent scanning twitter, managing data, writing content, handling emails, and running cron jobs - it works for about two weeks before context starts bleeding between tasks and everything slows down.
dedicated agents for dedicated jobs. cleaner context, faster responses, fewer mistakes.

read your memory files

your agent writes notes about you after every conversation. check them weekly. you'll catch when it has the wrong idea about something before it acts on it. it's like reading your assistant's diary - sometimes spot on, sometimes hilariously wrong.

update regularly

nine CVEs dropped for openclaw in one week last month. one scored 9.9 out of 10. run openclaw update weekly. not optional.

3D-First Portfolio Built with Antigravity

Paimon — Sat, 31 Jan 2026 18:28:09 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

I’m Aayush Bisht, a MERN stack developer with a strong interest in building interactive, visually rich web experiences that combine solid engineering with thoughtful design.

I enjoy working at the intersection of frontend performance, animation, and system architecture where small details like motion, timing, and interaction can completely change how a product feels.

For this project, I wanted to move beyond a traditional portfolio and explore how modern tools like Gemini 3 and Google Antigravity can support creative and technical decision-making throughout the development process. Instead of using AI only to generate code, I used it to reason about structure, animation flow, and interaction design.
This portfolio reflects how I like to build: ambitious ideas, broken down thoughtfully, executed with care and refined through iteration.

Portfolio

This portfolio relies heavily on scroll-driven animation, 3D interaction, and viewport-aware transitions.

For that reason, the best way to experience it is in a full browser window.

Live Portfolio:

https://portfolio-v2-709587781727.us-central1.run.app/

--labels dev-tutorial=devnewyear2026

How I Built It

This project is a Next.js 14 interactive 3D portfolio, built around a single idea:

Use motion, transformation, and spatial interaction to guide the viewer through a story.

Tech Stack

Next.js 14 (App Router)
React 18 + TypeScript
Tailwind CSS
GSAP + ScrollTrigger
Framer Motion
Spline (3D design & runtime)
Lenis (smooth scrolling)
Radix UI + custom UI components
Deployed on Google Cloud Run

Using Gemini 3

Gemini 3 played a key role throughout the development process — not by generating finished code, but by helping reason about complex systems.

Gemini was used to:

Explore different ways of mapping scroll position to 3D transformations
Reason about how a single 3D object could represent multiple sections of a portfolio
Evaluate animation pacing and transitions between sections
Think through interaction patterns between React state, GSAP timelines, and Spline objects
Stress-test ideas before committing to implementation

Many of the architectural decisions especially around animation sequencing and state-based transformations were refined through iterative conversations with Gemini.

Antigravity for Rapid Iteration

While Gemini helped shape ideas, Antigravity made it possible to execute them quickly.

Antigravity accelerated:

Refactoring large animation orchestrators
Iterating on scroll-triggered logic without breaking behavior
Maintaining consistency across many interactive components
Experimenting with alternate animation flows safely

This allowed the project to evolve organically without losing structure.

The 3D Keyboard System

At the heart of the portfolio is a Spline-designed mechanical keyboard, used as a dynamic visual metaphor.

The keyboard transforms through multiple states as the user scrolls:

Hero — subtle rotation and motion to establish presence
Skills — interactive keycaps representing technologies
Projects — dramatic rotation with animated elements
Contact — a teardown animation where keycaps break apart

Each keycap is mapped to a real skill and responds to hover and press events, updating live text inside the 3D scene.

All transformations are orchestrated through GSAP timelines tied directly to scroll position.

Designing the Portfolio Around a 3D Model

At the core of this portfolio is a single 3D object: a mechanical keyboard designed in Spline.

Rather than treating the 3D model as a background visual or decorative element, the entire website was designed around it. The layout, section flow, scroll behavior, and interactions were all shaped to support how the keyboard transforms and reacts over time.

Gemini played a key role in reasoning through this model first approach.

Using Gemini, I explored questions like:

How can a single 3D object represent multiple sections of a portfolio?
What transformations feel natural when transitioning between skills, projects, and contact?
How should spatial changes (scale, rotation, position) map to scroll progression?
Where should interaction live in the UI, the 3D scene, or both?

These conversations helped define a system where each section corresponds to a distinct keyboard state, with its own transformation logic and interaction rules.

The result is a portfolio where the 3D model isn’t an add-on it’s the structural backbone of the experience. Content and motion exist to complement the model, not compete with it.

Gemini made it possible to think through this complexity before implementation, allowing the final system to feel intentional rather than experimental.

What I'm Most Proud Of

Turning a 3D Object Into a Narrative Device

Instead of using 3D as decoration, the keyboard acts as a storytelling element reacting, transforming, and evolving alongside the content.

Complex Animation, Controlled Carefully

GSAP handles precision choreography.

Framer Motion handles UI-level interactions.

Spline handles spatial and interactive depth.

Each tool is used where it excels.

AI as an Enabler, Not a Gimmick

There is no visible “AI feature” in the UI.

Yet AI influenced nearly every decision:

How animations flow
How interactions feel
How complexity stays manageable

Gemini and Antigravity didn’t replace creativity they amplified it.

Conclusion

This project is not about building a flashy portfolio.
It’s about exploring what becomes possible when modern frontend engineering, 3D interaction, and AI-assisted reasoning come together.
Gemini 3 and Antigravity made it possible to think bigger, iterate faster, and refine ideas more confidently.

And that’s the most exciting part.