Hermes Agent is Nous Research's open-source autonomous agent framework with persistent learning, subagent delegation, and five sandbox backends. We're the team that deploys it, hardens it, and runs it for production.
Trusted by teams shipping production software
We’re a senior engineering team that deploys Hermes Agent into production. We pick the right sandbox backend for your risk profile, harden the runtime, build the custom skills your work needs, set up observability, and stay on to operate the system. Credit where it’s due: Hermes is the work of Nous Research — we’re the team you hire to make it run reliably in your environment.
Autonomous agents with shell access are dangerous.
Hermes can execute arbitrary code. A bad deployment lets an autonomous agent do real damage fast — the five sandbox backends exist for a reason, but only if they're configured right.
Self-hosting is a real ops burden.
MIT-licensed and self-hostable is great until someone has to deploy it, harden the runtime, patch it, and watch it. That someone usually isn't on your team yet.
Skill generation needs guardrails.
Hermes learns and writes its own skills. Without review policies and audit, you've got an autonomous system teaching itself things nobody signed off on.
The full lifecycle, with emphasis on the parts that matter for production autonomous agents — sandboxing, skills, and ops you can actually trust.
- 01
Sandbox selection + config
We pick from local / Docker / SSH / Singularity / Modal based on your risk tolerance, infrastructure, and use case. Container hardening, network isolation, resource limits — all configured.
- 02
Deployment topology
Self-hosted on your infra, Modal for managed sandbox, on-prem for compliance, HPC via Singularity. We match the deploy to your ops model.
- 03
Multi-platform integration
Wire up Telegram, Discord, Slack, WhatsApp, Signal, Email, CLI — the platforms where your team already works.
- 04
Custom skills + tools
Build the skills Hermes generates and the tools it calls. Custom integrations to your systems, internal APIs, knowledge bases.
- 05
Subagent design
Configure subagent delegation patterns: when to spawn isolated subagents, what context they get, how they report back. Critical for long-running and risky work.
- 06
Persistent learning policies
Hermes learns and self-generates skills. We configure what it's allowed to learn, what skills get auto-approved vs. reviewed, and how learning is audited.
- 07
Natural-language cron
Configure the autonomous scheduling layer for reports, briefings, backups, monitoring. The boring-but-powerful side of Hermes.
- 08
Observability + audit
Every action logged with full traces. Skill-generation events flagged. Cost tracking per agent and per subagent.
- 09
Security review + ongoing ops
Penetration scan of the deployed agent, ongoing patching, model upgrades, runtime monitoring. Production agents need production ops.
Production autonomous agents fail when teams deploy first and threat-model never. We do it in the right order.
Discover + risk model
1 week. Use case, threat model, compliance constraints, ops capacity. We pick the sandbox backend and deployment topology here.
Deploy + harden
1–2 weeks. Runtime up, sandbox configured, platforms wired, security baseline established.
Custom skills + tools
2–4 weeks. Build the integrations Hermes needs to do real work in your environment.
Pilot + audit
1–2 weeks. Real use under observation. We review every learned skill and every autonomous action before broader rollout.
Roll out + run
Ongoing. Training, gradual rollout, ongoing ops retainer. Production autonomous agents need someone watching.
The Hermes runtime, the sandbox backends, and everything we wire around it to make it production-grade.
- HXhermes CLIAgent runtime
- HShermes setupProvisioning
- SGSkill generatorPersistent learning
- LOLocalIsolation
- DKDockerIsolation
- SSHSSHIsolation
- SYSingularityHPC isolation
- ModalManaged sandbox
- TGTelegramMessaging
- DCDiscordMessaging
- SLSlackMessaging
- WAWhatsAppMessaging
- SGSignalMessaging
- @EmailMessaging
- $_CLITerminal
- Claude (Opus/Sonnet/Haiku)Reasoning model
- GPT-4o / o1Reasoning model
- Open modelsSelf-hosted LLM
- WSWeb searchTool
- BABrowser automationTool
- IMVision / Image genTool
- CRNatural-language cronScheduling
- ModalGPU compute
- Cloudflare WorkersEdge runtime
- CLAWS / GCPCloud
- OPOn-prem / HPCSelf-hosted
- {}Action logsTracing
- SASkill auditReview
- $Cost trackingBudget
- STSubagent tracesTracing
“They had Hermes deployed, sandboxed, and running our ops in under a month — with audit trails we actually trust.”
Deploy
Hermes deployed on your infra with the right sandbox backend, platforms wired, security baseline in place. No custom skills.
- Deployment + sandbox config
- 3–5 platforms
- Security baseline + audit
- Team training
Arlo
Our own product. An MCP connector that lets Claude query 100+ analytics platforms in natural language. Built for agencies managing dozens of clients. The same tool-access and isolation patterns we apply to Hermes deployments.
Agency ERP
Autonomous agents embedded in our own ERP for client triage, scope review, and project status reporting — sandboxed, audited, and operated exactly the way we run Hermes for clients.
Hermes Agent is an open-source autonomous AI agent framework by Nous Research, released under the MIT license. It runs as a self-hostable system across Telegram, Discord, Slack, WhatsApp, Signal, Email, and CLI. Key features: persistent learning with automatic skill generation, subagent delegation (isolated conversations and execution environments), natural-language cron scheduling, and five sandbox backends — local, Docker, SSH, Singularity, and Modal.
No. Hermes Agent is built by Nous Research. We're an implementation partner — the team that deploys, hardens, and operates Hermes for businesses that want production use of the framework but don't want to manage the deployment, sandbox configuration, custom skill development, and ongoing ops themselves.
Hermes Agent's five sandbox backends (local, Docker, SSH, Singularity, Modal) let you isolate agent execution at different security levels. That's a big deal for production deployments — you don't want autonomous agents executing arbitrary shell commands on your primary infrastructure. We pick the sandbox backend per use case and configure container hardening.
Subagents are isolated execution environments where a parent agent spawns a child to handle a task in a separate context. In practice: long-running research tasks, parallel work on independent problems, or risky operations isolated from the main agent's context. Very useful when you want concurrency or strong isolation between tasks.
Both are open-source autonomous agent frameworks with similar multi-platform reach. Hermes Agent leans developer-oriented with stronger sandboxing (5 backends) and subagent delegation — better when you need isolation and concurrency. OpenClaw leans integration-rich with a community marketplace (ClawHub, 50+ pre-built integrations). We help clients pick — see /comparisons/openclaw-vs-hermes-agent for the full breakdown.
Yes — that's a strength. Hermes is self-hosted by design. We deploy it on Modal for the sandbox-as-a-service path, on your own Docker infra, via SSH to existing servers, or on Singularity for HPC environments. We'll match the deployment to your compliance and ops constraints.
A few questions about the project so we come prepared — then we'll set up a short call to dig in.