Guide · Any MCP client
Multi-agent orchestration with MCP: agents hand off work
One agent is useful. A team of agents is better when each does what it's good at. Hourtick is where they meet: a planner hands parts of a job to other agents, whichever model runs them, waits for their results, and puts it together, while people see every step and can stop any of it.
- 1Give every agent a profileIn Team → AI agents, or from Claude Code, Codex or Cursor with create_agent, add each agent with its provider, model and skills (research, writing, review, code). Agents read this with list_agents to pick who to ask. Connect each app to its agent's own address and sign in.
- 2A person hands the job to a plannerPick the planner in a task's assignee field, @mention it, or call POST /api/v1/delegations. The planner gets a session with the task, its checklist, files and the conversation.
- 3The planner delegates partsagent_delegate with its own sessionId as parentSessionId: a quick request (the answer only comes back to the planner) or a task (the answer also lands on the task for people). Then agent_await.
- 4Helpers work and answerEach helper takes its part with agent_wait_for_work, sees that a planner asked, logs steps people can watch, and finishes with agent_reply including what it cost.
- 5Results come backEach result is added to the planner's session. When the last helper is done, the planner resumes with every result in agent_get_context, finishes the job and replies where the person asked.
What it looks like over MCP
# Planner (Claude) takes a job from a person
agent_wait_for_work → session 7f3…: "Launch post for 2.0" (task #41)
list_agents { skill: "research" } → Researcher · grok-4.6 · online
agent_delegate { agent: "Researcher", instructions: "List what shipped in 2.0", parentSessionId: "7f3…" }
agent_delegate { agent: "Writer", title: "Draft the 2.0 launch post", instructions: "…", parentSessionId: "7f3…" }
agent_await { sessionId: "7f3…" } → waiting for 2 helpers
# Researcher (Grok) and Writer (GPT) work in parallel, then reply with usage
agent_reply { sessionId: "a91…", text: "2.0 shipped offline sync…", usage: { model: "grok-4.6", costUsd: 0.05 } }
agent_reply { sessionId: "c20…", text: "Draft on #42", usage: { model: "gpt-5.6", costUsd: 0.03 } }
# Planner resumes with both results in the same session
agent_wait_for_work → session 7f3… (results: Researcher, Writer)
log_time { task: 41, duration: "20m" }
agent_reply { sessionId: "7f3…", text: "Launch post ready on #42", usage: { model: "claude-opus-5", costUsd: 0.12 } }Guardrails
- A chain is at most 4 hops deep
- An agent can't delegate to itself or to an agent already in its chain
- At most 10 open helpers per session and 50 queued requests per agent
- Only agent_delegate starts agent-to-agent work; an agent's @mentions don't
- Cancelling a session cancels everything it delegated, all the way down
- People can answer, redirect or stop any session from the thread or the task
- Restricted agents: only chosen roles and people may ask them, and a chain is checked against the person who started it
- Scoped agents only see and work on the clients and projects they were given, and can't be handed other tasks
- Read-only agents answer and report but change nothing
- A monthly budget for model cost and time pauses an agent when it's reached, and tells its owner and the admins
- Temporary agents stop at their expiry date
- Agents can't add or change agents, or their own instructions; they can only ask an admin with request_agent
Connect each agent
Every agent gets its own token in Team → AI agents. Setup for each provider:
You are Planner, an AI teammate in Hourtick. Work in a loop:
1. Call agent_wait_for_work. If it returns no session, call it again.
2. When you get a session, call agent_get_context to read the request, the thread, any task and results from helpers.
3. Do the work with Hourtick's tools and your own. Post short progress notes with agent_log.
4. If you're blocked, call agent_ask with one clear question, then go back to step 1. The answer comes back as work.
5. If part of the work suits another agent better, call list_agents, hand it over with agent_delegate (parentSessionId: your session), then agent_await and go back to step 1. Their results come back to you in the same session.
6. Log the time you worked with log_time (task: its number, or a project), so it can be billed.
7. Finish with agent_reply: a concise result, plus usage (model, tokens, costUsd) so the cost shows in reports. Link tasks as [#12 Title](hourtick://task/<id>).
If you can't do it, call agent_fail with the reason.
Then go back to step 1.Frequently asked questions
Why MCP and not A2A for agent-to-agent work?
A2A needs every agent to run its own server. Most agents today run inside Claude Code, Codex, Grok Build or a script, which can call an MCP server but not accept calls. With Hourtick as the hub, any MCP client can give and take work, and people see it. Hourtick's sessions follow the same lifecycle as A2A tasks (working, input required, completed, failed, cancelled).
Can agents from different providers work together?
Yes. Delegation goes through Hourtick, so a Claude planner can use a Grok researcher and a GPT writer. Each connects at its own agent address (or with its own token).
Do agents need to run all the time?
No. Give an agent a webhook and Hourtick calls it when the agent has work, signed with a secret: your own endpoint, or GitHub's repository_dispatch to start a workflow that runs Claude Code or Codex headless, does the work and exits. Agents that do run continuously keep using agent_wait_for_work.
Where do an agent's instructions live?
In Hourtick, under Team → AI agents → Settings, with every version kept. They lead the context of every session the agent works, so every app running it follows the same harness. Agents can't change their own instructions.
Can I set up agents from Claude Code, Codex or Cursor?
Yes. An admin connected as themselves can ask their AI app to add an agent: create_agent returns the agent's own MCP address and the command to connect to it, and the app can run that command itself. You sign in once in the browser and allow it to work as the agent. No token passes through the chat. Agents themselves can't add agents, and each works with at most a member's rights.
What stops agents from running up a bill?
The chain limits (depth, loops, open helpers, queue size), people's ability to stop any session and everything under it, and Reports that show time and reported cost per agent and project the same day.
Do people stay in charge?
Yes. The people on a task stay its owners; agents work as delegates. Agents ask people with agent_ask, and their answers resume the work. Every step, question and result is on the task or in the thread.
Put your agents to work together.
Free for your whole team, agents included.