What plain Hermes does on its own
Before pairing, it helps to know what Hermes brings by itself. Hermes Agent is Nous Research's open-source terminal agent, and its core is less about writing code than about running work:
- • Self-improving skills — reusable capabilities it can create and refine as it works. (We cover these in depth in Hermes Agent Skills.)
- • A cron scheduler — tasks described in natural language that run unattended on a schedule.
- • Persistent memory — cross-session recall so work compounds instead of resetting each run.
- • MCP support — connect any MCP tool, and expose Hermes's own tools to other hosts.
- • Multi-provider model routing — swap the backing model without touching your setup (see which LLM to run with Hermes).
That's plenty for ops, research, and glue work. What plain Hermes is not optimized for is heavy, interactive code generation — which is exactly the gap a coding runtime fills. For the full picture of Hermes itself, start with our Hermes Agent explainer and the official docs.
Why pair Hermes with a coding agent
The pairing is an instance of a pattern the whole field is moving toward: separating the orchestrator (what to do, when, and with what memory) from the agent runtime (the thing that actually edits and runs code). As Addy Osmani puts it in The Code Agent Orchestra, teams are shifting from a "conductor model" — one agent, one synchronous session — to an "orchestrator model" where a coordinator plans and specialized agents work with their own context windows. Hermes is a natural orchestrator; a coding CLI is a natural runtime.
Hermes + Claude Code: the standout pairing
Hermes ships an official bundled skill for Claude Code (under autonomous-ai-agents/claude-code), so this isn't a hack — it's a supported path. Hermes delegates a coding task to the Claude Code CLI, which reads files, writes code, runs shell commands, spawns its own subagents, and manages git — then hands the result back. The skill documents two modes:
- • Print mode (
claude -p) — a one-shot task that returns a result and exits, with no interactive prompts. This is the clean path for automation and CI: "fix the failing test", "add error handling to all API calls", run it, read the output. - • Interactive PTY via tmux — a full conversational session Hermes drives through a tmux pane, for multi-turn work where it needs to send follow-ups and watch progress in real time.
There's also a one-command import: hermes import-agent claude-code maps your existing Claude Code setup — CLAUDE.md instructions, permission allowlists, MCP servers, skills, and memories — into their Hermes equivalents, so an established Claude Code workflow carries over rather than being rebuilt. And because Hermes can run each delegated job in an isolated git worktree, multiple coding tasks can proceed in parallel without stepping on each other. In the split, Hermes plans, schedules, and remembers; Claude Code writes and runs the code. If you want the coding-agent side of that equation in context, our ranked guide to AI coding agents covers where Claude Code fits.
Get the weekly AI engineering brief
Agents, orchestration, RAG, and the tools worth using — one practical email a week. Plus the free roadmap PDF.
By subscribing you agree to receive emails from AI Engineer Insights. Unsubscribe anytime. See our Privacy Policy.
Hermes + DeepSeek: routing a cheaper brain
Because Hermes routes any model provider, the backing model is a separate decision from the runtime. DeepSeek is a supported provider, which makes it a common choice for the orchestration loop specifically: the planning, decomposition, and check-in steps don't always need a frontier model, so routing a cheaper DeepSeek model — including the R1 reasoning model for multi-step planning — and reserving a stronger model for the hard coding step is a practical cost lever. The general principle holds across providers: match the model to the step, not the whole job. (Exact pricing and benchmark numbers move fast and vary by model — check current provider docs rather than trusting a figure in any blog, including this one.) Our Hermes models guide covers provider setup, and the cost patterns of small vs frontier models are worth understanding before you route.
Beyond Claude Code: Codex, OpenCode, and computer use
Claude Code is the headline pairing, but Hermes ships the same kind of bundled skill for several runtimes, so the orchestration layer stays put while you swap the executor:
- • Codex CLI — OpenAI's coding agent, delegated with the same print-mode/PTY pattern.
- • OpenCode — an open-source, bring-your-own-key runtime for teams that want model and cost control.
- • Computer use — for work that isn't a code edit at all: driving a real browser or desktop to fill forms, scrape, or run checks.
The takeaway: "Hermes + X" is a family, not a single integration. Keeping planning and execution separate is what lets you change your mind about the runtime later.
The orchestrator + agent-runtime pattern (and its rules)
This pairing works for the same reasons multi-agent coding works in general, and it inherits the same hard-won rules. Drawing on Osmani's write-up and Microsoft's AI agent design patterns:
- • Specialization + isolation beats one big agent. Separate context windows for planning vs coding keep each focused and reduce cross-contamination.
- • Verification is the bottleneck, not generation. The orchestrator's real job is to gate output — tests, review, a human check — not just to hand off more work.
- • Keep the coordinating set small. Guidance across these sources converges on a handful of agents, with step limits to prevent loops.
- • Persist accumulated learning. A curated instructions file (CLAUDE.md / AGENTS.md) plus Hermes's memory is what makes runs compound instead of repeat.
Which pairing for which job
| Setup | Best for | Why |
|---|---|---|
| Plain Hermes | Ops, scheduling, research, glue | Skills, cron, memory, and MCP tools — no coding runtime needed for non-code automation |
| Hermes + Claude Code | Autonomous coding, refactors, PRs | Hermes plans and schedules; Claude Code edits, runs, and manages git as the executor |
| Hermes + DeepSeek | Cheap orchestration & planning | Route a low-cost model (incl. the R1 reasoning model) for the planning loop; save the strong model for hard steps |
| Hermes + Codex / OpenCode | BYO-key or alt-runtime coding | Same delegate pattern, different executor — swap runtimes without changing the orchestration |
| Hermes + computer use | Browser / desktop tasks | Drive a real UI for work that isn't a code edit — form-filling, scraping, checks |
Tips for running Hermes as an orchestrator
- Start with print mode. One-shot
claude -pdelegation is the simplest, most predictable integration; reach for tmux only when you genuinely need multi-turn. - Import, don't rebuild.
hermes import-agent claude-codecarries your CLAUDE.md, permissions, and MCP servers over so the runtime behaves the way you already trust. - Isolate parallel work in git worktrees. It's the clean way to let multiple delegated tasks run at once without collisions.
- Route models by step. Cheap model (e.g. DeepSeek) for orchestration, strong model for the hard coding — the split is where the cost savings live.
- Gate what ships. Keep tests and a human review between the runtime's output and anything that reaches production; print mode skips permission prompts by design.
- Mind autonomy risk. Unattended agents with shell access need tight tool scopes — see our Hermes security breakdown before going fully hands-off.
Frequently Asked Questions
Can Hermes use Claude Code?
Yes — Hermes ships an official bundled skill for it (autonomous-ai-agents/claude-code). Hermes delegates a coding task to the Claude Code CLI, which reads files, writes code, runs shell commands, and manages git autonomously, then returns the result. There are two modes: print mode (a one-shot 'claude -p' call, best for automation) and an interactive tmux/PTY session for multi-turn work.
What does 'Hermes as an orchestrator' mean?
It means using Hermes as the persistent brain — planning, memory, scheduling, and model routing — while a specialized agent runtime like Claude Code does the actual coding. Hermes decides what to do and when (including on a cron), delegates the code-writing step to the runtime, reads the result, and continues. It's the orchestrator + agent-runtime split: one layer plans, another executes.
Why not just use Claude Code alone?
Claude Code is excellent at the coding step but is session-bound and interactive by design. Pairing it under Hermes adds what a single interactive session doesn't have on its own: unattended scheduling (cron), persistent cross-run memory and skills that compound, task decomposition and dispatch, isolated git worktrees for parallel work, and model routing so a cheap model can handle orchestration. If you only need one interactive coding session, Claude Code alone is simpler; the pairing pays off for autonomous, repeated, or parallel work.
Can Hermes run DeepSeek?
Yes. DeepSeek is a supported provider in Hermes, so you can back the agent with a DeepSeek model (including the R1 reasoning model) via the DeepSeek API or an aggregator. A common motivation is cost: routing a cheaper model for the planning/orchestration loop and reserving a stronger model for the hard coding step. Exact pricing and quality vary by model and change often — check current provider docs before committing.
Does Hermes only work with Claude Code?
No. Hermes ships bundled autonomous-agent skills for several runtimes — Claude Code, Codex CLI, OpenCode, and computer use — under the same delegate pattern. You can swap the executor without changing the orchestration layer, which is one of the advantages of keeping planning and execution separate.
Is it safe to let Hermes drive a coding agent unattended?
Treat it with the same caution as any autonomous agent. Print-mode delegation skips interactive permission prompts, which is what makes it good for automation but also means the runtime can act without a per-step confirmation. Scope tool permissions tightly, run in an isolated git worktree, keep a human review gate on anything that ships, and avoid fully-permissive 'yolo' modes for work that touches production.