A terminal for multi-agent work
Keep a window full of agents on track
maiTerm runs Claude Code, Codex and your shells side by side — then shares a real kanban board with them, supervises them against rules you write, and brings every tab back exactly as it was. No LLM inside, no chat sidebar.
- Free — every feature, no paid tier
- No account — nothing to sign up for
- Source published
macOS, Windows and Linux.
Files
See what your agents read and change, as they do it.
Three agents in one repository, and the only record of what each touched is a transcript scrolling past. Which files did that turn change? Is anyone still in the one you're about to edit?
Press Cmd+Shift+B (Ctrl+Shift+B on Windows and Linux) for a project tree beside your terminals. It follows the
tab you're in — on SSH hosts too — and lights up as agents work: a file glows as an
agent reads it, and what each agent changes stays marked in that agent's colour.
This turn, this session
Narrow the tree to what the agents changed this turn or this session, or to one agent. Compare with Turn Start shows exactly what it did to a file on this computer, even on top of your own uncommitted changes.
Evidence, not guesses
A file an agent's edit tool named says so. One that changed while its shell command ran says that instead, because your own save at that moment would look the same.
A real file tree
Git colours and the branch, fuzzy find, preview tabs, rename, move and copy with undo, delete to the trash. Drag a file onto an agent's terminal and its path lands on the line, never sent.
Agent activity for Claude Code and Codex. The column opens, closes and changes width only when you do — nothing re-flows a streaming agent behind your back.
How Files worksChrome extension
Hand an agent the browser tab with the bug in it.
An agent fixing a web app usually can't see the bug. It reads the code, guesses, and asks you to reload and say what happened. Browser tools for agents give it a fresh browser: none of your logins, none of your data, rarely the state the bug needs.
Link tabs in your own Chrome to an agent instead, from the maiTerm extension's icon. The agent reads the console and the failing requests, with the body the server sent back, reads the page, and clicks, types, navigates and takes screenshots in it — signed in as you, and in the background while you work in another tab.
Diagnose, then fix
Console errors with the file and line they came from, each request's status and timing, and the response a broken call returned: usually enough for the agent to go straight to the code.
Only the tabs you link
No agent can link a tab, pick one or see your others. Each agent works only the tabs linked to it, and the popups they open for it, such as a sign-in window. Chrome groups them under the agent's name and shows its debugging bar. Unlink, close the tab or cancel the bar, and it ends.
Stays on your machine
The extension talks only to maiTerm on your own computer. What the agent reads goes to that agent, like anything else it reads.
Turn it on in Preferences → Chrome extension. Chrome and other Chromium browsers — Brave and Edge, and Arc on macOS. Install it from the Chrome Web Store.
How the Chrome extension worksMCP servers
Sign in to an MCP server once. Every agent gets it.
One remote MCP server means installing it in Claude Code, again in Codex, again under each Claude account and on each SSH host, and signing in every time. Then the sign-ins fight: most services rotate their refresh tokens, so two copies of one sign-in knock each other out.
Add it in Preferences → MCP servers instead. maiTerm signs in once, keeps the sign-in in your system's credential store and keeps it fresh, and hands the server to Claude Code under every account and to Codex. Each sees it as an ordinary MCP server of its own, with the same tool names, so your permission rules still apply. The agents never hold the token.
Your sign-in, even on a shared host
Claude Code on your SSH hosts gets the same servers, through your own tunnel to your own maiTerm. On a machine several people share, each person's agents use their own sign-in.
Down doesn't mean gone
A server that goes down or needs signing in again keeps its tools. A call answers with a sentence the agent can pass on, rather than tools vanishing halfway through a task.
Agents suggest, you add
Ask an agent to install an MCP server and it can offer maiTerm, with the trade-off. Adding it is a request you approve on its card or your phone, and the sign-in is always yours to do.
Opt-in, one server at a time; servers you installed directly are left alone. Remote (HTTP) servers and their tools for now, served while maiTerm is running. Codex over SSH and Gemini don't get them yet.
How MCP servers workAgents that ask first
Your agents can tidy up. Who talks to whom is still your call.
Agents can see how your workspaces and meshes are laid out and move tabs and workspaces around, without bothering you. Anything that changes which agents can message each other, starts a new agent (here or on one of your SSH hosts), reloads another agent's tab or a window, or restarts maiTerm is only a request: a card in the Loom and on your phone, and nothing happens until you click Approve.
Housekeeping, at once
Reading the layout and moving a tab to another workspace or a workspace to another window happen straight away, unless the move would change a tab's mesh. So does an agent reloading its own tab, when it will come back in the same conversation.
Decisions, by you
Making or linking a mesh, bridging two agents, a new agent tab on this machine or an SSH host, a reload, a restart: each waits in the Loom's Decisions and on your paired phone, and lapses if nobody answers.
Only your click counts
The card is in maiTerm's words, with the agent's reason quoted. An agent asking in chat, or a permission dialog it got past, is not approval, and you approve exactly what the card showed.
Inside Claude Code
It works with Claude Code from the inside, not through its keyboard.
Answering an agent from your phone used to mean maiTerm pressing keys in its terminal for you, and a message waiting until your half-typed draft was gone. Now every Claude Code tab, local or over SSH, loads a small maiTerm mod, and answers and messages are handed to Claude itself.
Yes means yes
Approve from your phone, the Loom or Overlord and Claude gets an allow or a deny, whichever row it sat on. Multi-select and "Other" answers go in as data, and one that doesn't take is withdrawn whole, never left half-typed.
Your draft stays yours
Phone messages, follow-ups, peer messages and chat replies reach an idle agent beside whatever you're halfway through typing. Not into it, and no longer waiting for you to finish it.
Only the paths you drew
Claude Code lets sessions on one machine message each other. In maiTerm they can't: one agent reaches another only through a mesh or a bridge you set up.
On Claude Code versions that support mods. Older ones keep working the way they did.
How the mod worksWorkstream Loom
Every agent in the window. None of their terminals.
Ten agents means ten terminals to visit: scroll back to find what one asked, answer it,
move on to the next, and miss the one that stopped while you were reading. Press
Cmd+Shift+J and the Loom puts all of them in one place, across every
workspace in the window.
Focus is where you talk to them. The agents that need you come first; open one and its conversation reads like a chat — tool runs folded away, the work it is doing beside it — with whatever it is stopped at answerable right there: a permission prompt by its real options, a question, a task waiting on your decision. Then reply — and, to a Claude Code agent, paste a screenshot in or switch its model and effort — without ever finding its tab.
Focus
A condensed chat per agent, a composer, and its prompts answered in place. The header carries its state, its context and anything Overlord is running at it, and what Overlord or maiTerm typed for you is folded apart from what you said.
Weave
Agents strung to the tasks they are working, by workstream: who is on what, what is waiting and on what, and what has quietly gone still.
Decisions
Every question an agent has stopped on, every watch script waiting for your OK, and every change an agent has asked you to approve, oldest first. Pick an option or answer in your own words, and the answer goes straight back to the agent that asked, even mid-turn. The same cards wait in the corner of each agent's own terminal, a click away.
Agent accounts
Claude Code has one login slot. Your week does not.
Two clients, or a personal subscription and your employer's — and one place to be
signed in. Moving between them means /logout, /login, the
browser, again; and it takes every tab with it, because that login is global to the
machine. The agent itself offers no way to switch.
maiTerm holds as many logins as you need and starts each new tab under whichever one you have made active. Pick an account, open a tab, pick another, open the next — and the client's account is working in one while your own runs in the tab beside it, at the same time, no signing out, nothing to redo when you switch back.
On this computer it does that without ever holding your credentials. Each account is a separate configuration directory, and the agent signs in to it, refreshes it and signs out of it exactly as it always has. maiTerm never reads, writes or parses a login, and never touches the keychain entry or credentials file it lives in — it owns the folder, never the credential in it.
Nothing else changes
Your hooks, skills, commands, permissions and MCP servers are shared into every account, so a tab running as one behaves exactly like a tab that isn't. It is a different login, not a different setup. Even the memory writes Claude Code asks about wherever its config runs through a link go through without a prompt.
Chosen when a tab starts
Switching decides what new tabs use; the ones already open keep working as whoever they started as. An account is handed to a shell at launch, so nothing can change it underneath a running agent — reload the tab to move it across.
It says who is actually answering
An ANTHROPIC_API_KEY or a cloud-provider variable outranks a
subscription login while still reporting itself as signed in. maiTerm strips those
out of every tab it starts under a managed account, and Verify
reads back the identity that genuinely resolved — not a green light.
Off until you turn it on. macOS and Linux for now, and Claude Code today; the other runtimes are named as not yet available rather than half-wired. SSH tabs can run as the active account too, on the hosts you choose — the one place maiTerm does hold a token, so it is opt-in per account and the trade-off is spelled out before one is made.
How accounts workStart with what you know
It is a terminal first. The rest waits until you want it.
Nothing here asks you to change how you work on day one. Open a project, run a shell, keep moving — and turn on the parts that manage a desk full of agents when you actually have one.
- Day one
A terminal that feels familiar
Tabs, splits, search, themes, a real editor on any file path. Fast, native, and small — Tauri 2 and the system webview, not a bundled browser.
- As you settle in
Your projects become workspaces
Group tabs by project with their own layout and context. Suspend what you are not using. Restart the machine and find all of it exactly where you left it.
- When you are ready
Your agents get a shared desk
One kanban board both sides work, a supervisor watching the whole window, agents that can talk to each other, and ways in from your phone and your team's chat.
Workspace stack
One dev server, however many agents.
Every project has things that must be running before any of it works — a dev server, an API, a database, a queue worker. You start them by hand in four tabs, lose track of which one died, and then an agent starts a fifth copy of the dev server because nothing ever told it the first one was up.
A workspace can just say what its project runs. maiTerm starts each service, watches its exit code, brings it back when it crashes, and shows the set under the workspace with a rollup dot that goes green only once every service meant to start with it has — never because one of them did. Click one and its console opens over your work — a drawer along the bottom, never a dock that steals width from the tab you are typing in. Click away and it is gone.
It knows where, too. A dev server announces its address the moment it comes up, so maiTerm reads it off the output and fills it in — no sockets sniffed, no configuration. Shift-click the row to open it in your browser.
The stack belongs to the workspace, so every agent in it sees the same one.
On a mesh workspace that is sixteen agents and still one dev server: each session is told
what is running and where — web (ready, http://localhost:5173), api (crashed)
— and eleven tools let them read a failing service's log, restart it, and wait for it to
come up before they call it.
It reads the project first
Point it at a directory and it offers what is already declared —
package.json scripts through whichever package manager your lockfile
implies, a Procfile, the services in a compose file, a
justfile or Makefile. Tick what you want.
A service is a real tab
Not a process hidden behind a panel — a terminal, with real scrollback, colour and
a TUI that renders properly. It just has no slot in your tab strip, so no
stray Cmd+W can take your database down with it.
Crashes, within reason
A service that dies comes back on its own, waiting longer each time. After five restarts in ten minutes it stops and says so on the row, rather than thrashing all afternoon against something that is not going to start.
Task board
A real kanban board, shared with your agents
Agents keep private to-do lists. You watch one scroll past in a terminal, and that is the whole relationship — no way to add an item, correct one, or see across a window what is actually in flight.
maiTerm owns that state now. Seven lanes, with workstreams keeping the unrelated jobs inside one project apart. Dependencies that genuinely hold: a prerequisite parked in the backlog still blocks what is waiting on it, and a task an agent retracts pointedly does not satisfy its dependents the way finishing one does. Assign a row to a tab, or leave it unassigned for whoever picks it up.
Every row carries a spec and an append-only log beneath it, where each entry is stamped with who actually wrote it rather than who claims to have.
- Backlog
- To-do
- Active
- Blocked
- Review
- Done
- Dropped
When an agent needs a decision, it asks on the row and stops: the question, the options, why it matters. Answer it on the board, in the Loom or from your phone, and the answer is typed straight back to that agent, which picks up where it left off.
Open it with Cmd+Shift+E: add, retitle, annotate, park, reassign, or hand
a row over with Do it. The agent sees every one of those edits
through the same tools it writes with. Work it misread gets retracted to
Dropped, which you can reverse. It can delete rows that should never have existed —
but never another tab's work in progress, or a task something unfinished still
waits on.
Overlord
A supervisor for a window full of agents
With a dozen agents running, what you lose is not any single answer — it is track. Which tab is about to hit a compaction wall, which has been sitting at a permission prompt for twenty minutes, which one quietly stopped being connected at all.
A rule is a condition and a sequence: when context reaches 55%, tell the agent to
bring its docs and tasks up to date for compaction, then /compact —
waiting for each step to genuinely land before sending the next.
No model sits in that loop, so it is predictable and costs nothing to
run.
And it never asks you what a tab is already asking you. Each question has one asker: the tab by default — or, if you switch it on, the optional supervisor agent, answering tabs' decisions from a playbook of your standing answers and coming to you only when the playbook doesn't cover a call that matters.
Held for your approval
Overlord types with your authority, so propose mode is on out of the box: every directive waits for you, showing the exact words it would send. Your own keystrokes abort a sequence already in progress.
An operations deck
Loom is where you work with the agents. Triage is one severity-ordered queue of everything wanting a person. Ledger is a verbatim record of every directive sent and what came back.
Rules you actually tune
Conditions fire on semantic state — context, commits, idle time, stale tasks, waiting permission prompts — not on scraped terminal output. Scoped globally or per workspace.
Mesh workspace
A team of specialists, not one giant context
Flip a workspace into a mesh and every agent in it can message any other by role. The frontend agent asks the backend agent for an endpoint's exact shape, the backend loops in infra, and nobody waits for you to play messenger.
It is also a token win. One monolithic agent drags every codebase into a single enormous context and re-reads it turn after turn. A mesh keeps each agent's context small and sharply scoped, and they trade short addressed messages instead of duplicating each other's worlds.
Keep each repository in a workspace of its own and link their meshes: the agents work as one team — one roster, one set of topics — while the sidebar stays sorted by project.
How mesh works
maiLink companion
Your agents, in your pocket. No cloud in the middle.
A phone app that connects directly to maiTerm on your own computer. Watch agents work, answer their questions, approve permissions, and interrupt a runaway turn — from the couch, the garden, anywhere in the house.
A permission card shows the options actually on the agent's screen, not a generic yes or no. A task an agent has stopped on arrives as a question you answer with a tap. Even Claude's folder-trust check — the “Quick safety check” that stops a session before it starts — is a card you can answer from the phone.
It writes, too: work the shared board — move a card between lanes, retitle or reassign one — approve an Overlord proposal, allow a watch script an agent wants run, rename or archive a tab, wake a suspended workspace. Running several Claude accounts? Each chat shows which one it's running as, and you can switch the active one from the phone.
It travels over your LAN only, on an encrypted, authenticated channel. The single exception is a content-free push doorbell. It rings for a permission prompt, a question on one of an agent's tasks or a watch script waiting for you, and wakes the app carrying nothing but a tab name and an event kind — never a transcript. Each phone picks which kinds ring it: keep permission prompts, mute "agent finished". Mute a tab on the desktop and it rings nothing at all.
How maiLink works
Chat threads
The bug report never has to leave the thread it landed in.
A customer problem shows up in a Mattermost thread. Normally you read it, switch to
your editor, reproduce it, fix it, then come back and write up what you did. Point a
tab at that channel instead: set up a bot account once, and an @mention of
it hands that tab the thread — the conversation so far, plus the screenshots, logs and
documents staged as real files on disk — to work in that tab's repository.
The channel keeps flowing normally. Only messages that @mention the bot are
delivered into the session, so the agent answers deliberate asks rather than reacting to
everything said near it.
It replies before it investigates — its one-line read of what is being asked, and how to reach it again — so a misunderstanding surfaces immediately instead of ten minutes later in the shape of the wrong fix. Then it goes quiet, works, and posts the resolution in two halves: plain language for whoever is talking to the customer, and the root cause below the divider for the devs.
Support can ask, not authorize
Who may summon the bot is enforced in Preferences — an @mention from
anyone else never reaches an agent. Above that, every delivered message arrives
tagged with its sender's tier and a standing rule: reading is free, but changing
code, deploying or touching data goes back to someone you named.
Six threads, and a kill switch
One tab works up to six at once and queues the rest, telling a waiting thread it is at capacity rather than leaving people wondering. The tab's right-click menu ends a binding — every one of them on a busy tab — without the agent's cooperation.
It can start the conversation
A regression it tripped over, a heads-up before a deploy, a question only a person
can settle — the agent opens its own thread in a channel you put on that tab's
list, @mentions whoever should see it, and stays bound for the replies.
Follow-ups
An agent that comes back to it, without you remembering to ask.
“I'll check the deploy in twenty minutes” is a promise no agent can keep. It stops, and the check happens only if you remember it. In maiTerm the agent schedules its own next prompt, into its own tab: at a time, when a service in the workspace comes up or goes down, or when a task on the board is done.
Waiting on something else — CI finishing, a file appearing, an error showing up in a log? The agent writes the check as a short script, and maiTerm runs it on a schedule without waking the agent, so nothing is spent while nothing has changed. The prompt arrives when the check passes, carrying what it found.
The same session, picked up
It lands in the tab the agent is already in — its transcript, your local services, your files — when it's due, even mid-turn, labelled as its own earlier note. Exited since? maiTerm relaunches it at an empty prompt, then delivers.
Nothing runs you haven't read
A watch script runs only after you allow it, on a card that shows the whole script, where it runs and how often. Answer it in the Loom, on the tab or from your phone; decline it and the agent is told. And it never types over a message you are still writing.
Yours to see and cancel
A clock on the tab says one is pending; click it for the list, each row leading with what it waits for and anything holding it — send one now, remove it, or schedule your own.
Part of Overlord, so it is live while Overlord is on. Claude Code and Codex alike, and it survives maiTerm restarting. An agent working over SSH has its watch script run on that host, where the thing it is waiting for is.
How follow-ups work
Runs the agent CLIs
you already have installed
- Claude Code
- OpenAI Codex
- Local shells
- SSH hosts
- macOS
- Windows
- Linux
The daily work
The rest of it still has to be a good terminal.
Orchestration is worth nothing if the thing you sit in front of all day is annoying.
Restart without losing anything
Reboot the machine and every tab comes back as it was — scrollback, layout, SSH sessions, agent sessions — each resumed agent reconnected to its tab with nothing typed by anyone, and the dev servers you left running started again.
Know what is in every tab
Interpolated names like CustomName %title combine your label with live terminal state. No more guessing across fifteen identical “bash” tabs.
Workspaces per project
Group terminals by project, each with its own pane layout and context. Suspend the inactive ones to free resources; they resume with full state. Move a workspace or a single tab to another window and everything in it keeps running — or move the project folder itself, and its tabs, services and agents’ sessions and memory follow it.
Hand a workspace to a teammate
Share a workspace as one file. Whoever opens it gets the same tabs in the same repositories — cloned for them where they don’t have them, services and agents included — and none of your accounts, scrollback or secrets. On their side, every command it would run is listed word for word first, and only the ones they approve ever run.
Bridge two agents
Connect two running sessions — one local, one over SSH, a Claude Code and a Codex — so they ask each other questions directly, in a split pane you can watch.
A composer, not a shell line
A multi-line dock under every terminal. Enter makes newlines, Cmd+Enter sends, drafts survive restarts, and pasted screenshots become attachments — uploaded automatically over SSH.
Built-in editor
Click any file path in terminal output to open it in an editor tab — over SSH too, loaded transparently. 50+ languages, with an inline merge view when a file changes under your unsaved edits.
Deshittify your agent
One Preferences section switches off the parts of a coding agent that serve its vendor: telemetry, error uploads, feedback nags, Remote Control (off by default), and the Co-Authored-By trailer in your history.
A Rust terminal underneath
alacritty_terminal does VTE parsing, buffering and scrollback in the backend, so the frontend only ever paints one screen. Scrollback persists to SQLite, crash-safe.
What it costs
Free. All of it. There is no tier above this one.
Not free-for-four-projects, not free-until-you-need-the-good-part. Overlord, the Loom, mesh, the shared board, follow-ups, chat threads, the phone companion, SSH — every feature on this page is in the build you download, and there is nothing to buy later.
No account
No sign-in, no licence key, no activation limit, no seat count. Download it and it works. It does not know who you are.
Works offline
There is no licence check to phone home to. The only request maiTerm makes on its own behalf is looking for a new version.
The source is published
Read it, build it, change it. Source available rather than OSI open source: the one restriction is that you may not use it to build a competing terminal.
Questions
Frequently asked questions
Is this a VS Code or Electron fork?
No. maiTerm is a Tauri 2 desktop app using the operating system's own webview — WebKit on macOS, WebView2 on Windows, WebKitGTK on Linux. There is no bundled browser and no editor fork. The terminal itself is Rust: alacritty_terminal does the VTE parsing and buffering in the backend.
Does maiTerm see my API keys or proxy my prompts?
No. maiTerm launches the agent CLIs already installed on your machine and they keep using their own accounts, authentication and configuration. Your conversations go from that local CLI to its provider. maiTerm is not a model gateway and never asks you for a provider key. The one thing it can sit in the path of is an MCP server you choose to add in Preferences → MCP servers: then maiTerm holds that server's sign-in and passes your agents' tool calls to it, without writing their arguments or results to its log.
Can maiTerm manage my MCP servers?
The remote ones, if you want it to. Add a server in Preferences → MCP servers and sign in once: maiTerm keeps the sign-in in your system's credential store, refreshes it, and serves the server to Claude Code under every account, to Codex, and to Claude Code on your SSH hosts — where, on a machine several people share, each person's agents use their own sign-in. A server that goes down keeps its tools instead of vanishing mid-task. It is opt-in per server, and servers you installed directly keep working untouched. Local servers started with a command, Codex over SSH and Gemini aren't covered yet.
Can my agent see what is going wrong in my browser?
Yes, in the tabs you hand it. With the maiTerm extension for Chrome (and other Chromium browsers), you link a tab to an agent from the extension's icon, and that agent can read the tab's console errors, its failing requests and the responses they got back, and the page itself, and can click, type, navigate and take screenshots in it — in your own signed-in session, in the background. No agent can link a tab or see your others, and each agent works only the tabs linked to it, plus a popup one of them opens for it, such as a sign-in window. The extension talks only to maiTerm on your own computer. Install it from the Chrome Web Store and turn it on in Preferences → Chrome extension.
Can I see which files my agents changed?
Yes. The Files column (Cmd+Shift+B) is a project tree that follows the tab you're in, and lights a file up as an agent reads it and marks what each agent changed this turn and this session, in that agent's colour. Narrow it to one agent's turn, or compare a file with how it was before the agent's first edit. It is built from the agents' own tool calls, for Claude Code and Codex: a file that changed while an agent's shell command ran is labelled as exactly that, not as the agent's edit.
Can I be signed in to two Claude accounts at once?
Yes, and Claude Code on its own cannot — it has a single login slot, shared by every terminal you open. maiTerm gives each account its own configuration directory and starts each new tab under whichever account you have made active, so a client's account can be working in one tab while your own runs in the next. For those local tabs it never holds the credential: the agent does its own sign-in, refresh and sign-out, and maiTerm owns only the folder. SSH tabs can run as the active account too, on hosts you choose — that needs a long-lived token, which maiTerm keeps in your system keychain, so it is opt-in per account. Off by default, macOS and Linux for now.
Which coding agents does it support?
Claude Code and OpenAI Codex, through one runtime-neutral pipeline — you pick which ones maiTerm wires up in Preferences. Any other CLI still runs in a tab like it would in any terminal; it just does not get the agent-aware features.
Is there an LLM built into the terminal?
No, and that is deliberate. There is no chat sidebar and no model maiTerm calls on your behalf. It manages the agents you run, rather than being another one.
What happens when I restart, or it crashes?
Every tab comes back as it was: scrollback, pane layout, working directories, SSH sessions and agent sessions. Each resumed agent reconnects to its tab on its own, with nothing typed by anyone. Scrollback persists to SQLite in WAL mode, so an unclean exit does not take the buffer with it.
Does it work over SSH?
Yes, and it is a first-class path rather than an afterthought. Agents on a remote host get the same tab identity, task board, notes and MCP tools through a reverse tunnel. Remote files open in the editor transparently, file paths in output are clickable the same way, and the Files tree browses the folder on the host.
Do my agents get to change things without me?
Only what you allow. Agents may move tabs and workspaces around, but anything that changes which agents can message each other, opens a new agent tab, reloads another agent's tab or a window, or restarts maiTerm is only a request: a card in the Loom and on your paired phone, worded by maiTerm, that nothing but your click approves — not an agent asking you in chat, and not a permission dialog. Overlord ships in propose mode: every directive is held for your approval showing the exact words it would send, and your own keystrokes abort a sequence in progress. The rule guards are human-only and cannot be edited by an agent. On the task board an agent retracts misread work to a lane you can reverse, and the rows it may delete outright never include another tab's work in progress or a task something unfinished still waits on. A script an agent asks maiTerm to run for it later runs only once you have approved that exact script. And nothing maiTerm sends for you — a message from your phone or a peer agent, a chat pickup — is submitted along with something you have half-typed into a Claude Code agent's input box: in a tab running maiTerm's Claude Code mod it goes in beside your draft, which stays put, and otherwise it waits until you have sent or cleared it. Nor, on Claude Code versions that support mods, can an agent in a maiTerm tab message other Claude sessions on the machine behind your back: the mesh and bridges you set up are its only way across.
What happens if I rename or move a project folder?
Use Move project… on the workspace and nothing is left behind. maiTerm pauses the agents working in the folder, moves it, and points everything at the new location — tabs, services, follow-ups, and each agent's own record of the project: Claude Code's sessions, memory and folder trust, Codex's trust and threads, Gemini's registry — then resumes each agent in the same session. Moved it outside maiTerm? A tab whose folder has gone opens in your home folder without resuming its agent there, and asks you where the folder went.
Claude Code can already schedule things. Why follow-ups?
Its own schedules either live inside the running Claude process or start a fresh session in the cloud, on a clone of your repo. A maiTerm follow-up is held by maiTerm and delivered back into the same tab — the same session, your local services and files, your SSH hosts — and it survives the agent exiting and maiTerm restarting. It can wait on your workspace, not only the clock: a service coming up, a task finishing, or a check the agent wrote. It works for Codex too, and you can see and cancel every one that is pending.
What does it cost?
Nothing. Every feature is included — there is no paid tier, no licence check and no account.
What licence is it under?
Source available, not OSI open source. The full source is published and you may use, modify, distribute and sublicense it; the one restriction is that you may not use it to build a competing terminal emulator. Building it into something with a substantially different purpose — an IDE, a DevOps platform — is explicitly allowed. The terms are in LICENSE in the repository.
Which platforms does it run on?
macOS (Apple Silicon only — there is no Intel build), Windows 10 and later as a 64-bit installer, and Linux as an AppImage or .deb built against webkit2gtk-4.1 on Ubuntu 24.04.
Does the Claude Code integration work on Windows?
Yes, with Git for Windows installed: Claude Code runs its commands through Git Bash, and so do the hooks that tell maiTerm which tab a session is in. A setup wizard checks for Git, Claude Code and whether claude is on your PATH, and installs or fixes what is missing in visible tabs. New tabs use Git Bash when it is installed. Windows support for Claude is new and less used than macOS, and the Claude Code mod is not loaded there yet.
Does it phone home?
Only the update check, and it is counted. That check reaches a small Cloudflare Worker which records one row per unique user per day — a salted hash of IP and user-agent, where the salt is random, rotates daily and is then discarded, so it cannot be reversed or linked across days. No IP, user-agent, cookie or device ID is stored, and nothing about your projects, tabs, terminal output or agents ever leaves the machine. There is no other analytics, no error uploads and no account. maiTerm also ships a Preferences section that switches off the telemetry and error reporting in the agent CLIs it launches, and it turns Claude Code’s Remote Control off by default, so your sessions are not exposed to claude.ai or the Claude mobile app unless you switch it back on.
How do updates work?
maiTerm checks GitHub Releases automatically and installs an update with one click, showing you the release notes first. You can turn the startup check off in Preferences and update from the menu instead.
Can I get my state onto another machine?
Yes. Export workspaces, tabs, scrollback, notes, triggers and preferences to a single archive — on a schedule if you want, with compression and auto-trim. Importing previews what is inside so you can pick which workspaces to bring in and whether to merge or overwrite.
Give every agent on your desk the same place to work.
Start with a terminal. Turn on the supervisor when the desk gets busy.
Free, source available. macOS, Windows and Linux.