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.
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.
- Every card shows what it was briefed with — memories, handoffs, attachments — and which session that context came from.
- Chains render as arrows, fan-outs as one raced group until you keep a winner, schedules as trigger nodes with an Upcoming drawer for what runs next.
- Machines you connect add their projects to the same canvas — one map for everything, local or remote.
Race Claude against Codex, keep the best attempt
Fan a hard task out to parallel lanes — Claude Code on one, Codex on another, or the same agent at different models — each in its own isolated git worktree. Compare the finished diffs, keep the winner, and let the scoreboard tell you which agent actually wins on your code.
- Up to four lanes per fan-out (two on Free), each an independent session in an isolated worktree — no shared state, no lanes stepping on each other.
- Mix agents per lane, or vary model and effort, so you’re testing approaches instead of rolling the same dice four times.
- Compare & keep: side-by-side diffs, an optional AI-judge verdict that never sees which agent wrote what, one click to keep the winning branch.
- Losing attempts fold away rather than get deleted — “actually, the second one was right” is a click, not a rerun.
- A cross-agent scoreboard in Git Insights counts which agent’s winning work actually landed on your main branch.
- 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 accounts.
Audit your whole codebase with one click
Fan out a fleet of review agents — dependency health, test gaps, architecture, security, dead code, change hotspots, and your agents’ own config — 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.
- Seven lenses, each its own agent running in parallel: dependency health, test coverage & gaps, architecture & coupling, security surface, dead code, change hotspots, and agent config.
- Change hotspots read your git history: which areas churn, who touches them, and where that churn lands on code nothing is testing.
- The agent-config lens audits checked-in skills, hooks, MCP servers and CLAUDE.md / AGENTS.md for hidden instructions and risky settings — the code measures, the agent only explains.
- 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 see what changed since last time, and export the whole report as one self-contained HTML file.
- Read-only by design: each lens gets a narrow allowlist of measurement commands and can’t touch your working tree. Works in any language, with that ecosystem’s own tools.
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. Or aim it at a session that already knows the context.
- 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.
- Or target an existing session: the prompt arrives as its next turn, with everything that session already knows. Busy or waiting on you? The run is skipped, never piled up.
- Missed a run because your computer was asleep? 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, effort and skills per schedule, see what runs next on the canvas, 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.
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.
- Reply to any earlier turn inline, and send several replies back in one message.
- 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.
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.
- The session card shows what was loaded, so you always know what the agent was told.
Load context
✕Review the diff, send it back to the agent
Read the diff of every change line by line, see how the changed files fit together on a change map, comment on any line, and send it straight back to the agent to fix. Plus the full git muscle — merge, rebase, cherry-pick, conflicts, PRs and CI.
- Inline diff of every change an agent makes — read it line by line before it merges.
- A change map draws how the changed files import each other, with one hop of unchanged neighbours — a 30-file change reads as one picture, in any language.
- 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.
- Merge conflicts resolved in the app: take a whole side per file, or go hunk by hunk and hand-edit the rest.
- A commit graph with branch names on every lane, and branches grouped into folders by prefix, with colour labels and notes of your own.
- Drag-and-drop merge and rebase, squash a range into one commit, cherry-pick, revert and stash straight from the UI.
- Pull requests and CI runs in the branch drawer — nightly and deploy runs too — with re-run on failed jobs.
Plugged into the tools you already use
Your forge, your tracker, and your agents’ tools, wired in from one pane. PRs, CI and issues from GitHub, GitLab or Azure DevOps. Tickets from Linear, Jira, ClickUp, Sentry and Notion one # away. A failing build becomes a briefed session in two clicks.
- GitHub, GitLab and Azure DevOps: pull requests, CI runs and issues in the Git page, through each forge’s own CLI — sign in with a device code, nothing pasted.
- Clone straight from your forge, and pick which remote is the default for pushes and PRs.
- Type # in the composer to attach a Linear, Jira, ClickUp, Sentry or Notion item — the agent gets the ticket itself, not a link to go find. Type a key like #ENG-142 to look up one that isn’t listed.
- Send a failing CI run or a PR to a session: fix the failure, review the PR, or address its review comments — to a running session or a fresh one.
- One-click tool tiles for Figma, Gmail, Google Calendar, Linear, Sentry and Notion connect them to your agents — no JSON config.
See it run, right there
Agents build; you check. A real terminal in every project without leaving the app — start the dev server, run the tests, see what the agent actually did.
- A real terminal per project, inside the app — no cmd-tabbing away to check what the agent actually did.
- Your package scripts in a searchable picker, one click to run.
- When the agent needs to click through the app itself, it gets a browser of its own — watch it live, and take the wheel when it hits a login.
- 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.
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 computer. 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 computer — 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.
From 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 or GitLab 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”.
Every machine you own, one window
Connect the computer 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.
Know what every agent costs, and what it shipped
Live spend per session, project and model, your subscription’s real 5-hour and weekly usage, and Insights that join it all to your git history — how much of what landed on main came from Claude, Codex, or you.
- Live cost per session while the agent works — today, this week, this month, all time — with a daily heatmap and per-model breakdowns.
- Your Claude and Codex subscription limits as real percentages — the 5-hour window and the week — not just a warning when you’re nearly out.
- Working time, measured from what your sessions actually did, and cost per active hour.
- Git Insights: how many lines landed from each agent and from your own hands, how long a turn takes to reach main, and what the work that landed cost.
- Run an analysis for up to five findings about how you work with agents, each one citing the numbers behind it.
- All computed on your machine, across every agent and machine you run — one view, not four dashboards.
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.
- Both agents’ skills in one pane, scanned for risky instructions — and skills installed from GitHub are checked before they land.
- Auth status per CLI at a glance, so “it silently logged out” stops costing you an afternoon.
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
Editor & project map
For the quick look and the small fix — without leaving the place your agents work.
- Open, edit and save any file in the project, and compare your edit with what’s on disk.
- A project map beside the editor draws how files import each other; the file in your active tab is lit up with its dependencies.
- Start from any folder: right-click it in the file tree and pick “Show map of this folder”.
- Select code and send it to a session’s review tray in one gesture.
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, and a heads-up when it passes three quarters of its window — before compaction 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.
- Move a session into its own git worktree mid-conversation, keeping everything it knows.
Agent browser
Give a session a browser of its own, watch what it does with it, and take the wheel the moment it hits a login.
- One isolated browser per session, running on that session’s machine — the agent drives it with the standard Playwright tools while the canvas shows what it sees, live.
- Take over whenever you like: click, scroll and type into the node yourself. Signing in by hand is the case this exists for — the agent carries on from the page you leave it on.
- Open more tabs, go back and forward, and copy-paste between the agent’s browser and your own machine.
- Frames follow your attention — collapse the node or scroll it off screen and the stream stops while the agent keeps working.
- Nothing to configure: the first run installs a headless Chromium for you, and the agent’s snapshots are written outside your repository.
- Claude Code and Codex sessions alike. Free runs one browser at a time; Pro runs one per session.
Sessions that message each other
Agents hand work to each other by name, so you stop being the messenger between two windows.
- A session can ask another by name — including sessions you started in a terminal outside Foreman.
- Ask a quick question on the side with btw: a read-only side chat that knows the session’s context and leaves no trace in it.
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.
- Pick the microphone; a silent one is called out by name instead of transcribed as gibberish.
- 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 — and reset a stuck sign-in in one click.
- 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.
History search
Search every session you’ve ever run, on every machine, from one panel (⌘⇧F).
Checkpoints
Every turn is a checkpoint — see what it changed, and rewind the files to before it.
Themes & Schematic look
Light and dark themes from the editors you know, plus a Schematic style for the whole app.
OS notifications
Get pinged when an agent needs you or finishes — even with Foreman in the background.
Free on macOS, Windows and Linux. Your agents, your keys, your machine.
macOS, Windows and Linux — all formats.