The hard part is not starting an agent. It is supervising several.

QA work naturally splits into logs, UI, tests, code, CI, and review. cmux makes those streams visible.

cmux is a Mac terminal that adds agent supervision primitives.

It stays close to the terminal, but adds the missing cockpit pieces around it.

Teach cmux as four nested units: workspace, pane, surface, process.

Once students know the hierarchy, every feature has a home.

Install cmux, then wire it into the agents your students already use.

Keep setup boring: one install path, one hook pass, one small verification.

$ brew tap manaflow-ai/cmux
$ brew install --cask cmux
$ cmux hooks setup
$ cmux hooks setup codex
$ cmux ping
pong: true

Each task becomes a visible lane instead of a hidden terminal tab.

For students, this is the difference between multitasking and chaos.

Put the entire QA investigation on one screen.

A strong cmux layout makes every pane answer one question.

cmux turns agent waiting time into an explicit queue.

This is the feature students will feel immediately when several agents are running.

$ cmux notify --title "Codex" \
  --subtitle "Waiting" \
  --body "Review locator strategy"

The browser pane makes UI testing part of the same agent workspace.

For QA/SDET, this is where cmux becomes more than a terminal.

cmux browser open-split http://localhost:3000
cmux browser surface:2 wait --text "Login"
cmux browser surface:2 fill "#email" --text [email protected]
cmux browser surface:2 click "button[type=submit]" --snapshot-after
cmux browser surface:2 errors list
cmux browser surface:2 screenshot --out failure.png

cmux is controllable enough for agents and test scripts.

Every important workspace action can be driven by the CLI or JSON socket.

{"id":"ws","method":"workspace.list","params":{}}
{"id":"notify","method":"notification.create", ...}

cmux claude-teams turns teammate agents into native splits.

Claude thinks it is using tmux; cmux translates those pane commands into its own socket API.

Use Git worktrees so multiple agents can code without stepping on each other.

cmux custom workspace commands can create a repeatable multi-agent layout.

"commands": [
  {
    "name": "Worktree Agents",
    "workspace": {
      "layout": { "direction": "horizontal", ... }
    }
  }
]

Long QA investigations can survive a restart.

cmux restores app-owned layout first, then supported agents can resume from saved session IDs.

Mac users can supervise remote dev/test boxes as cmux workspaces.

The local app shows the workspace; the compute can live on a server.

cmux ssh user@remote

Reproduce, inspect, patch, and verify a bug in parallel.

This is a practical classroom demo because each agent has a narrow job.

Use agents as specialized SDET roles, not a single magic worker.

cmux makes role separation visible enough for students to practice.

Parallel agents need explicit ownership and review gates.

cmux improves visibility, but the instructor still defines the operating rules.

Instructor mantra: fast parallelism, slow merge.

Teach cmux through one small web app and one real bug.

This agenda keeps the class moving from concept to hands-on workflow.

npm run dev
cmux browser open-split localhost:3000
cmux notify --title "Tests" --body "Done"
cmux claude-teams

Spawn three agents, then converge on one tested patch.

The goal is not agent spectacle. The goal is disciplined parallel QA.

Lab submission: screenshot of cmux workspace + PR/diff + test output.