Maxxwell by Rindler
Writing

Moving a Monday-Style Board to Agent Sessions

2026-10-11

By the end of this tutorial you’ll have your Monday-style workflow running in Maxxwell: same columns, same tags, but now tied directly to real coding agent.

By the end of this tutorial you’ll have your Monday-style workflow running in Maxxwell: same columns, same tags, but now tied directly to real coding agent sessions instead of a status board plus a dozen terminals.

You’ll:

Prerequisites

Before step 1, you need:

Common failure at this stage: trying to design a new workflow from scratch.

You’re not doing that. You’re mechanically mapping what you already use into Maxxwell’s herd view.

1. Snapshot your current Monday-style workflow

You need a concrete snapshot of how your board works today. This is the baseline you’ll mirror in Maxxwell.

Do this:

  1. Export or copy your current board structure
    • List out columns:
      • Status column (e.g. Backlog, In Progress, Stuck, Done)
      • Owner / assignee
      • Tags / labels
      • Notes / comments
    • Save this as a text or markdown file in your repo:
cd your-repo
cat > workflow_snapshot.md << 'EOF'
Statuses: Backlog, In Progress, Stuck, Waiting for Review, Done
Tags: backend, frontend, infra, priority:high
Assignee: single owner per item
Notes: freeform comments in Monday
EOF
  1. List 5-10 active items on the board
    • Example:
# Active items
1. Implement login rate limiting [backend, priority:high] - In Progress
2. Fix cursor-agent workspace leak [infra] - Stuck
3. Refactor profile settings form [frontend] - Waiting for Review
4. Add audit log export CLI [backend] - Backlog
5. Update Claude prompts for test generation [infra] - In Progress

Common failure: being vague about statuses.

If you can’t write down exact values and how you use them, you’ll end up with a fuzzy herd view that doesn’t match the way you actually work.

2. Map Monday statuses to Maxxwell herd labels

Maxxwell’s herd view shows each agent session with a concrete state:

You’ll create a simple mapping from your board’s statuses into these labels.

  1. Add a mapping section to your workflow_snapshot.md:
echo '
Status → Herd label
-------------------
Backlog             → not started
In Progress         → working
Stuck               → blocked
Waiting for Review  → waiting on you
Done                → done
EOF' >> workflow_snapshot.md
  1. Make one explicit rule for each Monday state:

Common failure: overloading blocked for everything.

Keep blocked for genuine external constraints (e.g. missing credentials, failing build). Use waiting on you for decision/clarification needed.

3. Install and open Maxxwell’s herd view

Now you bring Maxxwell into the workflow and get a single window to replace scattered boards and terminals.

3.1 Install Maxxwell

Follow the docs for your OS, but the shape is:

macOS (CLI via Homebrew):

brew tap rindler/maxxwell
brew install maxxwell

Linux (CLI):

curl -sSL https://docs.maxxwell.dev/install.sh | bash
# or: download from docs and move maxxwell into your PATH

Desktop app:

3.2 Launch the herd view

CLI example:

cd your-repo
maxxwell herd

Desktop example:

You should see an empty orchestrator seat and no workers yet.

Common failure: running Maxxwell in a random directory.

Start it in the repo you actually care about; sessions should attach to the working tree you’re already using.

4. Create an orchestrator that replaces your board

The orchestrator in Maxxwell is itself a real coding-agent session, started from a written brief. You talk to it instead of to twelve terminals, and it reports what landed, what it decided for you, and what needs your call.

This is the piece that replaces:

4.1 Write a brief from your board snapshot

Create orchestrator_brief.md next to your repo:

cat > orchestrator_brief.md << 'EOF'
Goal: replace the current Monday-style board with a Maxxwell herd view.

You are the orchestrator. Your job:
- Track 5 active tasks from workflow_snapshot.md
- Keep each task mapped to one worker session
- Report which sessions are working, idle, blocked, waiting on me, or done
- Summarize what landed (merged, ready to merge) vs. what needs my decision

Use the following status mapping:
Backlog             → not started
In Progress         → working
Stuck               → blocked
Waiting for Review  → waiting on me
Done                → done
EOF

Common failure: giving the orchestrator a fuzzy “help me manage agents” prompt.

Be explicit. This is your board logic encoded as text.

4.2 Start the orchestrator seat

From the CLI:

maxxwell orchestrator --brief orchestrator_brief.md

Or in the desktop app:

You now have:

Common failure: treating the orchestrator as another worker.

The orchestrator doesn’t write code for a single task. It coordinates workers and tells you where attention is needed.

5. Stand up workers mapped to items instead of cards

Now you map concrete items from your old board to Maxxwell worker sessions.

Each item gets:

5.1 Start workers for each active item

Take your earlier list:

1. Implement login rate limiting [backend, priority:high] - In Progress
2. Fix cursor-agent workspace leak [infra] - Stuck
3. Refactor profile settings form [frontend] - Waiting for Review
4. Add audit log export CLI [backend] - Backlog
5. Update Claude prompts for test generation [infra] - In Progress

For each item, start a worker via the CLI or UI.

CLI example for item 1:

maxxwell worker \
  --name "login rate limiting" \
  --tags "backend,priority:high" \
  --brief "Implement rate limiting on login endpoint; add tests; keep existing auth flow intact."

Repeat for items 2-5, adjusting --name, --tags, and --brief.

In the desktop app:

5.2 Set initial herd labels to match board statuses

For each worker, set the initial state according to your mapping:

Maxxwell tracks these per session and shows them in the herd view:

Common failure: starting workers without briefs or tags.

If you don’t encode the item title and tags into the session, you’ll end up with anonymous panes that are harder to reconcile with your old board.

6. Use fleet controls to draft changes instead of acting

One distinctive property of Maxxwell: fleet controls draft rather than act.

This is where you replace board edits and comment threads with concrete orchestration moves, while keeping control.

6.1 Move an item from Backlog to In Progress

In Monday, you’d change a status cell.

In Maxxwell, from the orchestrator seat:

  1. Select the worker for Add audit log export CLI
  2. Use a fleet control like Start work (name may vary slightly per build)
  3. Maxxwell drafts a message in the composer:
Please start implementing the audit log export CLI:
- Read events from the existing audit_log table
- Provide a command-line interface to export to JSON
- Add tests for large export batches
Mark this session as working.
  1. You review and press Enter

Result:

Common failure: assuming fleet controls auto-execute.

They don’t. If you don’t press Enter, nothing happens. That’s deliberate.

6.2 Handle a blocked worker

If a worker hits a build failure or missing secret, you mark it blocked.

From the orchestrator:

  1. Open the worker transcript
  2. See the error, e.g. missing STRIPE_API_KEY
  3. Trigger a Mark blocked control
  4. Maxxwell drafts:
You are blocked because STRIPE_API_KEY is missing in the environment.
Stop attempting further changes until I confirm credentials are available.
Mark this session as blocked.
  1. You can either send it or edit to add more detail

Herd view now shows the item as blocked, aligned with your old Stuck status.

7. Replace comments and pings with orchestrator reports

On Monday-style boards, most of the coordination lives in:

Maxxwell’s orchestrator takes that role and returns a report.

7.1 Ask the orchestrator for a status report

From the orchestrator seat, you can send something like:

Summarize the herd:
- Which sessions are working, idle, blocked, waiting on me, or done?
- For each working session, list the last concrete change (commit, diff, test).
- Separate what has landed from what is waiting on my call.

You get back something in this shape:

Working:
- login rate limiting [backend,priority:high]: added rate limit middleware, tests passing locally.
- Claude prompt updates [infra]: refactored test generation prompt, no code changes yet.

Blocked:
- cursor-agent workspace leak [infra]: blocked on reproducing leak; logs inconclusive.

Waiting on you:
- profile settings refactor [frontend]: tests green; waiting for your review and merge decision.

Not started:
- audit log export CLI [backend]: no work yet.

Done:
- none.

This report replaces your Monday “board view + comments + Slack” combo.

Common failure: still updating the Monday board manually.

Pick one coordination surface. If Maxxwell is the source of truth, stop doubly maintaining Monday statuses.

8. Shut the window without killing the work

One quiet but important part of this migration: sessions should outlive the app.

Maxxwell is local-first and respects that:

8.1 Verify persistence

  1. Start a worker doing something real, e.g. running tests or editing code
  2. Quit Maxxwell:
# In the desktop app, Cmd+Q / Alt+F4
# In CLI, Ctrl+C out of the UI
  1. Re-open Maxxwell and the herd view:
maxxwell herd

You should see:

Common failure: assuming Maxxwell owns your runtime lifecycle.

Your workers are your own unmodified tools - Claude, Codex, Cursor-agent - running as real terminal sessions you can attach to and take over at any moment. Maxxwell sits above them; it doesn’t replace them.

FAQ: troubleshooting your Monday → Maxxwell migration

How do I transfer Monday columns and tags into Maxxwell?

You don’t import Monday’s schema directly.

You:

The data lives in Maxxwell as text and labels, attached to real agent sessions instead of board rows.

Can Maxxwell automatically detect when a worker is building the wrong thing?

No.

Maxxwell surfaces:

It does not automatically correct drift or re-aim a session. You, via the orchestrator, stay the one who decides whether a worker is on track.

Does Maxxwell automatically compact or recycle agent context?

No.

What it does give you:

Maxxwell won’t silently rewrite or trim transcripts on its own schedule.

How does Maxxwell compare to keeping my Monday board and tmux scripts?

With a Monday board + tmux:

With Maxxwell’s herd view:

If you only ever run one agent at a time, this is overkill. Once you’re at 4-12 sessions, it removes a lot of manual tracking.

Can Maxxwell run hosted or require an account?

For ordinary local use: no.

You bring your own model access (API key or existing Claude/Codex subscription). Teams can pay for additional features, but the local orchestration behavior described in this tutorial is the same.