Daily standup with AI: how I report what 5 agents did overnight

Five parallel AI agents produce more output than a human can scan. Without a structured daily routine, "what happened overnight" becomes its own time sink — half an hour every morning trying to remember which session was which and what each one did.

This post is the 15-minute standup we use to handle the overnight queue.

The daily standup, in 15 minutes

The routine, top to bottom:

Step 1 (1 min): list active sessions

cmux list

Output:

NAME                       DIR                                       STATUS
rewrite-auth-main          ~/dev/sessions/2026-04-22-rewrite-auth    needs-review
draft-launch-post          ~/dev/sessions/2026-04-22-launch-post     running
port-ios-appkit            ~/dev/repos/mq-dir                        idle
bisect-perf-regression     ~/dev/repos/api-server                    needs-review
research-cache-papers      ~/dev/sessions/2026-04-23-cache-research  done

Five sessions, three statuses (needs-review, running, idle/done).

Step 2 (5 min): review the "needs-review" sessions

For each session in needs-review:

1. Open the worktree's diff: cd <worktree>; git diff main
2. Skim: did the agent do roughly what was asked?
3. Decide: merge / iterate / revert.

mq-dir's pane setup helps here: focus the pane on the worktree, the file list shows changed files, the preview shows current selection. Skim through 5-10 changed files in 2-3 minutes.

If the work looks good: merge or commit-as-is for later PR. If the work needs adjustment: write a follow-up prompt for the agent. If the work is wrong: revert the worktree and re-prompt with sharper scope.

Step 3 (3 min): catch up "running" sessions

For each session still running:

1. Attach: cmux attach <session>.
2. Look at the most recent agent output.
3. Read the last 20-30 lines.
4. Confirm progress is on track.

If on track: detach (Ctrl+B D) and let it continue. If off track: provide guidance or re-scope.

Step 4 (3 min): handle "done" sessions

Sessions where the agent finished and there's nothing left to do:

1. Final review of the worktree diff.
2. Merge to main, tag, or commit-and-push.
3. cmux kill <session>.
4. Optionally archive the session directory: mv <session-dir> ~/dev/sessions/_archive/.

This frees the slot for a new session.

Step 5 (3 min): plan today's new sessions

Based on what landed and what's still in flight, decide:

• Which existing sessions need new prompts (already covered in Step 2/3).
• Which new sessions to spawn for today's tasks.

For each new session:

init-session.sh <verb-noun>
# fill in CLAUDE.md
worktree-init.sh <repo> <branch> <session-dir/repo>
cmux create <verb-noun-scope> --dir <session-dir>
cmux attach <name>
claude-code
> Read CLAUDE.md and start.

(See the templates post for the helper scripts.)

Detach from the new session; let it run.

What the standup gives you

After 15 minutes:

• All overnight work reviewed.
• Drift caught (sessions that wandered off-scope).
• Stalled sessions unblocked or killed.
• New work for today queued.
• Mental model of what each agent is doing today.

You start the workday with a clear picture and zero "wait, what was I doing?" friction.

File-manager setup for standup

The mq-dir layout for standup:

• Pane 1 (top-left): ~/dev/sessions/ — list of all session directories with modified-time sorted to top.
• Pane 2 (top-right): focused session's worktree — the diff is here.
• Pane 3 (bottom-left): notes pane — notes.md of the focused session.
• Pane 4 (bottom-right): cmux pane — attach to read recent agent output.

⌘1-4 cycles focus through them. As you process each session, click into mq-dir's CMUX sidebar to update which pane shows what.

This compresses the alt-tab cycle that would otherwise dominate standup time.

Output: what the standup produces

The standup ends with two artifacts:

1. A morning summary (mental, optionally written)

For solo work, this is mental. For team contexts, write it as bullets:

Standup — 2026-04-23

• rewrite-auth-main: agent finished JwtAuth core. Diff looks good; merging today.
• draft-launch-post: still iterating on the headline. Provided new direction.
• port-ios-appkit: idle since yesterday — re-promoted with sharper scope.
• bisect-perf-regression: agent identified the regression commit. Plan: write fix today.
• research-cache-papers: done. Synthesis posted to /research/. Killing session.

Today's new sessions:

• debug-tab-state-bug: investigate the tab persistence regression filed yesterday.

Send this to a Slack #ai-status channel for team awareness, or just keep it in your daily journal.

2. An updated session queue

ACTIVE:
- draft-launch-post (running, mid-iteration)
- port-ios-appkit (running, fresh prompt)
- bisect-perf-regression (running, fix phase)
- debug-tab-state-bug (new)

DONE/ARCHIVED:
- rewrite-auth-main (merged)
- research-cache-papers (done)

This is your active fleet. Glance during the day; dive in for next standup tomorrow.

Anti-patterns

Skipping standup

"I'll just check on agents when I have time" → 30 minutes lost across the day with poor visibility. The 15 minutes saves more than itself.

Marathon review

If you spent 90 minutes reviewing one session's output, the agent probably went wider than scope. The right reaction: re-prompt with sharper scope OR revert and restart.

If reviews regularly take >60 minutes, the bottleneck is upstream (sessions are too unscoped). Tighten CLAUDE.md.

Reviewing without acting

Reviewing the diff and then doing nothing means the work isn't moving. Each review should end with a decision: merge / iterate / revert / kill.

Treating "running" as an excuse to defer

Sessions that have been "running" for 24 hours without progress are probably stuck. Kill or re-prompt. Don't let them rot.

Not killing finished sessions

A done session that stays in cmux list clutters the view. Kill aggressively.

Variations

Solo workflow

As documented above. 15 minutes, no audience.

Small team (2-5 people)

Each person runs their own fleet, does their own standup. Optionally cross-share via Slack at end of standup ("here's what my agents did") for team context.

Larger team (5+)

Standup becomes async (each person posts their summary in a thread; no synchronous meeting). Agents become individual contributors with their own status updates.

High-velocity day

If you're shipping aggressively, do mini-standups every 4-6 hours instead of just morning. The structure scales to whatever cadence you need.

Low-velocity day

If sessions are long-running (overnight refactors), one standup per morning is enough. Don't over-process.

Tooling

The minimum viable standup:

• cmux list — session inventory.
• git diff main — review changes.
• mq-dir's CMUX sidebar — visual session list.

Optional additions:

• A standup script that runs cmux list + git status for each session and produces a single summary file.
• A keyboard shortcut to toggle mq-dir's "standup layout" Project (panes pre-configured for review).

Verdict

Daily standup with AI agents is a real workflow ritual, not optional. 15 minutes pays back several hours of mid-day "wait, what's that session doing?" friction.

The structure:

1. List sessions (cmux list).
2. Review needs-review (each one's diff).
3. Catch up running (each one's recent output).
4. Handle done (merge + kill).
5. Plan today (new sessions).

Tooling: cmux + mq-dir + git diff. All free, all open-source.

If you're running 2+ parallel agents and don't have a daily standup, you're losing time you don't see. Add it for a week; you'll feel the change.