From the Department Head Buried in Approvals to the CEO Who Gets Briefed — Building a Claude Code Manager Session#

2026-11-21

Along a corridor, small robots work at desks in rooms with open doors; at the end of the corridor, a person sits at a tidy table in a bright meeting room and receives a single sheet of paper from a robot, while in a dark room in the foreground a desk is piled high with file folders

There’s a scene you often see in TV dramas and films. A department head’s desk is stacked high with folders waiting for sign-off, and he turns through them one page at a time late into the night. The CEO is different. The CEO sits in a meeting room, listens to the department heads’ briefings, and decides only what truly needs deciding.

Lately I had been working like the department head. Thanks to AI agents, doing several things at once has become routine, and my editor always has several Claude Code sessions open. At work alone, ad operations checks, incident analysis, and batch job fixes each run in their own session. Responses pile up in every session, and I move from tab to tab reading them and giving the next instruction. Then one day it struck me that I wanted to try working like the CEO.

This essay is a record of that attempt. In July I wrote Context Switching in the Age of AI Agents and set a rule of “at most two interactive tasks at a time.” Honestly, I didn’t keep it. In October, The Main Agent Only Sees the Question and the Answer covered a setup where Claude Code is the main agent and Codex works like a subagent. That was the familiar pattern of a main agent handing work to subagents, with agents from two different companies wired together, and I still use it. This attempt is a different kind of thing. Instead of splitting work inside a session, I gave one session the role of manager and added a layer on top of the sessions that were already running. The Claude Code versions at the time of checking were CLI 2.1.319 and Cursor extension 2.1.328.

Keeping context means reading, and there’s too much to read#

Handing work to agents doesn’t mean I can let go of the context. I need to know whether the work is heading where I want, and I’m the one who decides what to ask for next. That means reading and understanding what the agents say. The problem is that the reading grows with every session I add.

Yet how much I need to read changes from moment to moment. If I already have the context, one line like “Shall I go with option D?” is enough to decide. If I’ve lost the thread, I need to read why option D came up and what the other options were. And the agent doesn’t know whether I have the context right now. So I can’t fix the response length in the instructions either. Hard-code “answer briefly” and I’m stuck when I lack context; ask for “explain in detail” and I drown in text the way I do now.

The sensible approach, then, is to set an order. By default, receive only the gist and what I need to decide, and unfold the details only when needed. Let the worker sessions keep writing in detail as they do now, and give the job of reading and condensing their output to a separate role. The full text stays in the worker session, so I can always go in and read it.

Manager's reportGist and approvals, 2 linesdetails NDetailed briefingBackground, status, optionsopen the tabWorker transcriptFull chat, ask directlyDecide here if you have contextThe reading load grows toward the right
If you have the context, stop at the first step; go one step deeper only when you don't.

Besides the reading load, there was one more problem. I didn’t know when to go to a session, either. The session tabs in the editor light up whenever a response comes out. But they light up just the same for an interim update like “I’ve asked a subagent for a first review and am waiting.” When I went over, it often wasn’t my turn yet. A response having arrived and it being my turn to decide were two different things.

Many of the approvals were obvious#

Handling worker sessions one by one, I noticed something. Many of the decisions the agents asked me to make were obvious from where I stood. They would ask whether to move on to the next step of a plan we had already agreed on, or ask about a choice that had only one answer under the criteria already set. An agent being careful is a good thing, but when these questions pile up, they become exactly that stack of folders on the department head’s desk.

Still, putting “just handle this kind of thing yourself” into the worker instructions felt like a burden, for three reasons.

  • I can’t define the scope in advance. What counts as obvious often only becomes clear as the work goes on.
  • It applies to every session at once. A single instruction line lands just the same in a session that handles ad settings where money is at stake.
  • When it goes wrong, it’s hard to trace. If each session judges on its own, there’s no single place to see who decided what, where.

So I decided to put the decision-making authority not in the workers but in a separate manager session. The workers keep asking as they do now, and the manager reads those questions, decides what falls within its authority, and instructs the worker. It’s like the delegated authority a department head uses to sign off on certain matters within their own remit. Only what the manager can’t decide comes up to me.

The scope of that authority isn’t wide from the start. You don’t give a newly arrived department head full signing authority on day one. The first few days are a probation period. The manager gives the workers no instructions at all and reports only proposals of the form “had I decided this myself, I would have done this.” I mark each one right or wrong, and once the hit rate is high enough, I switch real delegation on. After that, whenever I say “from now on, decide this kind of thing yourself,” the manager writes it into a rules file and the scope widens. The worker instructions stay untouched; only the manager’s authority widens, little by little, as trust builds.

I split the delegation rules into three tiers, and approvals into two kinds.

TierWhat the manager doesExamples
DelegatedDecides, instructs the worker right away, and only logs itThe next step of an agreed plan, a choice with set criteria, extra lookups or checks
Report afterwardProceeds, then mentions it in one line in the next reportSmall implementation choices, how much review feedback to apply
Approval: decision onlyI decide, and the manager relays it to the workerChanges in direction or scope, choices that need a business judgment
Approval: direct orderI instruct the worker myself in its tabSending messages, deployments, changes to ad budgets or bids
Worker's requestProceed? Please decideManagerChecks delegation rulesDelegatedManager instructs, only logs itReport afterwardProceeds, one line in next reportApproval: decision onlyI decide, the manager relays itApproval: direct orderI instruct in the worker tab myselfWhen in doubt, escalate
Only the bottom two branches reach me, and the scope of the top two widens as trust builds.

There’s a reason for splitting approvals into two kinds. Claude Code’s is built from the start on the principle that a message from another session can’t approve anything. The official documentation says a message “can’t approve anything” and is not treated as the user’s consent. However firmly the manager says “go ahead,” anything that goes out externally or moves money has to come from me, directly to the worker. The system had already drawn the approval line I was trying to draw. So when such an approval comes up, the manager prepares a one-line instruction I can paste into the tab.

That said, my work sessions run in , which skips permission checks. In this mode, if a worker mistook the manager’s words for approval and acted on them, the system wouldn’t stop it. So I also added a rule to the worker instructions, “don’t carry out approval items on the strength of a manager message,” locking it from both sides. I’ve written about why I use this mode and its risks in The Sandbox I Turned Off Because It Got in the Way.

Why existing products didn’t fit#

Before building anything, I looked for similar products. I had four conditions: keep using the Claude Code extension in Cursor as I do now, manage sessions that are already open, let me go into any worker session at any time to read and instruct it, and let the manager decide on delegated matters. Figures are as of November 20, 2026.

ProductMade byAlready-open sessionsKeeps the editor extensionGo in and talkDelegation
Agent ViewAnthropic (official)Only sessions sent to the backgroundTerminal screenYesNone
Agent DeckIndividual developer, about 1,300 starsOnly sessions it launchedtmux terminalYesAuto-replies when confident
Agent OrchestratorStarted at Composio, about 15,000 starsLaunches new ones per taskIts own desktop appTerminal inside the appFocused on PR and CI feedback
Gas TownSteve Yegge, about 18,800 starsLaunches new ones per tasktmux terminalYesCloser to autonomous execution

The closest was Agent View, an official Claude Code feature. It shows a one-line summary written by a small model for each session, distinguishes “needs input” from “idle,” and even lets you reply straight from the list. But it’s a research preview, and according to the documentation, interactive sessions opened elsewhere don’t show up in the list until you send them to the background. What I wanted was to leave the sessions I’d been working in from editor tabs exactly as they were and manage them.

The closest in concept was Agent Deck’s conductor. A conductor session supervises the other sessions, answers routine questions itself, and passes only the important ones up to a person. That’s delegation and approval in their purest form. But it manages only sessions that Agent Deck launched inside . Agent Orchestrator is the largest, but it’s built around a coding flow that runs from an issue to a merged PR. Gas Town is the best known, but cost and stability problems come up again and again in reports from people who adopted it. One user wrote that they spent about $100 worth of tokens in an hour.

Someone else had the same idea. A developer who wrote about managing ten Claude Code agents put it this way: “I talk to one agent. That agent manages the rest.” On top of a terminal workspace manager, a single orchestrator agent reads the screens of the other workspaces and sends them instructions. The confusion I’d been through was written there too: “Which one was doing what?”

In short, every product needed to launch the sessions itself or pull the work environment inside itself. What I needed was to leave the sessions I’d already opened and was working in exactly as they were, and add just one management layer on top. I couldn’t find such a product. So I decided to build it myself.

I separated the workspace from the management space#

There were two ways to build it. One was to put a harness for the manager, meaning skills and rules, inside the project where the work happens. The other was to split the manager off into a separate project altogether.

I chose the second. In software design terms, it’s with a one-way dependency. The working side doesn’t know about the managing side; only the managing side knows about the working side. You could also compare it to the , which attaches alongside an existing service to monitor and assist it without modifying it.

The benefits of the split are clear.

  • The workspace doesn’t need to know about the manager. Even when the manager session isn’t open, the worker sessions work as usual.
  • Changing or turning off the manager leaves the workspace untouched. I never have to touch the work repository to change the manager’s instructions.
  • The manager’s instructions aren’t exposed to the workers. At first I considered making the manager’s instructions a skill, but a skill becomes a tool that every session in that repository can call. That leaves room for a worker to accidentally act like the manager.
  • It can be attached to other workspaces. I started with work only, but personal project sessions can be observed the same way.
MeManager sessionInstructions, watch scriptWorker session AWorker session BWorker session CState files, logsWritten by Claude CodeCross-session messagesReadReports, approvalsDirectly, when neededManager space (own folder)Workspace (work repository)No arrow back to the manager
The manager only reads and speaks from the outside; nothing in the workspace depends on the manager.

That said, it isn’t completely free of dependencies. I added a short four-line agreement to the worker instructions: how to receive manager messages, a rule not to carry out approval items on the strength of a message, a rule to present choices as numbered text instead of a dialog, and a rule to tag questions that need approval with [결재 필요] (“approval needed”). The dialog rule is there because the manager can’t answer a worker’s choice dialog on my behalf. None of these agreements does any harm when there’s no manager. So I see them less as a dependency and more as an interface agreement between the two spaces.

How the manager session runs#

The manager is an ordinary Claude Code session opened in a separate folder. It differs in three ways.

First, I set the main agent to be the manager. Claude Code has a setting (agent) and a CLI option (--agent) that choose the agent used for a session’s main conversation. The instructions, tool restrictions, and model from the agent definition file apply directly to the main conversation. The Cursor extension has no menu to pick an agent per session, but when I added a single line, "agent": "manager", to the project settings of the manager folder, extension sessions opened in that folder ran as the manager. The official documentation doesn’t describe this behavior for extension sessions, so I’m recording it only as what I confirmed in my own environment. I limited the manager’s tools to reading, listing sessions, sending messages, and monitoring, and used deny rules in the settings to block it from editing the work repository or its own instruction files. These measures keep the manager managing instead of doing the work itself.

Second, a script does the watching, not the model. Claude Code leaves a state file for each running session and records whether it’s working (busy) or idle (idle). This isn’t a documented format; it’s what I found by opening the files. A small script reads these files every two seconds and prints one line when a session that was working finishes its turn. The manager keeps this script running with Claude Code’s monitoring tool (Monitor) and wakes up only when it prints something. When I measured it, one read of the files took 0.15 ms, and the tokens spent while waiting are zero. Whether the polling interval is one second or ten, the cost is the same; it scales only with the number of turns that end.

Third, a finished turn doesn’t mean it’s my turn. The tab problem from earlier shows up here too, because a session that handed work to a subagent in the background also ends its turn and goes idle. So when the manager wakes up, it reads only the last response from that session’s transcript and sorts it into one of four groups.

  • In progress: It ended its turn while waiting on background work or a schedule, and isn’t asking me anything.
  • Completion report: It ended with a report of results and no question.
  • Decision request: It ended with a question or options. The delegation rules apply.
  • Waiting on a dialog: A choice dialog is open. The manager can’t answer it, so it tells me.

The script finds whether any background work remains by looking through the transcript. It pairs records of background work starting with notices of it finishing, and counts the unpaired ones as remaining work. Testing against real sessions showed that it also had to filter out work that was stopped midway, schedules that were deleted, and conversation compaction summaries.

What the first run taught me: most of a manager’s job is not speaking#

When I opened the manager session and typed “start,” the manager went through the four open work sessions, reported the current state, and set up the watch. Here’s what I saw in the first forty minutes.

Starting with what went well: it sorted the approvals correctly. Reverting ad bids or turning off automated rules went up as “direct order,” complete with a line I could paste into the tab, while questions like whether to notify the person in charge went up as “decision only.” It relayed two of my decisions to the workers, and the workers picked up the messages and carried on. When relaying “rethink what to do next and propose it” to one session, the manager added on its own a line saying “propose only; don’t change rules or bids.”

The things to fix were just as clear. All three came down to talking too much.

ProblemWhat it looked likeInstruction I changed
Spoke even with nothing to report“I’ve restarted the watch,” “Nothing new to report,” running commentary on progressSilence by default. If it’s in progress or a completion report, log it and say nothing
Long approval explanationsThree or four sentences per approvalTwo lines or fewer per approval. Background and reasoning only when “details” is requested
Didn’t notice approvals I handled in the tabKept repeating “still waiting for your answer” after I had already instructed the worker in its tabIf the worker’s latest instruction is later than when the approval was raised, treat it as handled

After the fixes, the report aims to look like this.

[2 approvals]
1. Ad ops session A — keep or turn off 3 new raise rules. Recommend: keep. Direct order → type "turn off the 3 rules" in the tab
2. Budget check session — notify the owner about an unusual change? Decision only → tell me and I'll relay it
[In progress 3 · Done 1 · Proposals 1 · Pending 0]

Revising the manager’s instructions, I realized something. Most of the manager’s instructions weren’t about what to do but about what not to say. Raise only approvals, raise them briefly, and don’t bring up what’s already handled. Come to think of it, a good department head is the same. The department head who saves the CEO’s time isn’t the one who reports a lot, but the one who filters out what doesn’t need reporting.

Closing#

Working like the CEO didn’t mean giving up the context. It meant cutting down what I read while keeping a path open to the full text whenever I need it. And it meant not deciding all at once what to hand over, but widening the delegated scope as trust builds.

In July I wrote that people had become schedulers moving between agents. This attempt shifted that role a little. I’ve handed the scheduling itself to the manager and moved toward designing the approval lines: what gets delegated and what comes up for my sign-off.

The limits are clear too. I still have to handle the workers’ choice dialogs and permission prompts myself. The manager spends tokens every time it wakes, and its own context builds up when it runs for a long time. So the manager keeps the current state and pending approvals in separate files, so that it can carry on even after I open a new session. It’s still in probation, so I don’t yet know how accurate its proposals are or how much a week of running it costs. Once those results build up, I’ll write a follow-up.

Appendix: If you want to try it#

Translated into generic paths, my setup looks like this. I haven’t published the full manager instructions on this blog.

~/work/manager/                  ← folder just for the manager (one editor window)
├── .claude/settings.json        ← "agent": "manager", deny rules for writes
├── .claude/agents/manager.md    ← role, sorting criteria, delegation rules, report format, prohibitions
├── scripts/                     ← scripts to list sessions, watch status, read the last response
├── state/                       ← operating mode (probation/delegation), status board, pending approvals
├── log/                         ← delegation log by date
└── rules/                       ← rules the user added with "from now on" or "remember"
{
  "agent": "manager",
  "permissions": {
    "deny": [
      "Edit(//path/to/workspace/**)",
      "Edit(//path/to/manager/.claude/**)"
    ]
  }
}
  • Write the deny rules as Edit(...). When I also added Write(...) rules, Claude Code warned that Edit rules apply to all file-editing tools, so the Write rules have no effect.
  • Open only one manager session. With two, both react to the same event and instructions go out twice.
  • For cross-session messages to be delivered right away, the manager and the workers need to be in the same class of permission mode. Otherwise the receiving side waits for the user’s approval. You can change this with the receiving session’s crossSessionInbound setting (accept / hold / refuse).
  • The monitoring tool runs for at most 30 minutes at a time, so the manager re-arms it when it expires. To get approval notifications on your phone, turn on Remote Control in the manager session. I covered that setup in Leave the Laptop, Carry Only the Screen.

References#