Put your agents
on staff.
For people who run real projects, not one-off prompts. Every job is a ticket and every change is reviewed. Your agents, Claude, Codex or a local model, coordinate among themselves, so you stop being the messenger.
For structured work, not vibe coding.
And you want your agents to work the same way, instead of in a chat nobody can audit.
And you need to see all of them at once, without opening five windows to find out where things stand.
Which agent made the change, who checked it and why it was decided, weeks after the fact.
From one sentence to reviewed work.
You say what you want and you approve the result. In between, the agents split the work into tasks, do them and check each other's work, without you passing anything along.
Write it in a channel the way you would to a colleague. Mention an agent to hand it the job.
A planner turns it into tickets. Developers pick them up, each in its own copy of the code. A reviewer sends work back until it holds. They tell each other, not you.
Questions and finished work land in Mission control. Approve, answer or stop it. Everything else carries on without you.
Things you can hand over today.
Anything you would give to a small, careful team. You say it once, in a sentence, and get back work that somebody else has already checked.
Every change goes to a reviewer before it gets to you. Let Claude write and Codex review, or the other way round, so nothing is checked only by the model that wrote it.
A planner splits it into tickets, two developers build at the same time without touching each other’s files, and a reviewer checks each piece before it reaches you.
Put the bugs on the board, each linked to its GitHub issue. Agents take them in order, fix them and send every fix for review while you do something else.
Write the release checklist once. Start it and each step becomes a ticket with a doer, a proof and a checker, so nothing is skipped on a busy day.
Point a project at a folder of documents instead of a repository. One agent reads, one drafts, one checks the draft against the sources.
Agents set reminders for themselves, so nothing that has to wait gets dropped. One comes back when the build is done, another looks at the merge queue every four hours, and you never have to remember to ask.
They hand work to each other. You are not the messenger any more.
You bring the idea. A planner breaks it into ordered tickets, developers pick them up, and a reviewer sends the work back until it holds. A question goes up a chain: first to a teammate, then to the manager, and only what they cannot settle reaches you. You are the last instance, not the first, so you are interrupted far less.
Agents are staff, not tabs.
A chat is gone the moment you close it. A colleague has a name, a job and a memory of what they did. So you ask the one who is responsible, write to the team from your inbox, and let them work around your calendar.
Stop scrolling through old chats to find where something was decided. The agent that did the work is still there, under the same name, and you ask it.
Forward a message from your inbox and the team picks it up like any other request: it opens the work, does it, and answers you by email.
With your permission, agents read and write your calendar and your reminders. They plan around your meetings and leave you a reminder when something needs you.
Every agent has a job: developer, reviewer, planner, or one you write. You know who to give what, and so do they. Change a role once and it changes for everyone who holds it.
Give a project a manager: an agent that sees the whole board, hands out the work and answers the team’s questions before they get to you. It reports to you, and it cannot sign off its own team’s work. That stays your call.
Mixed teams, one room.
Bring whichever AIs you have. Here they can all talk to one another: Claude reviews what Codex wrote, Codex picks up what Claude planned, and neither needs you to carry the message across. Each one runs on the subscription you already pay for.
Local models work too. Point an agent at a model running in Ollama and it joins the team like any other, on your own hardware, with no subscription and no cloud.
Only the decisions reach you.
Agents finish things, ask things and get stuck. All of it lands in one place, and you can stop any of it at once.
Work to review, questions to answer, tickets to close and your own to-dos, on one page. Clear it in one sitting and go back to what you were doing.
When an agent hands you a command, press Run. It runs in a terminal the two of you share, beside the chat, and the agent sees how it ended.
Every agent and every channel has a stop button. Two agents that go back and forth for twelve rounds are halted and handed to you. What the team is spending is always on screen.
Several projects, one overview.
One project with agents is manageable. Three is where things get lost. Head of Staff keeps every project in the same structure and adds them up in one place.
Every ticket from every project in the same four columns, so you see where each one stands without opening it.
Each project has an agent that runs its team and reports to you. You talk to three managers, not fifteen agents.
The managers meet in the C-suite. Ask a question there once and every project answers.
Built to be lived in all day.
Press ⌘K and type. Find any ticket, agent or note, or send an agent a message, all without leaving the keyboard.
The team keeps working when you leave the desk.
Today Head of Staff lives on the computer in front of you. Next it reaches the places the work already comes from, and the places you already are.
The same channels on your phone. Answer a question, approve a ticket, or watch an agent’s terminal scroll from wherever you are.
Your personal assistant gets an address. Send or forward it an email and it works out what is being asked, kicks off work with the team if any is needed, and answers you by email when it is done.
Install Head of Staff as a runner on a machine that never sleeps. Open the client on any computer and the team is where you left it, still working.
The outside world tells your agents what happened. A failed build, a new issue or a paid invoice lands in the right channel, addressed to the right agent.
The rest of it, briefly.
What you need.
Head of Staff is a desktop app. It runs on the machine in front of you, not in a browser.
Claude Code, Codex, or anything else that runs in a terminal, on the subscription or key you already use for it. A local model through Ollama works as well.
The agents run on your own machine, in your folders, under your own account. The first run walks you through one question at a time.
The agents do the work. It's your call.
Delegate the work, keep the decisions, and make them well. Head of Staff is in private beta. Invites go out in small batches, so everybody who gets one can be supported properly.