Most teams aren't underspending on their AI agent stack. They're compounding it wrong. Gartner expects over 40% of agentic AI projects to be canceled by the end of 2027, and Deloitte's 2026 State of AI in the Enterprise found only 11% of companies have agents in production despite 75% planning to invest. The reflex is to blame the model. It's almost never the model.
There's a difference between using AI and building a system that gets better every time it runs. After working inside dozens of agent stacks, the same pattern shows up: teams reach for the newest model, the highest token limit, the flashiest integration. They add compute. They don't add compounding.
I'll go first. I would have guessed my own stack scored a 3. Run honestly against the test below, it was a 2. I had a real skills library and ran everything sandboxed, so I felt covered. But there was no persistent memory, one bloated thread instead of isolated subagents, and everything lived in a single terminal I had to go find. It worked until a client asked why the agent relearned the same context every morning, and I didn't have a good answer.
Nous Research's Hermes Desktop changed how I frame this with clients. Not because it's the only agent stack worth running. Because it quietly assembled five architectural patterns that most stacks only partially implement. When you hold any AI setup against those five, the gaps get obvious fast.
This is that checklist.
What Hermes Desktop Actually Shipped
Hermes Desktop is a native cross-platform GUI for Hermes Agent (MIT licensed), running on macOS, Windows, and Linux. It shipped in public preview on June 2, 2026 on the v0.15.2 build, and Nous Research followed within days with v0.16.0, fittingly named "The Surface Release." If you are evaluating it now, work from v0.16.0. It is not a new agent. It is a new surface for the same agent already running in terminal, TUI, web dashboard, and a messaging gateway. The architecturally interesting part: the same memory, skills, and sessions follow you across every surface.
That session persistence is the first signal that something structural is different here. Desktop to Telegram to terminal, with no reset in between. But the product release is the least interesting part. The more useful read is what it made visible: a set of decisions most teams have been quietly deferring.
The 5-Pattern Checklist
Score your current stack against each pattern honestly. These aren't aspirational standards. They're the patterns the strongest agent infrastructure converges on, and Hermes is notable for productizing all five in one coherent system rather than inventing any single one.
1. Memory the Agent Curates
Memory means persistent state the agent writes and retrieves on its own across sessions. The agent decides what to save, pulls relevant context without being asked, and manages its own store. A large context window is not memory. A system prompt full of background notes is not memory. Memory survives the session ending.
Most teams conflate the two, and the data shows the cost. Atlan documents how long conversations can start contradicting themselves once early instructions fall off the context window, with no error to flag it. How quickly that happens depends on how much each turn consumes rather than a fixed turn count, but the failure mode is real and silent. Context windows grew from 512 tokens in 2018 to over 1 million by 2024, and stuffing them fuller did not solve recall. Hermes implements real memory through built-in MEMORY.md and USER.md files, FTS5 full-text search over session history, and LLM-driven summarization for cross-session recall. For deeper user modeling it can plug into one of eight optional external memory providers, including Honcho's dialectic approach, which analyzes a conversation after it happens to build a structured model of the user. Honcho is a layer you opt into, not the core memory engine.
The tell: If your agent starts every session knowing nothing it learned last time, you don't have memory. You have etiquette.
What to look for: Agent-curated write decisions, session-persistent storage, and retrieval that happens without operator prompting. For a deeper build guide, see Give Your AI Agent Real Memory.
2. Skills the Agent Improves on Its Own
Self-improving skills means the agent rewrites its own playbooks after successful runs. Not the operator. Not the developer. The agent closes its own feedback loop, so every completed task sharpens the next one without a human editing prompts in between.
This is where most orchestrators stop. Claude Code, OpenAI GPTs, and custom wrappers have skill systems, but they're operator-curated: you tune the prompts, you add steps, you decide when something ships. That manual loop is expensive at scale. LangChain's 2026 State of Agent Engineering survey of 1,300+ professionals found 32% cite output quality as the top barrier to production, which is exactly what static, hand-tuned playbooks fail to fix. Hermes flips the model with auto-generated, self-improving skills. One honest caveat on maturity: the skills are human-readable Markdown you can open and audit, but there is no explainability interface yet for why the agent retains or rewrites a given skill, and the deeper trace-based self-evolution work is still early. The loop is real, and it still rewards periodic review.
The tell: If you're tweaking system prompts between runs to make your agent better, the agent isn't improving. You are.
What to look for: Agent-initiated skill writes, improvement triggers on task completion, and a skills store that evolves without operator input.
3. Subagents With Their Own Context
Isolated subagents means one orchestrator spawns workers that each get a clean, separate context. Zero bleed between tasks or parallel workstreams. Isolated contexts are cheaper (fewer tokens per task), safer (one bad run can't corrupt others), and more reliable (workers start clean instead of inheriting a long chain of decisions).
LangGraph, CrewAI, AutoGen, and OpenAI Swarm all support subagent delegation, so this pattern isn't unique to Hermes. What matters is whether your production stack actually implements it or ships the simpler version: one bloated thread where everything from step 1 still sits in the window at step 8. That bloat is a known reliability tax, not a convenience.
The tell: If your multi-step workflow is one continuous conversation, you're running the bloated-thread version.
What to look for: Isolated subagent conversations or terminals, Python RPC for zero-context pipelines, and explicit orchestrator-worker separation.
4. Sandboxed Execution With a Selectable Blast Radius
Sandboxing means the agent executes code and commands inside a configurable boundary you choose on purpose. The line between the agent and your systems is explicit, not assumed. Sandboxing isn't paranoia. It's deciding your blast radius before you need it.
The tooling exists across the ecosystem: e2b, Docker, Modal, SSH, Singularity. Hermes ships five native execution backends of its own (local, Docker, SSH, Modal, and Singularity, with Daytona added in the configuration docs), all with container hardening and namespace isolation. Tools like e2b are reachable through MCP rather than as a native backend. The point isn't that no one else has sandboxing. It's that most teams skip it, and churn makes that riskier. Cleanlab's 2025 production survey found 70% of regulated enterprises rebuild their agent stack every three months or faster, and that internal tools fail twice as often as vendor partnerships. The teams running shell commands directly on a laptop have the bad week sooner or later.
The tell: If you don't know where your agent executes code right now, you haven't made a decision. You've deferred one.
What to look for: Configurable execution environments, explicit agent-host separation, and sandboxed terminal or code execution. More in Sandboxing Your AI Agents.
5. The Same Agent in Every Place You Already Work
Multi-surface presence means the same agent shows up in desktop, terminal, Telegram, Slack, and email with shared memory and skills. Sessions follow you across surfaces instead of resetting each time you switch interfaces. This is what makes an agent feel like infrastructure rather than a tool.
This is the hardest pattern to productize in practice. Most stacks are single-surface by default: CLI, or web UI, or API. You go to the agent. The agent doesn't come to you. Hermes ships a messaging gateway that covers the surfaces most people actually live in (Telegram, Discord, Slack, WhatsApp, Signal, email, and CLI) and extends to 20+ platforms in total, with sessions that resume across all of them.
The tell: If you have to navigate to a specific terminal or dashboard to talk to your agent, the agent doesn't live where you do.
What to look for: Multi-surface support, session persistence across interfaces, and shared memory and skills regardless of entry point.
How Most AI Agent Stacks Score
Most stacks land at 2 or 3 of 5. That's not a failure. It's the current baseline, and it tracks with the broader data: McKinsey's 2025 State of AI reports 88% of organizations now use AI in at least one function, but only about a third have scaled past experiments. Here's how the common stack types map to the five patterns.
| Stack Type | Patterns Met | Common Gaps |
|---|---|---|
| Early-stage wrapper (model API + system prompt) | 0-1 | No memory, no skills library, no sandboxing |
| LangChain / LangGraph production stack | 2-3 | Memory is operator-configured, skills are static, usually single-surface |
| CrewAI / AutoGen multi-agent | 2-3 | Subagent isolation varies, memory rarely agent-curated, single-surface |
| Claude Code / Cursor (dev-focused) | 1-2 | Single surface, memory is project-scoped not agent-curated, skills operator-managed |
| Hermes Agent | 5 | Newer ecosystem, self-hosted setup required, steeper learning curve |
One caveat, in the interest of honesty: this checklist is built around patterns Hermes implements well, so it scoring a 5 is partly by construction. Treat the numbers as directional rather than a benchmark, and the competitor rows as a rough read rather than a verdict. The point isn't to rank vendors. It's to surface your own gaps.
The question isn't whether you hit 5. It's whether the gaps are decisions you made or gaps you haven't reached yet.
Why Architecture Beats the Model in Your AI Agent Stack
The model is becoming a commodity. Frontier models from OpenAI, Anthropic, Google, and Meta each have strengths, and all of them improve every 6 to 12 months. You can swap them. The architecture doesn't swap as easily, and that asymmetry is the whole game.
If your stack lacks agent-curated memory, a better model gives you a smarter agent with no memory. If your skills are static, a more capable model still runs the playbooks you wrote six months ago. If your agent is single-surface, a faster model still lives in the one terminal you have to go find. This is why churn alone doesn't fix anything: teams rebuild the same shape repeatedly.
The abandonment data makes the point bluntly. S&P Global's 2025 Voice of the Enterprise survey found enterprise AI project abandonment jumped from 17% in 2024 to 42% in 2025, with 46% of projects dying between proof of concept and production. The teams that compound AI performance aren't chasing model releases. They're building stacks that improve between model upgrades.
What to Do With This
You don't need to rebuild your stack tomorrow. You do need to know where it stands. Run this in three steps.
- Score your current setup against the five patterns. Write down which ones you've actually implemented versus which ones you've assumed your tools handle.
- Pick the one gap creating the most friction. Memory loss between sessions and single-surface access are the two most common pain points I see.
- Research the tooling for that gap. MemGPT/Letta for memory. LangGraph for subagent isolation. e2b or Docker for sandboxing. Hermes Agent if you want a working reference implementation of all five together.
The checklist doesn't require a full rebuild. It requires honesty about where you are.
The Bottom Line
Hermes Desktop is worth studying not because it's a definitive answer to every AI infrastructure problem, but because it made visible a set of architectural decisions most teams keep deferring. The five patterns aren't proprietary to Nous Research. They're the direction the field has converged on for two years.
The gap between teams paying for AI and teams compounding it comes down to how many of these patterns they've actually implemented. Score yourself honestly. That's the whole exercise.
Frequently Asked Questions
What is an AI agent stack?
An AI agent stack is the full set of components that let an AI agent operate: the model, plus memory, skills, subagent orchestration, sandboxed execution, and the surfaces where you interact with it. The model is one layer. The architecture around it determines whether the stack compounds in value or just adds cost.
Why do most AI agent projects fail?
Most fail on architecture, not model quality. Gartner expects over 40% of agentic AI projects to be canceled by 2027, and S&P Global found 46% die between proof of concept and production. The common causes are missing memory, static skills, single-surface access, and no clear execution boundary.
Is a bigger context window the same as agent memory?
No. A context window is working memory for a single session and it fills up. Real memory is persistent state the agent writes and retrieves across sessions. Atlan notes that long sessions can start contradicting themselves as older context drops out, which a larger window delays but does not solve.
How many of the five patterns should my stack have?
Most production stacks score 2 or 3 of 5, which is a reasonable baseline. The goal isn't a perfect 5. It's making each gap a deliberate decision rather than an accident, then closing the one gap causing the most friction in your actual workflows.
Building an AI agent stack for clients or your own operations? The five-pattern audit is the starting point I use with every new engagement. Book a diagnostic call to run it against your specific setup, or grab the full AI Agent Stack guide to go deeper on each pattern.