Coordinate agents with a manager and worker panes

Adopt an agent-first mindset and the manager-worker topology; Drive CMUX terminal layouts with natural language; Set up AFK automation loops that keep working while you don't.

Original source pages and recordings require authorized access. The full article text here is public.

The practice is shifting from manually babysitting one terminal to using CMUX as an agent-first terminal workspace. John shows that agents can read CMUX's command surface, open and arrange panes from natural language, name tabs, resume old conversations from the Vault, jump to panes with unread activity, and inspect what other panes have said or done. He also describes his preferred manager-worker pattern: he talks mostly to one Manager pane, and that pane can open or check worker panes.

Working outcomes

  • Adopt an agent-first mindset and the manager-worker topology
  • Drive CMUX terminal layouts with natural language
  • Set up AFK automation loops that keep working while you don't

Concepts and consequences

Agent-first tooling

John frames modern dev tools around whether they are open source and agent-first: tools with CLIs, APIs, or other surfaces agents can interact with and control. His point is that you no longer need to personally memorize every flag or shortcut when the agent can inspect the interface and use it.

Why it matters: Agent-first tools let your instructions turn into real tool actions: opening panes, running commands, checking status, or operating a CLI. Tools without programmable surfaces put more mechanical work back on the human.

PackX for file collation

John shows PackX, a tool he built to collate a bunch of files into a single file. He explains that it supports file globs, patterns, and options, and that he typically lets the agent learn and use the CLI flags instead of using the tool manually.

Why it matters: It is an example of agent-first thinking: give the agent a useful CLI tool and let it handle the exact flags and patterns needed for the current context.

Natural language terminal orchestration

John demonstrates asking CMUX to open a new pane to the right, then asking it to open five more panes, run different safe commands in them, and space everything evenly. The agent uses the CMUX CLI surface to translate natural language into layout and terminal actions.

Why it matters: This makes the terminal workspace programmable. You can describe the workspace you need instead of manually arranging panes and remembering multiplexer commands.

Vault and resumed conversations

John demonstrates the CMUX right sidebar with Files, Find, and Vault. In the Vault, he can look through past conversations and resume one in a new tab, though he notes the feature is still in development and search is not great yet.

Why it matters: Resuming old context is useful when you lose or want to continue a previous conversation without manually reconstructing what happened.

Unread notification jumping

John shows that CMUX can surface notifications from sessions and that Cmd+Shift+U jumps to unread activity. He uses it to jump to a pane where a session had stopped.

Why it matters: When many sessions are running, jumping to the pane that needs attention is faster than manually scanning every pane.

Cross-pane context reading

John demonstrates that CMUX can read the contents of other tabs or panes by echoing text in one tab and asking another what that tab said. He explains that agents can check other panes, workspaces, recent commands, Git actions, and signs that something needs attention.

Why it matters: This is what makes multiple panes more than just visual clutter. A main or sibling agent can inspect what is happening elsewhere and summarize it for you.

Manager-worker topology

John describes treating himself as the CEO, one pane as the Manager, and other panes as workers. He tries to talk mainly to the Manager, which can open panes and send workers to investigate, research, or do other tasks.

Why it matters: A manager pane keeps the human interaction surface smaller while still letting several agents or terminal sessions do work in parallel.

AFK goal loops

John gives an example goal where an agent creates a timestamp, checks other panes every 10 minutes to make sure they are completing their goals, picks the best answer if a pane is blocked by a question, and continues until four hours after the original timestamp. He describes this as an AFK approach where he can set it and walk away.

Why it matters: Periodic check-ins can keep multiple running sessions moving, but John also says the upfront planning for parallel work is still something to be actively involved in.

Reference tools and resources

CMUX

An open-source, agent-first terminal workspace John uses to let agents control panes, tabs, workspaces, notifications, and terminal activity through a CLI-driven surface.

Use when: Use it when you want local agent-driven terminal orchestration: opening panes, arranging layouts, naming tabs, resuming old conversations, jumping to unread sessions, and checking what other panes are doing.

Reference

PackX

John's file collation utility for packing selected files, globs, and patterns into a single file.

Use when: Use it when an agent needs to gather a set of files into one context bundle and you would rather have the agent handle the CLI flags and patterns.

Reference

tmux

The classic terminal multiplexer that came up when a participant asked whether CMUX is worth trying for someone heavily invested in tmux.

Use when: Keep tmux in mind if remote session behavior is central to your workflow; John said CMUX does not have all the remote session features he associates with tmux, while his own work is mostly local.

search: tmux terminal multiplexer remote sessions

Claude Code scheduling

John mentioned that Claude Code has a scheduling or cron-like feature he wishes Codex had more directly.

Use when: Think of this as context for the AFK check-in idea, not as a taught setup path in this lesson.

search: Claude Code scheduled tasks

Codex Mobile

John briefly shows the Codex app setting for Codex Mobile and says recent changes let phone control work with sessions started in CMUX as long as the app is open.

Use when: Use it for lightweight control or check-ins from a phone, while recognizing this section only briefly demonstrates where the feature lives and what it enables.

search: Codex Mobile app

Recommendations and best practices

  • Choose tools that are open source and agent-first, meaning agents can control them through CLIs, APIs, or similar programmable surfaces.
  • Let agents handle CLI flags and command details when the tool surface is discoverable, as John does with PackX and CMUX.
  • Use natural language CMUX commands to create panes, arrange the workspace, name tabs, and run safe commands.
  • Prefer panes over tab groups when you want visible parallel work, because John says tab groups are easy to lose track of.
  • Use the CMUX Vault to resume old conversations, but remember John called the feature still in development and said its search is not great yet.
  • Use Cmd+Shift+U to jump to unread activity when a running session stops or needs attention.
  • For multi-agent work, try a Manager pane that you talk to directly, while worker panes handle investigations, research, or other delegated tasks.
  • For AFK-style work, use a clear interval and stop condition, and stay actively involved in the upfront planning before parallelizing work.

Practice and acceptance criteria

Practice using CMUX as an agent-controlled terminal workspace: natural language pane control, visible parallel sessions, a manager pane, and periodic check-ins.

Checklist

  1. Open a CMUX workspace.
  2. Run or inspect CMUX help so the agent can discover the command surface.
  3. Use a natural language command to open a new pane to the right.
  4. Ask CMUX to open several more panes, run different safe terminal commands in them, and space the panes evenly.
  5. Ask CMUX to name tabs with clear or memorable names.
  6. Open the right sidebar with Cmd+Alt+B and locate the Files, Find, and Vault sections.
  7. Resume a past conversation from the Vault if one is available.
  8. Use Cmd+Shift+U to jump to unread activity from a session that has stopped or needs attention.
  9. Echo a short message in one named tab, then ask another pane what that tab said.
  10. Create one Manager pane and have it check or summarize what worker panes are doing.

Natural Language Pane Warmup

Difficulty: Easy

In CMUX, ask the agent to open a new pane to the right. Then ask it to open several more panes, run different safe terminal commands in them, and space the layout evenly.

Done when: The workspace contains multiple visible panes, each running a harmless command, without you manually arranging every split.

Vault and Unread Navigation Drill

Difficulty: Easy

Open the right sidebar, find the Vault, and resume a previous conversation in a new tab if one is available. Then use the unread-jump workflow to move to a pane that has activity needing attention.

Done when: You can explain how to open the sidebar, where the Vault lives, and how Cmd+Shift+U helps you jump to unread activity.

Manager Checks the Room

Difficulty: Medium

Create one Manager pane and at least one Worker pane. Have the Worker run a safe command such as echo, pwd, or git status. Then ask the Manager to inspect the Worker pane and summarize what it sees.

Done when: The Manager correctly identifies what happened in the Worker pane and does not invent output that is not visible.

Small AFK Check-In Goal

Difficulty: Hard

Write a bounded goal for a Manager pane that creates a timestamp, checks other panes at a fixed interval, reports progress, and stops after a defined time window.

Done when: The goal includes an interval, a clear stop condition, and a reporting instruction, matching the AFK-style pattern John described.

Questions to test understanding

What does John mean by agent-first tooling in this lesson?

  • A. Tools that expose CLIs, APIs, or other surfaces agents can inspect and control
  • B. Tools that only work through graphical menus
  • C. Tools that require the human to memorize every shortcut before using them
  • D. Tools that prevent agents from running commands

Answer: A. John says the tools to look for are open source and agent-first: tools with CLIs, APIs, or other ways agents can interact with and control them.

What did John demonstrate with CMUX natural language commands?

  • A. Opening and arranging panes, then running different safe commands in them
  • B. Replacing the terminal with a static web dashboard
  • C. Deploying production code from a phone
  • D. Converting every pane into the same shared shell process

Answer: A. John asked CMUX to open a pane to the right, then to open five more panes, run different safe commands, and space everything evenly.

What is the role of the Vault feature John showed?

  • A. It stores billing credentials for agents
  • B. It lets John look through past conversations and resume one in a new tab
  • C. It prevents all worker panes from editing files
  • D. It automatically writes tests for every project

Answer: B. John opened the right sidebar, went to Vault, found past conversations, and resumed one in a new tab. He also noted the feature is still in development.

In John's manager-worker pattern, what does he try to do?

  • A. Talk mainly to one Manager pane while other panes do delegated work
  • B. Talk to every pane equally at all times
  • C. Avoid opening more than one pane
  • D. Use only phone controls and never the terminal

Answer: A. John describes himself as the CEO, one pane as the Manager, and other panes as workers. He tries to talk mainly to the Manager.

Why is cross-pane reading useful in CMUX?

  • A. It lets an agent check what other tabs or panes have said, run, or gotten stuck on
  • B. It guarantees that no two agents can ever conflict
  • C. It removes the need for planning parallel work
  • D. It makes tmux remote persistence unnecessary

Answer: A. John demonstrated asking one pane what another tab said, then described checking other panes, recent commands, Git actions, summaries, and things needing attention.

What was John's AFK-style example?

  • A. Check other panes every 10 minutes, answer blocking questions, and continue until four hours after the original timestamp
  • B. Run forever and approve every action automatically
  • C. Rewrite the whole repo every hour
  • D. Let every worker choose unrelated goals without checking in

Answer: A. John's example was a scheduled goal loop that checks other panes every 10 minutes, picks the best answer when a pane is blocked by a question, and continues for a defined four-hour window.

Reflection prompts

  • Which tools in your workflow are agent-first because they expose useful CLIs or APIs?
  • Where would visible panes help you keep track of parallel work better than hidden tab groups?
  • What work would you route through a Manager pane, and what work would you still handle directly?
  • What kind of AFK check-in loop would be useful without replacing the upfront planning you still need to do yourself?

Further applications

  1. Practice opening and arranging CMUX panes with natural language commands such as opening a pane to the right or creating several evenly spaced panes.
  2. Try naming tabs with a natural language request, then search for or close specific named tabs.
  3. Use the Vault sidebar to find a past conversation and resume it in a new tab.
  4. Create a simple manager-worker setup: one Manager pane and one or two worker panes, then ask the Manager to check what the workers have done.
  5. Draft a small AFK-style goal that checks other panes at a fixed interval, reports progress, and stops after a defined amount of time.

Applied exercises

Exercise: Orchestrating the Manager-Worker Pattern in CMUX

  • Objective: Build an isolated local development grid that relies on a single coordinator agent to direct sub-tasks across multiple child panels without manual human window tiling.
  • Setup Steps:
    1. Open a clean workspace inside CMUX.
    2. Split your terminal layout using a macro shortcut or natural language step (! Open a new Pane to the right).
    3. Designate the primary window as your Manager shell.
    4. Input a structured layout command to the Manager: "Spawn three sibling panes below. Initialize a clean repository tracker in pane 1, trigger a continuous build diagnostic loop in pane 2, and use pane 3 to monitor local directory storage footprints."
    5. Validate that CMUX correctly partitions the available workspace area, configures separate shell environments, and triggers the independent task sequences cleanly.
    6. Verify cross-context capabilities by asking your Manager pane: "What is the active execution state and output log of your second sibling pane?"

Questions and answers

What’s cmux? Is it like Warp, but less commercial?

An open-source, agent-first terminal multiplexer tool. It focuses on providing structural APIs and CLI endpoints that allow background autonomous models to freely control window positioning, manage context structures, and drive active command operations.

Would you recommend this to a heavily invested tmux user?

Yes, but with caveats. CMUX currently lacks some of the robust persistent remote-session features found in traditional Tmux architectures. It is highly optimized for local, agent-orchestrated loops, meaning pure remote workflow users may encounter friction.

do we have alternative for windows

Zellij operates effectively on Windows nodes and natively supports direct agent control integration features.

Platform caveat: this was a suggested alternative, not a demonstrated Windows installation. Confirm the supported host environment and any WSL requirement before using it as a team setup recommendation.

How do you get vault? I missed it

Press Cmd+Alt+B to display the right-hand utility sidebar. From there, navigate between Files, Find, and Vault categories using numerical shortcuts 1, 2, and 3.

Do you need your projects structured a certain way so cmux can run multiple sessions without causing issues with agents stepping on toes?

Isolate running server processes cleanly behind the individual terminal tabs that actively consume them. Because CMUX manages distinct windows independently, models can run safely in parallel and can programmatically read across sibling history buffers to check on processing states without corrupting cross-project environments.

Have ways in which you manage to move from one to the other, or you fork, or you come back. And then maybe a follow-up question is, I saw you post something about one agent controlling another agent through... a graphical, or for browser, accessibility controls, and I'm just curious if you have any... of these other ways in which you manage between agents?

John relies on the manual 'codex fork' option to branch conversations from selected history checkpoints. He uses a Manager-Worker Pattern: a single primary terminal pane is his designated 'Manager' (his sole point of interaction), and that manager model script handles splitting sub-panes to deploy worker agents. For browser environments, toolsets leverage accessibility tree paths to parse content, but within CMUX, the native command-line interface endpoints are fast and descriptive enough that parsing raw accessibility trees isn't necessary.

Codex implement /tree when?

Unanswered/Deferred. John does not address this question directly in the transcript; during this window, he is answering a verbal question from a developer regarding agent handoffs and manager topologies. The nearest tool comparison occurs at [00:45:55] where John discusses wanting Claude Code's cron scheduling features inside Codex.

Operational playbooks

Recording references

Timestamped source page

Visual reference index

  • 00:31:16: Screen showing the NPM home tracking page details for the custom tool package packx.
  • 00:33:55: The initial unified CMUX terminal layout before invoking layout splits.
  • 00:34:19: Visual proof of a new vertical split created by typing ! Open a new Pane to the right.
  • 00:34:59: The workspace grid re-tiling into a complex multi-pane array following the voice-dictated instruction to spawn 5 distinct command loops.
  • 00:37:06: The expanded Vault interface view appearing inside the right sidebar, showing past interaction history blocks.
  • 00:37:33: Right-click sub-menu interaction executing the 'Resume a new tab' instruction to revive old log states.
  • 00:39:29: The UI snapping focus directly to an isolated corner box via Cmd+Shift+U immediately following the termination of a background Codex Demons session.
  • 00:41:00: Multiple workspace tab configurations explicitly showing custom names generated by the agent (Zendaya, Oprah, Tom Hanks).
  • 00:47:53: Input prompt displaying John's complete text for the 4-hour cyclical /goal background monitoring loop.
  • 00:51:58: Close-up highlighting the position of the Codex Mobile icon within the master system settings pane layout.

Source references