Agent vs Sub-Agent vs Async: What Is the Difference?

I keep getting asked the same question: "what is an asynchronous agent?"

Here is the honest answer. There is technically no such thing. Those are tasks more than they are agents. But I included async in this comparison anyway, because that is exactly where the confusion lives, and you cannot clear it up without putting all three side by side.

This one is meant for beginners. If it is beneath you, no need to read the rest. If you want clarification between the three, this is for you.

The Three-Word Version

Agent is ownership. Sub-agent is isolation. Async is lifetime.

Those are three different operating choices, not three tiers of the same thing. Said another way: profiles own identity, sub-agents split context, async controls lifetime.

Or, in the phrasing my own agents gave me when they helped prep the visual prop for this video: an agent profile owns identity and judgment, sub-agents split fresh context specialist work, and async chooses how long the work lives.

You are going to notice repetition in this article. That is deliberate. I said the same thing three ways in the video too, because the point is to engrain it, not to be clever.

What Each One Actually Is

An agent is a full Hermes profile with its own identity. Your default profile is an agent. New profiles also become agents. Each profile owns its own config, Soul MD, memory, sessions, skills, crons, tools, and state.

A sub-agent is a focused child worker that your agent briefs and spins up. It starts fresh with only the parent agent's goal and context. It gets its own conversation, its own terminal session, its selected tool sets, and it hands a final summary back to the parent that called it.

Async, aka a background task, is agent work that continues outside the live turn. Commonly that is the /background command. It is also crons you pre-schedule, and it is Kanban profile workers that keep work moving outside the live session you have open with your primary profile, whether you are chatting through Telegram, TUI, Discord, Slack, and so on. Kanban dispatches durable named profile workers that run while you keep talking to your agent.

Five Questions, Asked of All Three

The whole distinction comes down to identity, context, and lifetime. Here is the interrogation.

### Does it have its own soul?

Agent profile: Yes. Each profile has its own Soul MD, config, memory, sessions, skills, crons, tools, and state tied to that profile.

Sub-agent: No. It is a child run, not a new profile.

Async: Not by itself. Background inherits your current setup. Cron and Kanban run through profiles, so depending on which profile you scheduled the task from, it inherits the context it needs to complete the job.

### Can it see the current chat?

Agent profile: The active profile session sees its own conversation and objective.

Sub-agent: No. It only gets the goal and context the parent agent passes it.

Async: It depends on the lane. Background prompt, scheduled prompt, terminal process, or board task.

### Do they run in parallel?

Agent profile: Yes. Profiles run independently as separate commands or gateways. If you have profile one, two, and three with their own workspace and gateway, they run side by side.

Sub-agent: Yes, and that is the entire benefit. Delegate task fans out concurrent child agents. Sub-agent swarms, where you run an insane number of parallel tasks, are a topic for a later video.

Async: Yes, through scheduled, background, or board-based execution.

Great benefits, great similarities here, but not the same.

### Do they live outside the current turn?

Agent profile: The profile and its sessions persist.

Sub-agent: No. Delegate task is synchronous to the parent turn, and children can be canceled on interrupt.

Async: Yes. Background, cron, terminal background, or Kanban profile workers give you durable work that keeps running as you continue prompting your agent.

That fourth question is the one people miss. Sub-agents run in parallel and still die with the turn. Parallelism is not durability.

Four Questions to Ask Before You Spawn Anything

This is the decision gate. It keeps profile agents as durable owners, gives child runs enough parent-passed context to succeed, and moves long work out of the fragile live turn.

• Does it need a durable role? Create or use a Hermes profile with its own soul, config, memory, sessions, tools, and state.
• Does it need parallel specialist thinking? Delegate bounded sub-agent tasks with exact parent-passed context.
• Does it need to survive interruption? Use background, schedule a cron, use terminal background, or schedule a Kanban task instead of delegating through your main profile, which would just spin up a sub-agent session.
• Do you need named agents to collaborate? Use Kanban profile workers, not an anonymous sub-agent swarm.

Good Versus Bad Delegation

Delegation fails when the parent abdicates ownership.

The bad pattern: Parent says "research this thing." The child gets no source list, no scope, no tools, no constraints, no return format. The team calls that child "a new agent" even though it has no profile and no soul. The main conversation sits waiting with no useful checkpoint. The final answer arrives with no evidence and no next action.

The good pattern: The profile agent owns the goal, identity, decision, and review gate. The sub-agent gets a narrow parent-passed packet and the smallest useful tool set for that specific task. Slow or interrupt-sensitive work moves to async infrastructure. Durable multi-agent work goes through Kanban profile workers. And every lane returns the same receipt: evidence, risks, files touched, and recommended next action.

The Three Contracts

Use these as checklists.

Agent profile contract: profile name, Soul MD, config, memory, sessions, tool boundary.

Sub-agent contract: parent-passed goal, context, tool sets, final summary.

Durable async contract: background, cron, terminal background, or Kanban task, plus a completion notice.

The Prompts

These are meant to be copy-paste and fill-in-the-blank, not copy-paste and done. What is nifty about them is that using them actually teaches you the difference between the three.

Create a profile: