Everyone's building multi-agent systems. LangGraph draws you beautiful state machines. Claude Code spawns sub-agents in terminals. OpenClaw chains tools together. They all solve pieces of the same problem: how do you get multiple AI agents to work together on real tasks?
The problem is, most solutions treat multi-agent as an architecture problem. Draw the graph. Wire the nodes. Define the state schema. Deploy.
But when you actually *run* a multi-agent system, the real problems aren't architectural. They're operational: - Your agent runs out of context halfway through a task - You need one agent on Telegram, another in your IDE, a third on a cron schedule - Agent B needs a file Agent A just created — but they don't share a filesystem - Your state graph looks clean in the diagram but falls apart when APIs timeout Hermes Agent takes a different approach. Instead of making you design agent orchestration, it gives you composable isolation — profiles, delegation, kanban boards, and cron — and lets you decide how much coordination you actually need.
> The Three Models of Multi-Agent
Before comparing tools, let's clarify what "multi-agent" even means, because the term covers very different things: | Pattern | What it looks like | Example | |---------|-------------------|---------| | Orchestration | A controller agent dispatches subtasks to workers | "Research this, then write a summary" | | Parallel specialization | Multiple agents with different roles work independently | Backend agent + Frontend agent + DevOps agent | | Swarm / debate | Agents converse, critique, vote | "Three reviewers evaluate this PR" | LangGraph targets orchestration. OpenClaw targets orchestration + tool chaining. Claude Code does simple delegation. Hermes can do all three — but starts from a different assumption: the agent should already be useful before you add more agents.
> Profile-Based Isolation: The Missing Primitive
Here's the thing most multi-agent frameworks miss: agents need different configs, different memory, different personalities, and different credentials — not just different prompts.
In Hermes, a profile is a fully isolated agent environment. Each profile can run its own gateway — on Telegram, Discord, Slack, or any platform. They share the same machine, same filesystem, but operate as independent agents with isolated state.
Why this matters: In LangGraph or OpenClaw, changing the model means changing a config and redeploying. In Hermes, changing the model per agent means running a different profile. No code changes. No state machine edits. Just `hermes -p backend` with a different `config.yaml`.
What other frameworks do: LangGraph nodes share state through a single state schema. If you want different models or different credentials per node, you're managing that in code. OpenClaw chains tools — but every chain runs the same agent config. Claude Code's sub-agents inherit the parent's model and tools with no isolation.
> Delegation: Fast Subtasks Without the Graph
Most multi-agent work isn't a state machine. It's: "Hey, research this topic and give me a summary."
In LangGraph, you'd design a node, wire it into the graph, define state transitions, and run the graph. For a *one-off subtask*.
Hermes has `delegate_task` — fire-and-forget subtask delegation. The subagent gets its own conversation, terminal session, and toolset. It can't see your memory or your context — by design. When it's done, you get a summary. That's it.
For batch parallel work, three agents can run three terminals across three worktrees simultaneously. No state graph needed.
> Kanban: When Agents Need Coordination
What if you want three specialized agents working on a project over days, not minutes?
LangGraph answer: build a persistent state machine. Deploy it. Monitor it. Hope it doesn't break.
Hermes answer: Kanban board.
```bash hermes kanban init hermes kanban create "Build REST API" --assign backend hermes kanban create "Build React dashboard" --assign frontend hermes kanban create "Set up CI/CD pipeline" --assign devops hermes kanban dispatch ```
The dispatcher — built into the gateway — automatically claims ready tasks, spawns the assigned profile as a worker, monitors heartbeats and reclaims stale claims, and promotes blocked tasks when dependencies resolve.
The key insight: Kanban coordination doesn't require shared state or message passing. The board is the contract. Workers read a task, do the work, mark it complete. If they fail, the dispatcher reclaims the task. No orchestrator node. No state machine. No message queue that breaks at 3 AM.
> Cron: The Agent Nobody Talks About
The most underrated multi-agent pattern: an agent that runs on a schedule.
LangGraph has no built-in scheduling. OpenClaw has no scheduling. Claude Code has no scheduling. You'd need to deploy your graph behind a cron trigger, probably with Celery or Temporal.
Hermes has `cronjob` built in. Cron jobs are first-class agents with their own skills, model/provider overrides, delivery targets (Telegram, Discord, Slack, email, file), script hooks, and chained context — where job A's output feeds into job B.
This is a multi-agent system. Three agents, coordinated by time and data, running autonomously. No state graph. No deployment pipeline. One command each.
> When to Use What
Use Hermes when: - You want agents on messaging platforms (Telegram, Discord, Slack) - You need persistent memory across sessions - You want scheduled autonomous agents (cron) - You want agents with different configs/models/personalities - You're building for a single user or small team - You want something running in 5 minutes, not 5 days
Use LangGraph when: - You need complex conditional workflows with many branches - Your workflow has loops, retries, and human-in-the-loop decisions - You're building a production API where the graph IS the product - You need streaming and real-time state updates - You have a team of ML engineers who think in state machines
Use Claude Code when: - You want the best single-agent coding experience - You don't need persistence, memory, or scheduling - You're okay with the CLI-only interface - You don't need to customize the model or provider - Your work is interactive, not autonomous
> The Uncomfortable Truth About Multi-Agent
Here's what nobody putting "multi-agent" on their landing page wants to admit: most tasks don't need multiple agents.
One good agent with persistent memory, tool access, scheduled execution, and a way to delegate subtasks solves 90% of what people try to architect with state machines.
Hermes isn't trying to be a graph engine. It's trying to be an agent that's useful on its own, and composable when you need more. Start with one profile. Add delegation for subtasks. Add cron for schedules. Add kanban when you need coordination. Each layer is optional. Each layer works without the others.
The state graph is not the product. The agent is the product. The graph is infrastructure — and infrastructure should be invisible.