Verdict: For developers and small teams who want an AI agent that genuinely improves over time instead of forgetting everything between sessions, pairing Hermes Agent (Nous Research's open-source, self-improving agent framework) with Laguna S 2.1 (Poolside's 118B open-weight coding model) is the strongest fully open stack available in July 2026. Hermes provides the memory, the skill-creation loop, and the multi-platform reach; Laguna provides a coding brain that scores 70.2% on Terminal-Bench 2.1 using only 8B active parameters — competitive with models many times its size. Connecting them through OpenRouter takes under 15 minutes if you already have Hermes installed, and the whole thing runs on a $5 VPS (Hermes) or even a single desktop machine (Laguna S 2.1 self-hosted).
Last verified: 2026-07-23
- Hermes Agent: open-source (MIT license), GitHub: NousResearch/hermes-agent, one-command install.
- Laguna S 2.1: released July 21, 2026 by Poolside. 118B total params / 8B active per token. Open weights under OpenMDW-1.1. Free on OpenRouter at 256K context.
- Pricing/limits change often — re-check before production deployment.
What Is a Self-Improving AI Agent?
A self-improving AI agent is one that retains knowledge across sessions, creates reusable skills from the tasks it completes, and gets measurably better at repeated work — instead of starting from a blank context window every time you open a new chat. Most AI assistants today are stateless: you teach them your preferences, your codebase, and your workflow, and by the next session it's all gone. A self-improving agent builds a persistent model of you and your work, so the hundredth interaction is faster and better than the first.
Hermes Agent by Nous Research is the most prominent open-source example as of mid-2026. It uses a closed learning loop: observe a task, plan a solution, act, then learn from the outcome — preserving the successful approach as a reusable skill file that it can pull automatically next time. The agent also maintains multi-layer memory (short-term context, cross-session recall, and procedural skill memory), so it can retrieve a workflow or correction from weeks ago without you repeating it.
What Is Hermes Agent and How Does It Work?
Hermes Agent is an open-source, MIT-licensed autonomous AI agent built by Nous Research and first released on February 25, 2026. It runs on Linux, macOS, WSL2, and Docker, and you interact with it through a terminal CLI, a web dashboard, or messaging platforms like Telegram, Discord, Slack, WhatsApp, Signal, and Matrix. You don't need to use it through a browser — it lives on your own machine or server.
The three pillars that make Hermes different from ChatGPT, Claude, or Cursor:
1. Persistent cross-session memory. Hermes stores durable facts in a local MEMORY.md file and a user profile, plus a SQLite database with FTS5 full-text search for querying past conversations. Everything lives under ~/.hermes/ on your machine — zero telemetry, zero cloud call-home. If you tell it your project structure on Monday, on Friday it still knows.
2. Automatic skill creation and improvement. When you complete a complex task, Hermes writes a SKILL.md file — a reusable template that captures the approach, the steps, and the key decisions. The skill gets loaded automatically the next time a similar task comes up, and Hermes refines it over use. According to independent analysis, agents that accumulate 20 or more self-generated skills are roughly 40% faster on repeated tasks in the same domain (innobu.com, corroborated by Nous Research's own GEPA-based benchmarks accepted at ICLR 2026).
3. Model agnosticism. Hermes is not tied to a single model. It routes through 200+ models on OpenRouter, or directly through OpenAI, Anthropic, Google, z.ai, MiniMax, Kimi, NVIDIA NIM, or any OpenAI-compatible endpoint — and you can switch providers mid-session without restarting. This is the key to pairing it with Laguna S 2.1: you point Hermes at the Laguna model string and it starts routing every request through that brain.
Hermes also ships with 40+ built-in tools (web search, browser, file operations, terminal, vision, image generation, TTS), a cron scheduler for operating 24/7 automations, subagent delegation for parallel work, and MCP (Model Context Protocol) integration for connecting external services.
What Is Laguna S 2.1 and Why Does It Matter for AI Agents?
Laguna S 2.1 is Poolside's newest open-weight coding model, released on July 21, 2026. It was designed specifically for agentic coding — autonomous, multi-step terminal workflows where a model reasons through problems, writes code, runs it, and iterates — rather than being a chat model that happens to code.
Here are the verified specifications:
| Spec | Value | Source |
|---|---|---|
| Architecture | Mixture-of-Experts (MoE), 256 routed experts + 1 shared expert | Hugging Face model card |
| Total parameters | 118B | Poolside blog |
| Active parameters per token | 8B (~6.8%) | Poolside blog |
| Context window | 1,048,576 tokens (paid endpoint); 262,144 tokens (free tier) | OpenRouter |
| Max output | 131K tokens (paid); 33K (free) | OpenRouter |
| License | OpenMDW-1.1 (commercial use permitted, Linux Foundation-backed) | Hugging Face |
| Training hardware | 4,096 NVIDIA H200 GPUs | VentureBeat |
| Training time | Under 9 weeks (pre-training started May 22, 2026) | Poolside blog |
| Pricing (paid) | $0.10 / M input · $0.20 / M output · $0.01 / M cache-read (OpenRouter) | MarkTechPost |
| Pricing (free tier) | $0.00, 256K context | OpenRouter |
Benchmark performance (Poolside-reported, July 21, 2026)
| Benchmark | Laguna S 2.1 | Notes |
|---|---|---|
| Terminal-Bench 2.1 (thinking) | 70.2% | 11th on leaderboard; ahead of DeepSeek-V4-Pro-Max (64.0%), Thinking Machines Inkling (63.8%), NVIDIA Nemotron 3 Ultra (56.4%) |
| Terminal-Bench 2.1 (no thinking) | 60.4% | Still competitive — the thinking-mode boost is +9.8 points |
| SWE-Bench Multilingual | 78.5% | Near the top of the open-weight field |
| SWE-Bench Pro (Public) | 59.4% | Beats DeepSeek-V4-Pro-Max (55.4%) |
| DeepSWE v1.1 | 40.4% | Some 1T+ parameter open models score below 10% |
| SWE Atlas (Codebase QnA) | 46.2% | Leading the comparison set cited by Poolside |
All benchmarks are vendor-reported and based on Poolside's own agent harness (pool) for DeepSWE, not the standard mini-swe-agent used by DeepSWE's leaderboard — scores are less directly comparable for that benchmark. Poolside published full unedited trajectory logs for every trial, which is unusual transparency for an AI lab.
The headline: an 8B-active model beats models like DeepSeek-V4-Pro-Max (1.6T total params, 49B active) on two benchmarks. According to Poolside co-head of applied research Pengming Wang, the gains came from improving working habits, not raw intelligence: "more verification, less taking things for granted, not declaring victory early, and being more persistent" (Poolside blog).
Why MoE matters for agents
A Mixture-of-Experts model routes each token to a small subset of "expert" sub-networks rather than running all parameters on every computation. With Laguna S 2.1, only 8B of the 118B parameters fire per token — so inference cost scales with the 8B active, not the 118B total. According to The Decoder, the model is small enough to run on a single NVIDIA DGX Spark, the desktop-class AI machine. For an agent like Hermes that may run hundreds or thousands of inference steps over hours of unattended work, that cost-per-token difference is the difference between a $5/day bill and a $50/day bill.
How Does Hermes Agent Compare to Other AI Agent Frameworks?
Hermes Agent competes with ChatGPT, Claude Code, Cursor, and Devin, but the comparison is partly apples-to-oranges — most of those are closed, hosted products, while Hermes is a fully open-source agent framework you run yourself. The different combination changes the calculus:
| Feature | Hermes Agent | ChatGPT (OpenAI) | Claude Code (Anthropic) | Cursor | Devin |
|---|---|---|---|---|---|
| Self-improving skills | Yes — built-in loop, auto-created SKILL.md files | No | No | Partial (project rules) | Partial |
| Persistent cross-session memory | Yes — multi-tier, FTS5 search | Partial (memory feature) | Limited | Awareness scope | Yes |
| License | MIT (fully open-source) | Closed | Closed | Closed | Closed |
| Model support | 200+ via OpenRouter, any compatible endpoint | OpenAI only | Anthropic only | Multiple | Multiple |
| Self-hosting | Yes — local, Docker, SSH, cloud VPS, GPU | No | No | No | No |
| Messaging gateways | 15+ (Telegram, Discord, Slack, WhatsApp, Signal, Matrix, email) | No native | No native | No | No |
| 24/7 scheduled automations | Yes — built-in cron | No | No | No | Yes |
| Cost to run | Free (you pay only for your LLM provider) | $20–200/month | $20–200/month | $20/month | Subscription |
Bottom line: if you want a closed chat assistant that works out of the box, ChatGPT or Claude is simpler. If you want an agent that remembers your business and gets smarter at your specific workflows over time — and you're comfortable with a terminal — Hermes Agent is the only open-source option with genuine self-improvement as of mid-2026.
If you want a deeper comparison focused on the self-improvement architecture itself, see our guide on how to build a self-improving AI agent with skills, memory, and open models.
Why Pair Hermes Agent With Laguna S 2.1?
Most developers run Hermes Agent with a general-purpose model (GPT, Claude, Gemini) as the brain. That works well for writing, research, and everyday automation, but if your agent's primary job involves engineering work — writing code, debugging, running terminal commands, navigating large repositories — a model built specifically for agentic coding gives measurably better results.
Laguna S 2.1 was designed from the ground up for software engineering and autonomous agents. A few features that make it a particularly good fit as Hermes's brain:
Long context (256K free, up to 1M paid). A 1-million-token context means your agent can ingest an entire codebase or full documentation set in a single session without losing thread of what it was doing. For context, 256K tokens is roughly 200,000 words — enough for most repositories and their dependencies.
Thinking mode. Laguna S 2.1 supports separate "thinking" and "no-thinking" modes. Enabling thinking mode lifts Terminal-Bench scores from 60.4% to 70.2% — Poolside reports the largest performance gap ever between the two modes for a Laguna model. When an agent is running unattended for hours, productive reasoning over long horizons matters more than raw generation speed.
Tool calling and multi-step execution. The model supports function calling and interleaved reasoning, which is exactly what an agent loop needs — plan what to do, call a tool, interpret the result, decide the next step.
Open weights, self-hostable. If you're already running Hermes on your own infrastructure for privacy and control, you can extend that to the model itself — host Laguna S 2.1 locally with Ollama or vLLM, and nothing about your work leaves your network.
For more on different AI models and which tasks they're best suited for, see our real-world model task-routing guide.
How to Connect Laguna S 2.1 as Hermes Agent's Brain (Step-by-Step)
Prerequisites
- Hermes Agent installed and running (if you haven't installed it yet, the one-liner below does it in under a minute)
- An OpenRouter account (free — you get API credits to try models)
Step 1: Install Hermes Agent (if you haven't yet)
On Linux or macOS:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
On Windows, use WSL2 and run the same command, or download the official Hermes desktop installer for macOS/Windows.
This clones the repo, sets up the Python virtual environment, installs dependencies, and configures the ~/.hermes/ directory. The entire process takes around a minute.
For the full install walkthrough and what to expect across versions, see our Hermes Agent 0.19 Quicksilver update guide.
Step 2: Get an OpenRouter API key
OpenRouter is an API gateway that fronts 200+ models including Laguna S 2.1. It's the simplest way to give Hermes model access without managing separate provider accounts.
- Go to openrouter.ai and create a free account.
- Go to Settings > API Keys and generate a new key.
- Add some credits (the free Laguna tier at 256K context is $0.00 — a good way to test).
Step 3: Configure Hermes to use OpenRouter as a provider
Open your Hermes config file. From the terminal:
hermes config set openrouter_api_key sk-or-v1-YOURKEY
hermes config set provider openrouter
Alternatively, you can edit ~/.hermes/config.yaml directly:
providers:
openrouter:
api_key: "sk-or-v1-YOURKEY"
base_url: "https://openrouter.ai/api/v1"
Run hermes config check after any provider change to verify the key is recognized.
Step 4: Set Laguna S 2.1 as your model
hermes config set model "poolside/laguna-s-2.1:free"
The :free suffix targets the free tier at 256K context. For the full 1-million-token context window, use poolside/laguna-s-2.1 (paid endpoint — $0.10 / $0.20 per million input/output tokens).
You can verify the model is recognized:
hermes config show
hermes doctor
hermes doctor checks your full setup — provider, model key, file structure — and tells you exactly what's missing or misconfigured.
Step 5: Configure a fallback model
Always set a second model as a fallback, in case OpenRouter is down or rate-limited:
hermes config set fallback_model "anthropic/claude-sonnet-5"
For maximum independence (no external provider at all), consider setting Ollama running locally as a last-resort fallback, so the agent can still work towards completing your task even if every cloud provider is unreachable.
Step 6: Test the setup
hermes run "Write a Python function that returns Fibonacci numbers as a generator, with docstring and type hints"
If everything is wired correctly, Hermos routes the request through OpenRouter to Laguna S 2.1 and returns a response. The first response should take a few seconds (cold start), subsequent turns will be faster.
Step 7: Connect messaging and scheduling (optional but powerful)
The pair becomes much more useful when you add a messaging gateway (so you can talk to your agent from your phone) and the cron scheduler (so it runs automations while you sleep):
# Connect to Telegram
hermes gateway add telegram --token YOUR_BOT_TOKEN
# Schedule a daily standup summary at 8 AM
hermes cron add --name "daily-standup" --schedule "0 8 * * *" \
--prompt "Review yesterday's git commits from the my-app repo, summarize what changed, identify any TODOs or risky patterns, and post it to the #standup channel"
For deeper coverage of multi-agent scheduling patterns (running several Hermes instances in parallel on different tasks), see our guide on Hermes Agent Quicksilver multi-agent workflows.
What Does This Cost to Run?
The honest cost depends on three variables: what model, how many tokens/day, and whether you're on the free or paid tier. Here are rough monthly estimates based on typical small-team usage:
| Usage pattern | Model | API cost / month | Est. tokens consumed |
|---|---|---|---|
| Casual: 20–30 short tasks/day | Laguna S 2.1 (free tier) | $0 | ~5–10M total |
| Heavy agent use: 100+ tasks/day | Laguna S 2.1 (paid 1M context) | $5–20 | ~30–100M |
| Mixed: coding + writing + research | Claude Sonnet 5 via OpenRouter | $20–40 | mixed quality tiers |
| Self-hosted: all local | Laguna S 2.1 via Ollama (Q4_K_M, 75GB model) | $0 (or your own hardware/electricity) | unbounded by API limits |
The wild card is the free Laguna tier: $0 at 256K context on OpenRouter. For solo founders and small teams, this is functionally free coding-agent inference — you only pay if you need the full 1M context or higher rate limits.
A note on "free" usage: the OpenRouter free tier is rate-limited (typically tens of requests per minute per key) and Poolside's terms indicate free-tier usage may be used for improving the model. Read the OpenRouter terms before sending sensitive data through any free tier.
What This Means for You
If you're a solo developer or small-team builder who's been integrating disconnected AI tools — a tab for ChatGPT, a separate IDE for Cursor, a third tool for automation — pairing Hermes Agent with Laguna S 2.1 gives you one persistent system: a single agent that knows your codebase, remembers what you tried last week, generates reusable skills, and codes at benchmark levels competitive with models that cost 20–50x more per token.
The day-one setup is for technically comfortable users (you don't need to be a developer, but you should be willing to use a terminal). Plan for about an hour to get the full stack working — install Hermes, get an OpenRouter key, point it at Laguna, wire up one messaging channel, and test a real task. Once it's running, the compounding effects start fast: by the second week, Hermes has accumulated enough skills and memory that simple tasks take 30–40% less prompting and re-explaining than they did at launch.
FAQ
Q: Is Hermes Agent really free? A: Yes — Hermes Agent itself is MIT-licensed and fully open-source. You pay nothing for the agent framework. Your only costs are whatever LLM provider you route through (OpenRouter, OpenAI, Anthropic, etc.). If you route through OpenRouter's free Laguna S 2.1 tier, your total cost can be $0.
Q: Can I run Laguna S 2.1 locally without any API?
A: Yes. Laguna S 2.1 weights are available on Hugging Face under OpenMDW-1.1. The Q4_K_M quantized version is ~75GB, which fits on a 128GB unified-memory machine like an NVIDIA DGX Spark or an Apple Silicon Mac with 128GB RAM. Use ollama run laguna-s-2.1 after downloading.
Q: Does Hermes Agent support Claude or GPT too, not just Laguna? A: Yes — Hermes is model-agnostic. You can switch between Laguna S 2.1, Claude Sonnet 5, GPT-5.6, Gemini 3.6 Flash, or any of the 200+ models on OpenRouter mid-session without restarting. Hermes recommends setting at least one strong fallback model.
Q: How does Laguna S 2.1's "thinking mode" affect performance? A: Substantially — Poolside reported the largest thinking-mode gap ever observed for a Laguna model. Max-thinking lifts Terminal-Bench 2.1 from 60.4% to 70.2% (+9.8 points) and DeepSWE from 16.5% to 40.4% (+23.9 points). The trade-off is latency: thinking mode generates more tokens, so it takes longer. For agent work where the agent can run unattended for minutes or hours, thinking is worth the wait.
Q: What hardware do I need to self-host this whole stack? A: For Hermes alone, a $5/month VPS with 1GB RAM is sufficient. For self-hosting Laguna S 2.1 in addition, you need roughly 128GB of memory (a high-end Mac, an NVIDIA DGX Spark, or a workstation with 2× H100 / 1× B200). For most users, the easier path is to self-host Hermes and use OpenRouter's hosted Laguna endpoint — total cost: free at 256K context.
Q: Is this production-ready for a business? A: Hermes Agent itself is maturing rapidly (215k+ GitHub stars, active weekly releases as of mid-2026) but is best suited to technically comfortable users and pilot projects. For enterprise production, the main gaps are audit logging (decisions aren't logged out-of-the-box yet) and explicit governance. The EU AI Act transparency rules kicking in August 2026 raise some compliance considerations. Most small teams can run Hermes + Laguna in development today; production deployments should factor in security review and memory inspection before connecting real customer data.
Discussion
0 comments