Agentmaster

By developers, for developers - Never lose a session again - feel like Windows Terminal so you forget you are vibing

Microsoft Windows Terminal but pumped up with observability, persistence and all the tools you need to scale up your parallel context management.
Coding fast is no longer about typing faster but about holding and manuvering around and between 10 coding contextes.

Each session is a real claude.exe on a ConPTY connection: a full-fidelity terminal with a shared stdin (you and the orchestrator coexist), output tapped for the UI, and semantic state from Claude Code hooks and an out-of-band observer — never screen-scraping.

The Agent Manager — one click on the tab strip's Home button — is mission control: a Triage Board that sorts every session into Running · Waiting-for-you · Needs-approval · Error · Done, an Explorer Tree of your working-dirs → sessions, and a Prompt Queue to queue prompts per session. Click a card and its terminal tab follows — both ways, across every window — so you never lose which tab is which. A side panel beside the terminal keeps the session cards in view while you work.

Close a window and reopen it whole: geometry, resumed Claude and Codex conversations, shell tabs back at their real cwd, even the focused tab. And the Sessions browser searches every conversation that's ever hit disk — an instant index, then ripgrep across the actual content — so you can Resume or Fork anything, from any day. Closing only archives a session; your transcripts are never deleted. Your workspace also survives installs and version changes:

• no install, update or uninstall deletes Agentmaster's state;
• a state file that cannot be read is kept instead of saved over;
• a window holds on to the tabs it could not bring back;
• every save keeps what another version wrote;
• each new version first copies your state files into backups\.

The Fleet Observer detects, correlates, and enriches every Claude/Codex session by reading process memory and transcripts out-of-band — no hooks, no setup, completely invisible to the shell. Hand-type claude in any tab and it's managed within seconds. Sessions running outside the app show up too: watch them read-only, or adopt them (fork a safe copy, or resume).

State is never screen-scraped: it's hook-derived and then self-healed from the transcript, so dropped or out-of-order events can't lie to you. It drives a board column and a hover card carrying the conversation's recap ("what we did / what's next"). Waiting-for-you works like an unread inbox: a finished turn stays flagged until you've actually looked at it.

You never have to open the Manager to read a session. Every classified tab wears a state-colored dot in the strip and a top-right overlay badge — status · model · effort · kind · Prompt Queue Runner · queued · workdir/branch · the next queued prompt — that flips live as the session moves, with a one-hover copy menu — also on the tab's right-click menu — for its id / path / branch / real launch CLI / summary / transcript. The badge's pencil unfolds a per-tab summary panel (plan · tasks · prompts · files read/created/edited), and a per-prompt Jump (or Alt+↑/↓) scrolls straight to where a prompt was sent. Even a plain shell tab keeps a dim ○ kind · unlinked twin — nothing in your strip is a mystery.

Turn on the Telegram bot (Settings → Messaging, with a bot of your own; only your account is answered) and every working session becomes a topic on your phone: its whole conversation, Claude's replies with their Markdown rendered, and a live status card with buttons. A message in a topic is queued as that session's next prompt (/steer sends it into the running turn). From the phone you can:

• answer Claude's questions with a tap;
• send a 🎤 voice note, transcribed with that session's own vocabulary and read as its prompt;
• see the terminal's screen, which every status card carries as it updates;
• see the whole conversation as tall pictures (📜 All Screen), file diffs included;
• press Esc, deactivate, fork or restart a session, and read its /status and your plan usage;
• start a new session in any folder and window;
• ask the 🔎 Search topic to find and reopen old sessions.

And the small stuff that adds up: ★ favorite a session to pin it, permanent per-directory tab colors (a folder keeps its color across tabs, windows, and restarts), per-install profiles so a from-source dev build sits beside the release, and a Settings cog for the knobs (model · env · Prompt Queue Runner defaults).

• Prompt Queue Runner — auto-sends the next queued prompt on turn-complete (per session: Auto or Paused, plus one Pause for all sessions), with stop-on-error · max-sends · pause-on-input · question-guard · Enter-retry, and savable plan templates.
• AI search — the Sessions page's AI toggle takes a request in plain words; a hosted Sonnet 5.5 reads your sessions, shows the ones that fit with the evidence, and can reopen them into the window you choose.
• Presets — launch or fork a session on other models and providers (OpenRouter, Xiaomi MiMo, NanoGPT, your own RunPod endpoint, any Anthropic-compatible URL), keys kept in Windows Credential Manager.
• Show Transcript — any conversation as Markdown in a reading view; Copy ▸ Transcript at five detail levels.
• Deactivate — park a session's claude while its tab keeps its place; entering the tab resumes the conversation. Deactivate All Idle Tabs parks every idle tab, and Deactivate All Waiting-for-you every tab waiting for you (each stays Waiting-for-you), in this window or all of them.
• agentmaster CLI — query the fleet from any shell, app up or down (show / list / sessions / tabs / windows / external, --self, --json).
• In-app updater — checks GitHub on launch and from Settings → Updates; one-click update, pre-release and (warning-gated) nightly opt-ins, and uninstall. Nightly builds — unstable dev versions, tag contains nightly — are always skipped unless you accept the nightly opt-in.
• Keep Awake — toolbar toggle (Off / Always / While-Running) so the machine won't sleep mid-run.
• Context-window usage — every card shows how full the conversation's context is (e.g. ctx 182K).
• Never dead-ends — quit an agent and you land on a live shell prompt at its cwd, not a dead pane.
• Sessions row Filter — right-click a row to narrow the list by dir / branch / day / week / month / fork-family.
• Favorite crown — a starred session wears a gold crown on its tab-strip dot.
• Home / jump back — one button in the tab strip opens the Agent Manager; while it is open, the same button turns into a back arrow that returns you to the session's tab.
• Hide / Unhide — drop a session from the Sessions list (reversible; the transcript is untouched).

In active use, shipping regular releases. The full pipeline runs end-to-end in the packaged app; the standalone engine harness passes 10,000+ checks.

• Claude Code — fully managed: launch · observe · drive · persist · restore.
• Codex (OpenAI Codex CLI) — managed for observe + state + the full launch / restore / adopt lifecycle (driving its TUI is next).
• Every session — the Observer manages them whether they fire hooks or not; external ones stay read-only until you adopt.
• Installs side-by-side under its own identity — your real Windows Terminal is left untouched.

One line, no download — paste into PowerShell (administrator rights not needed). It grabs the latest release, verifies its checksum, and asks where Agentmaster should live:

• [1] Just for you — the default: no administrator rights, now or for any update. Desktop icon, Start menu, an "Open in Agentmaster" folder right-click entry, Apps & Features and PATH, in ~/.agentmaster\bin.
• [2] For all users of this PC — one administrator approval (only that step is elevated); every user keeps their own data; updating it needs an administrator again.
• [3] As the app package (MSIX) — an administrator trusts each release's signing certificate once (every release has its own).

& ([scriptblock]::Create((irm https://raw.githubusercontent.com/Nucs/Agentmaster/agentmaster/tools/Install-Agentmaster.ps1)))

Flags: -Scope User|Machine|Package (skip the question) · -Version <x.y.z> · -ZipPath <zip> (install a portable zip you already have) · -Prerelease · -Nightly (also consider unstable nightly builds) · -Launch · -Force · -Uninstall (with -Scope) · -ForCurrentAccount. Run by an administrator from another account, or as SYSTEM, it installs for the user signed in to Windows and starts Agentmaster as them, without administrator rights; -ForCurrentAccount installs for the running account instead. Unattended (a scheduled task, a deployment tool): add PowerShell's own -NonInteractive.

Prefer the files? Grab them from Releases: the portable zip (unzip, run Agentmaster.exe — its first launch asks the same question: just for you (recommended), for all users, set it up for the signed-in user when another account runs it, a folder you pick, here, keep it portable, or later) or the self-signed .msixbundle (trust that release's Agentmaster.cer, then Add-AppxPackage). For debugging, each release's zips carry a public PDB beside every binary, and its _symbols.zip assets hold the full PDBs, Source-Linked to the release's commit.

First launch silently picks a per-install profile folder (~/.agentmaster) holding everything it persists. Requires Windows 10 19041+, x64/arm64, and a native Claude Code claude.exe on PATH (Codex optional).

• Start here: CLAUDE.md — full working notes (status by area, build/deploy, gotchas, correctness rules) · DESIGN · IMPLEMENTATION
• Internals: OBSERVER · HOOKS · STATE · SESSIONS · PERSISTENCE · PROFILES · CLI · TAB_OVERLAY

Build it with VS 2022 (Desktop C++ + UWP workloads, Windows SDK 10.0.22621/26100):

pwsh -File .\tools\Build-Agentmaster.ps1            # first build (restores packages)
pwsh -File .\tools\Build-Agentmaster.ps1 -NoRestore # inner loop

To run from source, deploy the loose layout (registers the dev identity AgentmasterDev, which coexists with the release):

Add-AppxPackage -Register ".\src\cascadia\CascadiaPackage\bin\x64\Debug\AppxManifest.xml" -ForceUpdateFromAnyVersion

Our code is additive and marked Agentmaster: the Manager UI in AgentManagerContent, the plain-C++ engine + Fleet Observer under src/cascadia/TerminalApp/AgentMaster/, the per-tab overlay AgentTabOverlay, and small touches at the TerminalPage / Tab integration points.

A fork of microsoft/terminal at v1.24.2372 — pristine upstream on main, the fork's work on agentmaster; upstream code, docs, and notices are retained (NOTICE.md).

License — dual. The Agentmaster combined work is licensed under the GNU AGPL-3.0-or-later, with a commercial license available for uses the AGPL doesn't fit (closed-source, or offered as a network service). Because Agentmaster forks MIT-licensed Windows Terminal, the upstream Microsoft code and the bundled OSS components remain under their original permissive licenses — the original Copyright (c) Microsoft Corporation MIT notice is retained in LICENSE-MIT, with third-party attributions in NOTICE.md. "Agentmaster" is a trademark of the project (TRADEMARKS.md); this is an independent fork, not affiliated with or endorsed by Microsoft. Contributions require signing the CLA. For Windows Terminal itself, see aka.ms/terminal-docs.

This feels like the entire codebase went into Form1.cs, but patience and careful designing made this little gem.