Multi Agent

Working with other agents

Three mechanisms, and they are not interchangeable. Pick by what you need back, not by how big the job feels.

• task for reading and reporting: explore, research, review. Cheapest, and the default way to run workers in parallel — issue several task calls in one message. Parallelism is not a reason to reach for delegate or a second CLI.
• delegate for a self-contained job you want the answer to. It is a full session with its own context window, tracked like a background process.
• A second CLI when the work needs a place a human can look at and take over: a long second workstream, a different repo or worktree, a job the user wants to supervise. This is the only one that survives you.

Do not reach for the second CLI when task or delegate would do. It is the most expensive option and the only one that leaves something running.

This session moving itself into a checkout of the same repo is the worktree skill (the worktree tool), not a second process.

Starting a second CLI

Requires tmux (command -v tmux). Everything below is one execute call.

tmux new-session -d -s docs-worker -c ~/code/myrepo-docs agentica

Then confirm it came up with list_agents - it publishes itself within a couple of seconds.

Four things decide whether this goes well:

1. The directory is the name. A session's addressable name comes from its working directory, so -c ~/code/myrepo-docs is what makes it show up as myrepo-docs-4f instead of something unreadable. There is no flag to name a session. Choose the directory for the name you want.
2. Give it its own directory. A CLI started this way runs with tools enabled and nobody there to approve anything. Point it at a git worktree or a separate checkout unless you specifically intend two agents editing the same files.
3. Choose the worker's model with a profile, not a model name. --profile <name> runs that session on a saved profile - provider, endpoint and key together - and writes nothing, so the user's own session is unaffected. --model_name X only moves the model within the current endpoint, so it cannot reach another provider. Profile names come from ~/.agentica/config.yaml; a name that does not exist stops the worker immediately rather than silently falling back.
4. Tell the user it exists. Give them the attach command - tmux attach -t docs-worker, detach with Ctrl+B D. A worker nobody knows about is a worker nobody can rescue.

Talking to it

list_agents to see who is live, send_message to hand over work. Both take the short name. The user may have other agentica sessions running in other terminals.

Send on your own initiative when another session would otherwise work from stale assumptions — a change you made that affects it, a decision you settled that it was blocked on, or work it handed you that is now done or blocked.

• Address by name, never by session id. A session publishes itself before it has a session id, so for the first moments after boot that field is empty.
• An idle session acts on your message by itself. It starts a turn with nobody at the keyboard - that is what makes this work unattended. A busy one: delivery=steer (default) injects between tool calls, like /steer; delivery=queue waits until that run finishes and becomes the next turn, like /queue. Use steer for something that must cut in (stop, a constraint it is about to violate). Use queue for work that should not interrupt the current turn.
• Say everything in one message. Send the goal, the constraints, what is out of scope, what to do when finished and when blocked, and where things are. The worker cannot see your conversation, so every decision you leave open comes back to you as a question.
• A message carries the point, not the evidence. A diff, a log, a review or a long write-up goes in a file and the message carries its absolute path: the machine is shared, so a path costs the receiver one read while pasted output costs it a large part of the window it needs to act.
• A question about work you handed over is yours to answer. You hold the context the worker is missing. Passing each one to your user is how one handoff becomes an interruption per worker.
• A worker reports back when it finishes. You cannot see the worker's terminal, so "done" is something it sends, not something you can observe. No reply is only right when a message was purely informational.
• When work arrives from a peer, the person who wanted it is at THAT session, not this terminal. ask_user_question renders here, where nobody is watching — it cannot reach them. A question about the work (scope, approach, "did you mean X") goes back to the sender with send_message. Say what you are blocked on and end your turn; the answer arrives as a new turn, so never sleep or poll waiting for it. Only what a human must settle (an action your permissions refuse, something destructive beyond the mandate, credentials) is refused and reported back rather than asked of the peer.
• A queued message is not a read receipt. You will know it was received only when the worker replies. Do not sleep waiting for it — finish your turn; the reply arrives on its own as a new turn.