New — Tasks
Agents keep private to-do lists. You watch one scroll past in a terminal, and that’s the whole relationship — no way to add an item, correct one, or see across a window what’s actually in flight. maiTerm owns that state now, and both sides read and write the same list.
Tasks hang off the workspace, because a workspace is a project: they outlive a tab reload, a window move, and the agent that wrote them. Six lanes — Backlog, To-do, Active, Blocked, Review, Done — where Backlog is a parking lot for next month rather than an inbox, exempt from every staleness check, and new work starts in To-do. Workstreams name the separate jobs inside a project, so a tab asked to do two unrelated things doesn’t flatten them into one list.
Open the panel with Cmd+Shift+E — the same dock as notes, per tab. Add, retitle, annotate, park, reassign, hand a row to the agent with Do it, or delete it; your agent sees every one of those edits through the same tools it writes with. That’s what makes it two-way: until now, task state was something you could only watch. On by default, in every runtime, local or over SSH.
It picks itself up
Every agent tab is told about the list when its session starts, resumes, forks or compacts — including “if you already have a list for this project, move it here”, so work already in flight becomes visible instead of just the next job.
Only a human deletes
An agent may mark a task done; there is deliberately no delete tool. An agent tidying away work it didn’t understand is unrecoverable — and when you delete a row, the agent carrying it is told.
Archived with its tab
Archive a tab and its work parks with it; restore the tab and the rows come back, still attributed. A parked prerequisite still blocks whatever was waiting on it.
New — Overlord
With a dozen agents running, what you lose isn’t any single answer — it’s track. Which tab is about to hit a compaction wall, which one has been sitting at a permission prompt for twenty minutes, which one quietly stopped being connected to maiTerm at all. Overlord watches all of them, per window, and acts on rules you write.
A rule is a condition and a sequence: when context reaches 55%, tell the agent to update its docs, then to prepare for compaction, then /compact — waiting for each step to genuinely land before sending the next. No model sits in that loop, so it’s predictable and costs nothing to run. Four rules ship: checkpoint before compaction, review after a commit, re-bind an agent that has lost its connection to maiTerm, and keep a task list.
Overlord types with your authority, so propose mode is on out of the box: every directive is held for you to approve, showing the exact words it would send. The guards that decide whether a rule may fire at all are human-only and can’t be edited by an agent, and your own keystrokes abort a sequence already in progress. Off until you switch it on.
You keep the manual controls too. Fire any rule yourself — Trigger ▾ on a fleet card, or a bolt in the composer of the tab you’re already in — whatever its condition says. And take a tab, or a whole workspace, off the board when it shouldn’t be supervised at all: the engine then can’t see it, and releases anything it was already holding for it.
An operations deck
Triage is one severity-ordered queue of everything wanting a person. Fleet is a card per agent — context ring, live state, time since its last turn, sequence in flight — sorted by peak context or latest activity. Board is the task board indexed by workstream. Ledger is a verbatim record of every directive sent and what came back.
A supervisor agent, too
Optional: an agent with its own tools — pull the escalation queue, drive another tab, answer a prompt one is stuck at, propose rule changes for you to approve. It reaches tabs that are suspended, archived, or on the far end of an SSH connection.
Rules you actually tune
Conditions fire on semantic state — context, commits, idle time, stale tasks, unbound agents, waiting permission prompts — not on scraped terminal output. Seeded, hideable and restorable like triggers; scoped globally or per workspace.
Spotlight — Mesh Workspace
Flip a workspace into a mesh and every agent in it can message any other by role. Purpose-trained specialists — each expert in its own repository — ask each other precise questions and get answers back as real turns: the frontend agent asks the backend agent for an endpoint’s exact shape, the backend loops in the infra agent, and nobody waits for you to play messenger. That’s cross-repository collaboration, live, in panes you can watch.
It’s not just a coordination win — it’s a token win. One monolithic agent has to drag every codebase into a single enormous context and re-read it turn after turn. A mesh keeps each agent’s context small and sharply scoped, and agents trade short, addressed messages instead of duplicating each other’s worlds — multi-repo work at a fraction of the token spend.
Addressed, never broadcast
Every message routes to a specific role over a stable handle — a rename never misroutes, and an unknown recipient is a hard error, never a silent drop.
Topics keep threads honest
Conversation groups into owned, deduped topics — with opt-in loop caps (soft, hard, time-to-live) for when you want backstops on a runaway exchange.
You stay in the cockpit
Cmd+Shift+M opens a live conversation graph, a topic board with resume/complete controls, and a focused stage + filmstrip view of every agent.
New — maiLink Companion
maiLink is a phone companion that connects directly to maiTerm running on your own computer. Watch your agents work, answer their questions, approve permissions, and interrupt a runaway turn — from the couch, the garden, anywhere in the house.
It shows you what the agent is doing, not just what it said: the task list it shares with you streams to the phone — and you can add a row, retitle one, move it between lanes or reassign it from there, with the write landing even while the Mac’s screen is asleep — its background shells appear as a roster with a Stop button each — liveness confirmed against the process list, never guessed from the transcript — and agent-to-agent mesh and bridge traffic reads as its own kind of turn. Tap New conversation to start a fresh session beside the one you’re reading: same host, same directory, clean history. Agents can send you files, too — any kind, arriving in that tab’s chat and in a cross-chat Files list, from remote SSH sessions as readily as local ones.
Now it manages your desk, too. Rename a tab, archive one for later (and restore it from the archived list — it respawns and resumes its agent), or close one for good. Tap Resume workspace to wake a suspended workspace back to life, bringing back exactly the tabs that were running. Mesh workspaces are badged in the inbox with a one-tap Initialize all that readies every agent in them, and any single tab that’s stopped answering has an Initialize of its own. With Overlord running, its escalations and proposals reach the phone too: approve or dismiss a proposal, clear an escalation, fire a rule at a tab, or drive one.
It travels over your LAN only, on an encrypted, authenticated channel — TLS with a pinned certificate and a per-device paired token. No cloud service sits between your phone and your agents. The single exception is a content-free push “doorbell” hosted on Cloudflare: when an agent needs you while the app is backgrounded, it wakes the app carrying only the tab name and event kind — never a transcript or message. Away from home? Set up a WireGuard VPN back to your LAN rather than exposing anything to the internet.
Live transcripts
Each agent streams per turn as a distilled chat — with its model, reasoning effort, a live context-window gauge, and compaction shown as a divider in the thread. “Working…” says what on: the tool it’s running right now, and a row per subagent it has handed work to, with that subagent’s own latest line of progress. Its tasks and background shells stream alongside it. Fast even on hundred-tab windows and sessions hundreds of megabytes long.
Answer from anywhere
AskUserQuestion prompts arrive as interactive cards — single-select, multi-select, and “Other” free-text — plus reply to or interrupt a running agent, and send images to a Claude Code session, local or over SSH.
Run the desk from the couch
Rename, archive, restore, or close a tab; edit the shared task list; approve an Overlord proposal or fire a rule; wake a suspended workspace; ready a whole mesh in one tap. Pair by scanning a QR code — every phone gets its own revocable token, and you choose which tabs are reachable.
New — Chat Threads: channel monitoring
A bug report lands in a Mattermost thread. Now maiTerm can be watching for it: right-click a tab → Enable chat monitoring…, pick the channels your bot belongs to, and that tab becomes a dispatcher. Whenever someone @mentions the bot in a thread, maiTerm binds the thread to the tab and hands the agent the whole conversation — it reproduces and fixes the issue in that tab’s repository, then posts the resolution back, a plain-language summary for support and technical detail for the devs, without you ever leaving maiTerm. Still prefer to hand-pick? Paste a permalink with /maiterm resolve — both paths land in the same flow. Configure the bot once in Preferences → Integrations.
It can start the conversation, too. An agent that found a regression, or needs a human to settle a question, can open its own thread in a channel it monitors and stay bound to it — and because it asked, every reply comes back without anyone having to @mention a bot they didn’t summon. Whichever way a thread arrives, the agent acknowledges it first, with its read of the ask in one line, so nobody is left wondering whether it was picked up.
You stay in control of what it can act on. Only people you list can summon it, on a thread someone else started only messages that @mention the bot reach the agent, and each is scoped by its sender. The line is read versus change: investigating, explaining, reproducing and answering happen freely on anyone’s ask, while editing code, deploying, or touching data needs an authorized operator’s go-ahead — which the agent requests by @mentioning one of them. A monitoring tab works up to six threads at once — its @ indicator is dim while idle, green with a count once threads are bound — and a finished thread is released as the agent posts its resolution, freeing the slot — an @mention summons it straight back if the fix turns out to be wrong, delivering only what’s been said since rather than replaying the whole thread.
Attachments work both ways. Whatever is attached to a report — a screenshot, a PDF, a spec document, a log — is staged where the agent can actually open it, with a note on how to read that kind of file, including for agents running on a remote host over SSH. The agent can attach files to its own replies too, so a before/after or visual proof of a fix goes back to the thread.
Summoned, not pasted
Monitor the channels the bot belongs to; an @mention in a thread binds it to your dispatcher tab automatically. The agent can open a thread of its own in those channels too. One tab handles up to six threads at once, and overflow queues.
A tiered summon list
Authorized operators carry your full authority; pickup users can summon the bot and get investigation and answers for free, but any change waits on an operator’s go-ahead; everyone else is never picked up. Set both lists in Preferences.
Route it across a mesh
In a mesh workspace, the dispatcher tab can hand an investigation to the peer whose repo matches — staying on the thread itself while the right agent does the work, then posting the answer back.
Other terminals give you tabs and splits. maiTerm gives you a system for managing the chaos of real AI-assisted development — where you’re juggling multiple agent sessions (Claude Code, Codex) across projects, SSHing into servers, and trying to remember what you were doing three hours ago.
Know what's in every tab
Interpolated tab names like CustomName %title combine your label with live terminal state. Name a tab “billing API” and always know what’s running in it — no more guessing across 15 identical “bash” tabs.
Restart without losing anything
Reboot your machine, restart maiTerm — every tab comes back exactly as it was, out of the box. Scrollback, layout, SSH sessions, Claude Code sessions — and each resumed agent comes back connected to its tab with nothing typed by anyone. Back up your state on a schedule or export it manually — and import it on a new machine.
Workspace Organization
Group terminals by project. Each workspace has its own pane layout, tabs, and context. Suspend inactive workspaces to free resources — they resume instantly with full state when you need them.
AI Agent Integration
Deep integration with Claude Code and OpenAI Codex through one runtime-neutral pipeline — pick which agents maiTerm wires up in Preferences. No registration step: a tab identifies itself on the wire and its session links itself when the agent starts, so restarts, resumes, forks and compactions all come back correctly bound with nothing typed. 40+ MCP tools let your agent navigate workspaces, manage tasks and notes, control preferences, review diffs, send you files, and discover what’s running in your tabs. Real-time hooks track what each agent is doing — active tool, permission requests, compaction state. Per-tab, per-workspace, and a global footer dot roll up every agent’s state — working, waiting for permission, or done — so you can see at a glance which ones need you. Works over SSH too via reverse tunnel.
Share a task list with your agents
maiTerm owns the task state, so it’s the same list on both sides. Six lanes, named workstreams, a panel on Cmd+Shift+E where you add, retitle, park, reassign or hand a row to the agent — and it sees every edit through the same tools it writes with. Scoped to the project, so the work outlives a reload, a window move, and the agent that wrote it. Works in every runtime, local or over SSH.
Supervise a whole window of agents
Overlord watches every agent tab in a window and acts on rules you write — checkpoint before a compaction wall, review after a commit, re-bind an agent that dropped off. Deterministic, no model in the loop, and every directive held for your approval by default. Triage, Fleet, Board and Ledger views, plus an optional supervisor agent with tools of its own. Fire any rule by hand, or exempt a tab or workspace that shouldn’t be supervised. Opt-in.
Bridge two agents
Connect two running agent sessions — one local, one over SSH, two related projects, even a Claude Code and a Codex — so they collaborate directly. One agent asks the other questions, requests research, or shares context, and replies come back as new turns. maiTerm spawns a split pane so you see both sides, stamps every message with the sender’s real identity, and keeps the agents deferring to you for the decisions.
Mesh a whole workspace
Bridge connects two agents — a mesh connects them all. Flip a workspace into a mesh and every named agent can message any other by role, addressed and routed so a rename never misroutes. Conversation groups into topics, with opt-in soft, hard, and time-to-live loop caps when you want backstops. Open the cockpit (Cmd+Shift+M) for a live conversation graph, a topic board, and a focused stage + filmstrip view of every agent.
Resolve support threads in-terminal
Watch your Mattermost channels and the bot picks up threads on demand: @mention it and maiTerm binds the thread to a dispatcher tab, which works the bug to resolution — reading the whole thread, fixing it in that tab’s repo, and posting back a support summary plus technical detail. One tab handles up to six threads at once, and the agent can open a thread of its own when it finds something the channel needs to know; you can still hand-pick a thread with /maiterm resolve <permalink>. Authorized operators carry your authority, everyone else gets investigation and answers for free but no changes without an operator’s go-ahead. Posting the resolution releases the thread rather than camping on it — an @mention brings the agent straight back with only what’s new. Configure the bot once in Preferences → Integrations.
Reach agents from your phone
maiLink, the companion app, connects directly to maiTerm over your LAN — encrypted, authenticated, no cloud in the data path. Watch live transcripts, follow background shells (with a Stop button each), answer agent questions, approve permissions, and interrupt runaway turns from anywhere in the house. It writes, too: edit the shared task list, approve an Overlord proposal or fire a rule, and manage the tabs themselves — rename, archive, restore, close, start a fresh conversation, wake a suspended workspace, or ready a whole mesh in one tap. QR pairing with revocable per-device tokens.
Deshittify your agent
One Preferences section switches off the parts of a coding agent that serve its vendor rather than you: telemetry, error uploads, feedback nags, and the Co-Authored-By: Claude trailer in your commit history — with a git hook that strips the trailer anyway should the setting stop being honoured, while your repo’s own hooks keep running. maiTerm edits the agent’s own config, so it holds in every terminal, and the rules travel to the hosts you bridge to.
Compose prompts like a human
A multi-line composer dock under every terminal: Enter makes newlines, Cmd+Enter sends, and drafts survive tab switches and restarts. Paste screenshots or drop files and they become attachment chips — over SSH they’re uploaded automatically. No more crafting a five-paragraph prompt on a single shell line.
Built-in Editor
Click any file path in terminal output to open it in an editor tab. Works over SSH too — remote files load transparently via SCP. 50+ languages, auto-reload on external changes, and inline merge view when files change while you have unsaved edits.
Quick Open anything
Double-press Opt (or Cmd+P) for a fuzzy file finder with glob patterns, directory navigation, and recently-opened ordering. It even lists files on the remote host when you’re SSH’d in.
Smart Triggers
Regex triggers watch terminal output for patterns and fire actions — notifications, commands, variable capture. Scope triggers to specific tabs or fire them globally. Build your own automation for builds, deploys, SSH sessions, and more.
Archive and restore tabs
Set up auto-resume on a tab, then archive it. The tab disappears from your tab bar but preserves everything — scrollback, notes, triggers, resume command. When you need that task again, restore and pick up instantly. Pin auto-resume settings so they survive across restarts and replays.
Notes on everything
Every tab has its own markdown notes panel — track TODOs, paste connection strings, jot down what you’re debugging. Workspace-level notes too. Your agent — Claude Code or Codex — can read, write, organize, merge, and clean up your notes via MCP tools, sharing the same scratchpad.
Rust-Powered Terminal
alacritty_terminal does VTE parsing, buffering, and scrollback in the Rust backend, so the frontend only ever paints one screen — no GPU rendering needed. Scrollback is stored in SQLite for crash-safe persistence, and full terminal state survives restarts: tab layout, workspace state, and scrollback history all come back.
Auto-Updates
maiTerm checks for updates automatically via GitHub Releases and installs them with a single click — no manual downloads, no reinstalling. Toggle auto-check on startup in Preferences, or check manually from the menu.
Backup & Selective Import
Export your entire state — workspaces, tabs, scrollback, notes, triggers, preferences. Schedule automatic backups with gzip compression and auto-trim. Import on a new machine and preview what’s inside — pick which workspaces to bring in, choose merge or overwrite, toggle preferences.
Split Pane Cloning
Duplicate a tab and get everything: scrollback, CWD, SSH session, the agent’s resume command, notes, trigger variables. SSH sessions clone to the same remote CWD.
Built with Tauri 2 for native performance with a small footprint.
| Layer | Technology |
|---|---|
| Frontend | Svelte 5, SvelteKit, TypeScript |
| Backend | Rust, Tauri 2 |
| Terminal | alacritty_terminal (Rust) + xterm.js (DOM renderer) |
| Editor | CodeMirror 6 |
| Storage | SQLite (WAL mode) |
| PTY | portable-pty |
