Writing

Triage boards vs live agent status streams

2026-09-08

You’re already running multiple coding agents in parallel. The new bottleneck isn’t tokens, it’s your attention. The question is: do you spend that attention.

You’re already running multiple coding agents in parallel. The new bottleneck isn’t tokens, it’s your attention. The question is: do you spend that attention herding them in a generic Monday-style board, or reading a live status stream coming straight from the terminals?

This comparison is about that choice.

What actually competes for your attention budget

Manual triage boards sound harmless: a few columns, some statuses, drag cards, add comments.

In practice, every update you make to a board is time you’re not reading logs or agent output.

A few data points make this concrete:

UCI’s field study found information workers spend ~3 minutes on a task before switching, and just over 2 minutes per document/tool before changing context.
A later UCI/Microsoft study reported median screen focus of 40 seconds, with shorter focus correlating with lower end-of-day productivity.
Microsoft’s 2025 Work Trend Index reports frequent interruptions through the workday, and that 48% of people feel their work is chaotic and fragmented.

If you add a manual triage board for your agents, you’re adding another screen that wants a slice of those 40 seconds.

Maxxwell doesn’t remove context switching, but it stops creating a second source of truth. Its live status view reads from the actual sessions: working, idle, waiting on you, blocked, needs sign-in, done, dead, not heard from, plus a “possibly stalled” overlay. You don’t have to remember to drag a card when something changes.

Manual boards: snapshots with built-in lag

Monday-style boards, Jira walls, Notion tables - they all share one property: the board is a snapshot.

monday.com literally defines a status report as “a snapshot at a specific moment.” It’s only accurate until reality moves.

For AI coding agents, reality moves constantly:

A Claude Code session hits a Git conflict and waits.
Cursor-agent pauses on an auth error.
A Codex run is happily building the wrong microservice.

On a manual board:

The card still says “In progress” until you remember to change it.
A session that is hard-blocked looks the same as one that is just slow.
“Done” might mean “agent thinks it’s done” or “you reviewed and merged”; the board can’t tell.

The more often you update it, the more accurate it is - and the more of your day disappears into keeping states “herded” across tools.

Maxxwell: one window, live state per session

Maxxwell takes the opposite stance: it doesn’t ask you to maintain a board; it maintains a live inventory of your agent sessions.

Core behavior:

Each worker is a real terminal session: Claude, Codex, Cursor-agent, or whatever else you already trust.
Maxxwell tracks live state: working, idle, waiting on you, not started, blocked, needs sign-in, done, dead, not heard from, plus possibly stalled.
When it cannot confirm, it says not heard from instead of guessing.

You get:

A single window showing everything your fleet is doing.
No second representation to keep in sync with reality.
The ability to attach and take over any worker mid-sentence.

For developers already comfortable with tmux panes and multiple terminals, Maxxwell is basically “tmux, plus state, plus a conductor seat” - not another board.

Attention cost: moving cards vs reading logs

Let’s put numbers on the attention tax.

If you switch tasks every 3 minutes, and your triage board is one of those tasks, then each status change is another 3-minute block that breaks flow.
ICSE 2024 showed that on-screen interruptions from dominant sources increased code comprehension time and altered stress patterns for engineers.

Updating a board is an interruption, even if you caused it.

With a manual triage board:

Every “what is agent #4 doing?” becomes: open board, find card, see text, maybe open terminal anyway.
Every “blocked” state needs you to notice something in logs, then go copy it into the board.
You now have two maps of reality: your terminals, and whatever your board thinks is happening.

With Maxxwell:

“What is agent #4 doing?” is just glancing at the status stream: working on brief X, or waiting on you with a question.
You answer in one place: via the orchestrator seat, which is itself a real agent session started from a written brief.
You don’t pay the cognitive tax of remembering to encode reality into cards.

You still make decisions. You just stop maintaining a second world state by hand.

Update latency: snapshot tools vs live status

Manual boards have update latency that is entirely human:

When you’re in the zone, you ignore the board. It drifts.
When you remember the board, you lose time you could use on code review.

This latency matters because:

51% of professional devs already use AI tools daily (Stack Overflow 2025).
46% actively distrust AI output, and only 3% “highly trust” it.

So you already know you need to verify agent work. A stale board can’t help you verify anything.

Maxxwell’s status stream cuts that latency down to whatever your terminal can report:

A worker stuck on “needs sign-in” shows up promptly as needs sign-in.
A session that hasn’t responded in a while is marked possibly stalled or not heard from.
Context pressure is read live, with tiered warnings, plus a one-click compact when you decide to apply it.

You still decide whether to compact and how to re-aim a stalled session. Maxxwell does not auto-correct drift or restart stopped work. But you see the problem earlier, without having to curate a board.

Comparison: Monday-style boards, Herd, DIY scripts, Maxxwell

Here’s how common options stack up on attention cost and update latency.

Criteria that matter

For multi-agent coding work, the relevant axes are:

Attention cost: how much time you spend managing the tool instead of reading agent output.
Update latency: how far status can drift from reality before you notice.
Source-of-truth count: how many places can contradict each other.
Control posture: who presses enter, and who decides what runs.

Monday-style boards

Think: Monday.com, Jira boards, Notion Kanban.

Attention cost: high; all state changes are manual.
Update latency: high, tied to when someone edits the board.
Sources of truth: at least two - board vs terminals / IDE.
Control: indirect; the board doesn’t control the agents, it just describes them.

This works for classic project tracking with human tasks. It breaks down when each “task” is a live agent session running scripts and editing code.

Herd and similar orchestration dashboards

Tools like Herd market real-time monitoring and multi-agent orchestration. They optimize deeper coordination: workspaces, parallel runs, guardrails.

Strengths:

Real-time run view and sometimes automatic data collection.
Agent work often lives inside a controlled environment (cloud IDE or sandbox).

Trade-offs:

They usually bring their own agent runtime or wrap yours, which can feel like switching stacks.
Some hide your real terminal behind their interface.

If you want a managed cloud agent platform, these can be good. If you want to keep your own tools and terminals, they’re heavier than a board, and heavier than Maxxwell.

DIY tmux + scripts

A lot of devs solve this with tmux and some shell glue.

Typical pattern:

# simple "monitor" alias
alias lanes='tmux list-windows && tmux list-panes'

Pros:

Minimal attention cost; no board to maintain.
Zero abstraction; you see exactly what’s running.

Cons:

Status is whatever you remember from the last glance.
No structured notion of “waiting on you” or “blocked”; it’s just logs.

You can script some heuristics, but you’re building your own status layer.

Maxxwell’s live agent status stream

Maxxwell sits between tmux and full-blown platforms:

Attention cost: low; state is read from sessions, not manually maintained.
Update latency: low; status follows actual terminal behavior.
Sources of truth: one; your terminals and Maxxwell’s view are aligned.
Control posture: you press enter. Fleet controls draft text into the composer; nothing runs until you send it.

You get visibility without surrendering control or swapping out your existing agents.

Where Maxxwell’s conductor seat replaces the board

The orchestrator seat is a single agent session, started from a brief, that you talk to instead of juggling a dozen terminals.

Mechanics:

You describe the overall goal: add pagination to all list endpoints, refactor auth across services.
The conductor starts workers, assigns scopes, and reports back:
- What landed (files changed, tests added).
- What it decided on its own (safe, local choices).
- What needs your call (schema changes, API contracts, risky refactors).

Instead of changing cards:

You ask: “what’s stuck?” and get a summarized answer from an agent sitting above the fleet.
You answer questions once, in language, and the conductor propagates decisions.

Critically, Maxxwell does not auto-correct drift, auto-compact context, or restart stopped work on its own schedule. It surfaces problems and drafts controls; you stay the one who sends commands.

When you should still use a board

Manual triage boards are not obsolete. They’re just the wrong tool for live agent orchestration.

Keep using a Monday-style board when:

You’re tracking human work over days or weeks.
The “task” is a planning or comms unit, not a running process.
The people involved don’t live in terminals.

Use Maxxwell’s live status view when:

You regularly have 3+ coding agent sessions running at once.
You care about tests, review, and what lands on main.
You want to stay in your own tools (Claude, Codex, Cursor, local repos) while seeing everything in one place.

If you’re only ever running a single agent at a time, Maxxwell is probably extra. The coordination cost isn’t high enough yet.

FAQ: Herd vs herded in real workflows

How do I track AI agent progress without a board?

With Maxxwell, progress is visible as live session state plus the conductor’s return report.

You see:

Each worker’s state (working, waiting on you, blocked, etc.).
Which sessions changed files or added tests.
What’s still pending your decision.

You don’t need a card to say “doing X” because the worker’s own log and status already say it.

Can Maxxwell replace Herd or Monday in my team workflow?

It replaces them specifically for herding coding agents.

You might still keep Monday/Jira for sprint tracking and non-code work.

For agent orchestration:

Maxxwell runs locally, with no sign-up or server.
Workers are your existing Claude/Codex/Cursor sessions in real terminals.
The conductor seat is where you reason about the fleet.

What about teams that need approvals and compliance?

GitHub’s Agentic Workflows and platforms like Herd put strong emphasis on sandboxing, budgets, and compliance.

Maxxwell takes a simpler stance:

It keeps you in control by drafting fleet changes instead of acting.
It never runs a command until a person presses enter.

If you need formal approvals and audit trails, combine Maxxwell with your existing git workflows and review tools.

How does Maxxwell handle context pressure and long sessions?

Maxxwell shows live context-pressure readouts with tiered warnings.

When the context is getting tight:

You see it in the status view.
You have a one-click compact option when you choose to apply it.

It does not auto-compact or recycle context on its own. You decide when to intervene.

Does Maxxwell kill sessions when I quit the app?

No.

Sessions outlive the app:

Quitting Maxxwell detaches from workers; it never kills them.
Closing your laptop is not a decision to throw away work.

You can reattach later and pick up where you left off.

If you’ve hit the “I have eight sessions open and I am the slowest part of this” point, the real question isn’t which agent to use. It’s whether you want to herd them in a board, or read them from a live status stream.

Maxxwell exists to make that second option practical.