Everything in the control room
What each part of Foreman actually does with your Claude Code and Codex agents — in more detail than the front page, in less time than the docs.
Orchestration canvas
Your whole operation, on one canvas
The default view is a map, not a list: every project a box, every session a card with live status, git state, and cost. The difference between running agents and overseeing them.
- Sessions grouped inside project boxes, laid out automatically — pin what you want where you want it, the rest keeps tidying itself.
- Live status, diff stats, and cost on every card, so a glance answers “what is everyone doing?”
- The stage lens filters by what needs you: a plan waiting for review, changes to look at, work still running, or quiet.
- Chains render as arrows, fan-outs as one raced group until you keep a winner, queued issues as a triage band inside the project.
- Machines you connect add their projects to the same canvas — one map for everything, local or remote.
Parallel fan-out
Race the same task, keep the best attempt
Fan a hard task out to four agents in parallel, each in its own isolated git worktree. Compare the finished diffs side by side, keep the winner, discard the rest in one click.
- Up to four lanes per fan-out, each an independent session in an isolated worktree — no shared state, no lanes stepping on each other.
- Vary the model or effort per lane, so you’re testing approaches instead of rolling the same dice four times.
- Compare & keep: side-by-side diffs, an optional AI-judge verdict, one click to keep the winning branch and clean up the losers.
- Per-project setup scripts bootstrap every fresh worktree — deps, env, ports — before the agent starts, so lanes boot ready to work.
- Every lane launches through a shared gate that caps concurrency and backs off on rate limits, so a burst stays polite to your Anthropic account.
Project review
Audit your whole codebase with one click
Fan out a fleet of review agents — dependency health, test gaps, architecture, security, dead code — each measuring with your repo’s own tooling. The result is one structured report where every number cites its evidence, and every finding has a fix button.
- Five lenses, each its own agent running in parallel: dependency health, test coverage & gaps, architecture & coupling, security surface, and dead code.
- Measured, not vibes: every metric cites the exact command or file it came from, and anything the agent couldn’t verify is visibly marked as an estimate.
- Findings ranked by consequence, with the evidence quoted — the file, the lines, and why it matters in your repo specifically.
- Fix straight from the report: “Start session to fix” spawns an agent briefed with the finding, or copy it as a prompt for any session.
- Narrow a review to chosen folders, re-run it as the code moves, and export the whole report as one self-contained HTML file to share.
- Read-only by design: each lens gets a narrow allowlist of measurement commands — audit, outdated, counts — and can’t touch your working tree.
- Works in any language: lenses detect the ecosystem and use its own tooling, from pnpm audit to pip-audit to govulncheck.
Scheduled tasks
Put your agents on a schedule
Hand an agent a standing job and a time — once, every morning, or every Monday at 09:00 — and Foreman runs it unattended, leaving the result waiting for your review.
- Run a prompt once at a set time, or on a repeat — daily, or a chosen day and time each week.
- Isolated by default: each run lands on its own fresh git branch you review and merge — nothing touches your main checkout.
- Missed a run because your Mac was closed? It fires the next time you open Foreman, marked “ran late” so you know it caught up.
- Quiet unless it matters — a run with nothing to do finishes silently; you’re notified only when there’s a change to review, or a run failed (with the reason).
- Pick the model and effort per schedule, and keep a run history for every task.
Scheduled tasks
Run an agent prompt on a cadence. A missed run fires the next time Foreman opens.
What's new in the Claude CLI this week, and should we adopt it? Summarise the changelog and open a PR if a flag we use changed.
Run the test suite, check for outdated deps and flaky specs, and leave a short report in the session.
Permissions, plans & questions
Approve the work, not just the diff
Agents pause and ask in the chat, not in a buried terminal prompt. Approve each tool call, review the plan before a single file changes, answer questions with one click.
- Per-tool approval cards in the chat — approve or deny each command, edit, or web request as it happens.
- “Always allow” rules for tools you trust, so routine work never interrupts you twice.
- Plan review: the agent proposes its plan as a card, and nothing is edited until you approve it.
- Question cards: when the agent needs a decision, you get option pills and free-text — one click instead of a paragraph.
- A needs-attention inbox plus OS notifications, so a blocked agent never waits silently.
- Autonomy is per session: from ask-every-time to fully unattended, your call.
Project memory
Agents that remember your project
Curated memory per project — conventions, decisions, gotchas — that you pick and attach when a session starts. Yours to browse and edit; nothing gets injected behind your back.
- Curated memory cards per project — conventions, decisions, gotchas — written once, reused every session.
- Pick and attach exactly the cards a session needs via Load Context; nothing is injected silently.
- Edit, append, and prune every card in the UI as your project evolves.
- Claude Code’s own memory is browsable alongside Foreman’s, so you always know what the agent knows.
Load context
✕Git, built in
Review the diff, send it back to the agent
Read the diff of every change line by line, comment on any line, and send it straight back to the agent to fix. Plus the full git muscle — merge, rebase, cherry-pick, conflicts.
- Inline diff of every change an agent makes — read it line by line before it merges.
- Comment on any line and send it straight back to the agent to fix, no terminal round-trip.
- AI review of the diff, at the model and effort you choose — findings arrive as line comments you edit, delete, or send on.
- Pick which files get reviewed, then re-review just the one you fixed.
- Merge conflicts resolved in the app: take a whole side per file, or go hunk by hunk and hand-edit the rest.
- Branches and the commit graph with context menus everywhere — checkout, rename, delete, compare.
- Drag-and-drop merge and rebase, squash a range into one commit, cherry-pick and revert straight from the commit list.
Terminal & preview
See it run, right there
Agents build; you check. A real terminal in every project without leaving the app, and one-click preview of the dev server an agent just started.
- A real terminal per project, inside the app — no cmd-tabbing away to check what the agent actually did.
- One-click preview of running dev servers.
- Run your own commands while the agent works — the workspace is yours, not just the agent’s.
- Works on remote machines too: the same terminal, over SSH.
Session from phone
Steer your agents from your phone
Share a running session and open it in any browser — read the live transcript and send the next turn while work keeps running on your Mac. End-to-end encrypted, nothing stored.
- Share any running session to your account and open it in any browser — phone included.
- End-to-end encrypted: content is sealed on your phone and opened on your Mac — the relay sees ciphertext and routing metadata, never your code or prompts.
- Nothing stored server-side: pure pass-through relay, your machine stays the only source of truth.
- Read the live transcript, answer the agent’s questions, and send its next turn remotely.
- Revoke a share at any moment; access dies instantly.
Share Laptop
Make this machine available to your other devices. They connect through your Foreman account — encrypted end to end, with nothing exposed on your network.
Issue intake
From GitHub issue to working session
Browse your repo’s open issues inside Foreman, queue the ones worth doing, and start each when you’re ready — with the full issue as its brief, its own branch, and a PR that closes it.
- Browse and search open GitHub issues in-app; queue them to a per-project triage board. Queueing never launches anything — starting is always your explicit call.
- Start with one click on your defaults, or configure agent, model, and branch per issue.
- The session’s first turn carries the issue body and the freshest discussion, with a link back for anything clipped.
- Branches are namespaced (foreman/issue/N-slug) and the PR defaults to “Closes #N”.
Multi-machine
Every machine you own, one window
Connect the Mac in the other room with your account, or a headless build server over SSH. Their projects join the same canvas, and sessions survive disconnects.
- Share Laptop: account-based pairing through a lightweight companion app — no SSH keys, no port forwarding, no network fiddling.
- Classic SSH for headless build servers, with the same terminal and session tooling.
- Projects and sessions from every machine land on the one canvas, with status and cost per node.
- Sessions survive disconnects — pick them back up when the link returns.
Cost tracking
Know what every agent costs
Per-session and per-project spend, live while agents work — with a daily heatmap, per-model breakdowns, and the most expensive sessions called out.
- Live cost per session while the agent works — today, this week, this month, all time.
- A daily spend heatmap and per-model breakdowns.
- The most expensive sessions called out, so you know where the budget went.
- Works across machines and agents — one number, not four dashboards.
Multi-agent
Not married to one agent
Run the agent CLIs you already use — Claude Code and Codex — with install, login, and updates handled from the UI. Pick the model per session, and route each task to whichever agent is best at it.
- Claude Code and Codex CLI today — install, login, version checks, and updates handled from the UI.
- Pick the model per session — Opus for the hard problem, Haiku for the cleanup.
- One permission model, one memory, one cost view across every agent you run.
- Auth status per CLI at a glance, so “it silently logged out” stops costing you an afternoon.
Run on
Subscription or API key — you pick, per session
Interactive work runs on the Claude subscription you already pay for. Unattended work — schedules, fan-out bursts — defaults to your metered API key, the billed and policy-safe path for automation.
- A “Run on” toggle wherever sessions start: subscription for interactive work, API key for automation.
- Scheduled, bulk, and fan-out runs default to the API key, keeping unattended bursts off your subscription’s limits.
- Foreman never lifts your OAuth token into its own client — the official claude CLI owns auth, always.
- Every launch passes a shared gate that caps concurrency and honors rate-limit signals instead of hammering.
More in the box
Session branching & handoff
Context is the scarcest resource in agent work. Foreman lets you fork it, distil it, and carry it forward.
- Every session shows a live context meter, so you see compaction coming before it quietly eats your context.
- Handoff distils a long session into a curated digest and opens a fresh session carrying exactly the context you chose.
- Read the digest, edit it, regenerate it — and pick which model writes it.
- Fork a session to try two approaches in parallel; lineage stays visible in the graph.
- Chain a follow-up onto a running session: when it settles, the next session launches itself, seeded with the handoff.
Directives
Standing instructions you write once and attach to any session — so agents follow your rules without being reminded.
- Reusable instruction cards — coding standards, review rules, tone — prepended to every turn of a session.
- Attach one or several per session; edit them in one place and every future session picks up the change.
- Pairs with project memory: memory is what the agent knows, directives are how it behaves.
Voice dictation
Talk through a task instead of typing it.
- Dictation straight into the composer, one click from the keyboard.
- Fully on-device via whisper.cpp — audio never leaves your machine.
- Core ML–accelerated on Apple Silicon, so it keeps up with you.
MCP servers & plugins
Your agents’ tools, visible and managed in one place.
- Every MCP server your agents can reach, listed across global and project scope.
- Log in to servers that need auth with a guided flow — no JSON config spelunking.
- See which servers are connected before you start a session, not after it fails.
Setup wizard & diagnostics
From download to first agent turn without touching a config file.
- First-run wizard checks your CLIs, logins, and git setup, and fixes what it can with one click.
- Per-CLI auth status at a glance, with guided login when something expired.
- When a session fails to start, you get the reason on the card — not a silent spinner.
OS notifications
Get pinged when an agent needs you or finishes — even with Foreman in the background.
In-transcript search
Search inside any session’s transcript and jump straight to the match.
Streaming chat
Watch agents think and act live, with persistent history that survives restarts.
Free on macOS. Your agents, your keys, your machine.
Download for macOS