Writing
Six ways to lay out a multi-agent session pane
2026-11-15
You already know how to run agents. The problem now is keeping track of ten of them at once without becoming the bottleneck.
You already know how to run agents. The problem now is keeping track of ten of them at once without becoming the bottleneck.
This ranking is for developers who:
- Run multiple coding agents in parallel (Claude Code, Codex, Cursor, custom terminal agents).
- Care about what lands on main and want humans in the loop.
- Are hitting the attention ceiling: you are the slowest part, not the model.
The patterns below assume you’re using Maxxwell as the agent-of-agents: one pane of sessions, an orchestrator seat on top, and your existing workers running as real terminal sessions.
The ranking criteria:
- How well the pattern answers: “What needs my attention right now?”
- How legible it is when you have 8-20 sessions running.
- How much it respects your existing repos, branches and workflows.
1. State-first herd view
The state-first layout puts session status at the top: working, idle, waiting on you, needs sign-in, blocked, done, dead, not heard from, possibly stalled.
This is the pattern that treats attention as the scarce resource.
Why it’s ranked first:
- Stack Overflow’s 2025 survey: 84% of developers use or plan to use AI tools, but only ~29% trust outputs. The real work is triage and verification, not generation.
- Sonar’s 2026 report: AI hasn’t produced massive productivity gains; it created a verification bottleneck. That’s an attention problem.
In Maxxwell terms:
- The herd view is sorted by “needs human” first, then by activity.
- “Waiting on you” and “blocked” float to the top.
- “Possibly stalled” and “not heard from” are explicit, not guessed.
- The orchestrator seat reports: what landed, what it decided, what is waiting on you.
This is your default if:
- You have more than 5 sessions running most of the day.
- You answer “where should I look next?” more often than “what should we build next?”.
- You’re reviewing and merging across several repos or branches.
Trade-offs:
- Less semantic grouping. A bugfix for
api-service and a refactor in frontend sit next to each other if they’re both blocked. - You need some discipline in naming sessions so you can still find “feature-foo” quickly.
Concrete example:
- Lane A: “auth-bug-prod: working (possibly stalled)”
- Lane B: “mobile-startup-perf: waiting on you”
- Lane C: “infra-terraform-upgrade: blocked (needs sign-in)”
You look once and know exactly where your next three decisions are.
2. Goal-grouped layout
Goal-grouped views cluster sessions by a written objective: “Ship subscription billing”, “Stabilize test suite”, “Migrate feature X off legacy API”.
Claude Projects does this at the thread level. In Maxxwell, the orchestrator seat takes the written brief and spins up workers against it.
Why it’s second:
- It matches how product work is actually planned: epics, features, initiatives.
- It sits naturally on top of repo and branch isolation.
In Maxxwell terms:
- You start with an orchestrator brief, e.g. “Add usage-based billing to the SaaS product.”
- The orchestrator spawns:
- A worker in
billing-service for usage tracking. - A worker in
frontend-dashboard for UI changes. - A worker in
infra for metering and alerts.
- The herd view shows one goal with several lanes underneath, each with its state.
Good for:
- Tech-lead ICs driving cross-repo features.
- Solo devs with 1-3 concurrent initiatives and many agents per initiative.
- Teams that talk about work in terms of goals more than repos.
Trade-offs:
- Easy to hide a stuck lane inside a “green” goal if you don’t also surface state.
- Goals can get fuzzy; “stabilize infra” is a bad grouping key.
Best practice:
- Use sharp, testable goals:
- “Reduce P95 checkout latency from 1200ms to <600ms.”
- “Move all Stripe calls behind a single billing facade.”
- Map each lane to a specific sub-goal or repo.
3. Repo-grouped layout
Repo-grouped views cluster sessions by Git repo or worktree. Conductor, ADE and Helmor all converge on “one task, one isolated branch/worktree” for parallel agents.
Why it’s third:
- It’s the most obvious mapping from how devs think today: each repo is one box.
- It works well when state sharing within a repo matters.
In Maxxwell terms:
- Each repo/worktree/monorepo package is a group.
- Within a repo, you might have lanes like:
api-service:- “add rate-limit headers (working)”
- “refactor auth middleware (waiting on you)”
frontend-app:- “checkout perf tuning (working)”
- “A/B experiment wiring (idle)”
- You see all work touching a given repo and its states at a glance.
Best for:
- Monorepos with many packages and shared infra.
- Teams where ownership is by repo: “you own payments-service”.
- ICs doing intense deep work in one codebase while still supervising others.
Trade-offs:
- Cross-repo goals are harder to see; you have to mentally join
frontend and api work into “checkout improvement”. - Doesn’t answer “what needs my decision?” as directly as state-first.
Recommended shape:
- Base grouping: repo/worktree.
- Within repo: sort by state, then by branch/feature name.
4. Attention queue layout
The attention queue layout is basically a priority inbox for agents: a single list of “things that need a human”, sorted by urgency and type.
Acepe calls out this pattern explicitly with “attention queues” for session triage.
Why it’s fourth:
- It is the strictest expression of “you are the bottleneck, work from a queue.”
- It stacks well with any other view: repo-grouped, goal-grouped, state-first.
In Maxxwell terms:
- The herd view exposes a filtered slice:
- All sessions with state in {waiting on you, blocked, needs sign-in}.
- Optionally, “done” lanes that need review/merge.
- The orchestrator session compiles a return report:
- “3 items need your decision.”
- “2 sign-ins are blocking progress.”
- “1 done lane pending merge into
main.”
Good for:
- ICs keeping velocity high while juggling meetings and interrupts.
- Tech-leads who don’t have time to read every transcript.
- Any setup where “what do I do next?” is answered in one place.
Trade-offs:
- You can lose context if you live only in the queue; it’s a list, not a map.
- Easy to overweight urgent but low-value items if you don’t tie priority to goals.
Practical pattern:
- Use state-first view as the default.
- Flip to attention queue for “focus sprints” where you clear blockers.
5. Branch/worktree-isolated layout
Branch/worktree-isolated views reflect a now-standard pattern in multi-agent tools: each independent task gets its own branch or worktree, and all agent sessions for that task run inside it.
Conductor’s docs put this very clearly: use multiple workspaces for independent features or bug fixes, and one workspace when shared state matters.
Why it’s fifth:
- It’s essential for safely running many coding agents at once.
- It makes review and merge manageable.
In Maxxwell terms:
- Each lane is tied to a branch or worktree, e.g.
feature/live-pricing, bugfix/cart-tax, spike/new-cache-layer. - Sessions outlive the app: quitting Maxxwell detaches, it never kills the terminal or the branch.
- Your herd view shows which isolated efforts are alive, done, or dead.
Best for:
- Teams nervous about agents touching
main directly. - Complex changes that need isolated review.
- Experiments or spikes that may be abandoned.
Trade-offs:
- More branches/worktrees to manage; requires discipline.
- If you don’t name branches clearly, the layout degenerates into noise.
Recommended habits:
- Encode goal and scope in branch names:
feature/checkout-p95-600ms. - Tie Maxxwell lane names to those branches.
6. Time-sliced / lineage-first layout
Time-sliced or lineage-first views show the history and evolution of each session: which commands ran, which decisions were made, and how the transcript changed over time.
Tools like ctx emphasize transcript lineage filters; you see how one idea spreads and mutates across sessions.
Why it’s sixth:
- It helps with audit, debugging, and trust.
- It’s less critical for day-to-day triage than state or goals.
In Maxxwell terms:
- Each lane carries a readable state and a durable transcript.
- You can attach to any worker mid-sentence and inspect its history.
- “Not heard from” is explicit; Maxxwell does not pretend to know what happened off-pane.
Good for:
- Teams in regulated environments needing traceability.
- Debugging “why is this agent confidently building the wrong thing?”
- Post-mortems on drifted work.
Trade-offs:
- Adds cognitive load if presented as the primary view.
- Best used as a drill-down from a clearer herd layout.
Practical usage:
- Run state-first or goal-grouped as your main pane.
- Jump into lineage view when you need to understand how you got here.
Comparison at a glance
State-first and attention queue layouts are strongest for triage; goal- and repo-grouped views shine for structural clarity; branch isolation and lineage matter most for safety and audit.
Recommendations by use case
There isn’t a single “best” herd view. The right layout depends on where your bottleneck actually is.
Solo IC with many agents on a personal or startup repo
Use:
- Primary: State-first herd view.
- Secondary: Attention queue for focus blocks.
- Structure: Branch/worktree isolation per feature.
Pattern:
- Brief the orchestrator with a clear goal.
- Spawn workers per branch/worktree.
- Live in state-first view; flip to attention queue when clearing blockers.
Tech-lead IC across multiple repos and initiatives
Use:
- Primary: Goal-grouped view.
- Secondary: Repo-grouped for deep dives.
- Overlay: State-first sorting inside each goal.
Pattern:
- Treat Maxxwell’s orchestrator as your project chat.
- Define goals that match your epics.
- For each goal, run lanes tied to repos/branches, sorted by state.
- Use the attention queue before standups to see what needs your call.
Team lead coordinating several devs using agents
Use:
- Primary: Repo-grouped view matched to ownership.
- Secondary: Branch/worktree isolation per task.
- Audit: Lineage-first when something goes wrong.
Pattern:
- Each dev owns a set of repos; group lanes accordingly.
- Encourage feature/bugfix branches per task.
- Maxxwell sits above individual agents and shows where work is blocked or stalled.
Highly regulated or safety-critical contexts
Use:
- Primary: State-first with strict branch/worktree isolation.
- Secondary: Lineage-first view for traceability.
Pattern:
- Keep agents off
main; everything in dedicated branches. - Treat lineage view as part of your review checklist.
- Use “not heard from” as a red flag, not a cosmetic state.
FAQ: herd views, Maxxwell, and multi-agent work
1. What is a “herd view” in the context of Maxxwell?
A herd view is the pane where you see all your coding agent sessions at once: their state, their repo/branch, their goal, and whether they need you.
Instead of twelve terminals with separate chats, you get one surface with labeled lanes. Maxxwell adds an orchestrator seat on top, itself a real coding-agent session, so you talk to one briefed agent and it coordinates the rest.
2. How is Maxxwell different from Claude Code, Codex, or Cursor?
Claude Code, Codex and Cursor are workers: coding agents that edit, run, and explain code.
Maxxwell is the agent that manages your agents. It:
- Runs your existing tools as unmodified terminal sessions.
- Keeps them in one window with explicit states (working, idle, waiting on you, blocked, etc.).
- Provides fleet controls that draft rather than act - any control that would change the fleet writes a complete, unsent sentence into the composer; you still press enter.
It does not replace your coding agents; it sits above them.
3. Does Maxxwell automatically detect drift or fix stuck sessions?
No. The conducting is real, the autopilot is not.
Maxxwell:
- Shows live context-pressure readouts with tiered warnings.
- Offers one-click context compaction.
- Surfaces “possibly stalled” and “not heard from” explicitly.
It does not:
- Automatically detect drift and re-aim a session.
- Automatically recycle context.
- Restart work that stopped.
- Run goal checks on its own schedule.
You stay in control; Maxxwell’s herd view tells you where to intervene.
4. Which herd view should I start with if I already have tmux + shell aliases?
If you’re already running DIY orchestration:
- Start with state-first as your main pane.
- Layer repo-grouped when you want structure that matches your tmux layout.
- Use branch/worktree isolation for every independent task.
You’ll still be able to attach to real terminals and keep your workflow. The difference is that Maxxwell tracks states across them and outlives the window: quitting detaches, it never kills sessions.
5. Does Maxxwell require a server or SaaS account?
No.
Maxxwell:
- Runs locally.
- Requires no server.
- Is free for individuals; teams pay.</br>
You bring your own model access: an API key or an existing Claude or ChatGPT/Codex subscription.
The short version: pick a herd view that matches where your bottleneck is. If your problem is “what needs my attention?”, start state-first. If your problem is “how do we move this feature across three repos?”, start goal-grouped. Maxxwell gives you the layer above your agents so you can spend less time herding and more time deciding.