Control plane for a fleet of AI agents — on phone and desktop.
Direct agents from your pocket or your desk. A steward turns your goal into a plan, a fleet executes across your own hardware, you ratify and review.
Android, iOS, iPadOS, macOS, Windows, Linux — open source, self-hosted, Apache 2.0.
Agent front-ends are catching up on raw session count — several now juggle more than one session at a time. TermiPod isn't another session multiplexer; it's a director's control plane: you state a goal, a steward decomposes it into a plan and tasks, a governed fleet executes across your own machines, and the loop closes back to you — on your phone or at your desk.
- Multi-agent fleet — coordinate Claude Code, Codex, Gemini CLI, Kimi Code, or any CLI that takes a pty, each with its own pane, profile, and budget. One inbox for all of them.
- Multi-host over your own infra — a steward on a $5/mo VPS delegates work to a GPU box at home behind NAT, via A2A over a self-hosted reverse-tunnel relay. No cloud middleman holds your sessions.
- Director, not operator — write a natural-language goal. The steward decomposes it into a plan and a set of first-class tasks, dispatches workers, and you ratify. You don't author DAGs or babysit terminals.
- Governed actions — consequential moves are proposed, not silently executed: the steward surfaces them, you ratify. Backed by budget caps, policy overrides, per-agent usage, an immutable audit log, and team roles.
- Closed-loop orchestration — dispatched work routes back to you when it finishes or blocks, so you're notified instead of polling. The fleet itself — host-runners, agents, tokens — is startable, stoppable, and updatable from the client.
- Phone and desktop — the same control plane in two clients: a Flutter mobile app (Android / iOS / iPadOS) and a desktop workbench (macOS / Windows / Linux) built on one shared React + TypeScript frontend in an Electron shell. Point both at the same hub.
- Offline-first — SQLite snapshot cache shows last-known-good lists on every screen when the hub is unreachable. Subway-safe.
- Scales on a small VPS — the Go hub drives a large fleet on cheap hardware with zero added infrastructure (no Redis, no managed DB at MVP): per-team SQLite sharding, a writer/reader pool split, and a deferred digest fold take it to ~1,000 concurrent agents on a 2 GB-RAM / 2-vCPU box with no write-error cliff (load-tested). When you outgrow one box, a selectable Postgres backend is the designed scale-out path for HA and high write-concurrency.
- Vendor-agnostic, self-hosted — Apache 2.0 Go hub you run yourself. No account gating, no cloud relay, no vendor lock-in.
30-second demo. Type ablation sweep on nanoGPT — tell me which optimizer scales better on your phone. Your VPS steward decomposes it into a plan and a handful of tasks, then asks to spawn six training runs on your home GPU box — you tap Approve. The runs execute across hosts over A2A while you close the app. When the work finishes (or blocks), the loop closes back to you: a briefing with loss curves lands on your Me tab. You ratify it on the train home.
See docs/discussions/positioning.md for the full thesis, ICP, and competitive analysis. The full doc index lives at docs/README.md.
⚠️ Preliminary preview — partial. Captured on a real foldable device, before the Candidate-A hardware demo's final UX polish. It covers only part of the app and is not a full feature tour — shared for eager readers who want an early feel ahead of the proper demo. Click the screenshot above to play the demo video (docs/screens/termipod-demo.mp4). A complete, CI-captured walkthrough is planned; design in docs/discussions/screenshot-automation.md.
A tour of the director's cockpit, captured on a real foldable (the same preliminary build as the demo above — UX still in flight).
The cockpit — a five-tab home for the director
 Projects · directed work, progress, open ACs |
 Activity · the team-wide event & audit stream |
 Me · your steward, requests & team spend |
Directed work — tasks and deliverables
 Tasks · the steward's work board (blocked / done) |
 Documents · plans, memos, reports, reviews |
 Deliverable · a report with its metrics, in-app |
Watching the agents — the Insights workbench
 Session · a live agent transcript + artifacts |
 Run report · turns, cost, tools, errors, models |
 Navigator · jump by turn, error, or map |
Fleet cost & experiment tracking
 By agent · token spend across the fleet |
 Experiments · runs by hyperparameters |
 Run detail · live metrics, config, outputs |
More views — task detail, the sessions rail, more deliverables, full run config
 Task detail · goal, status, result summary |
 Sessions rail · every steward + run, team-wide |
 Run config · the full hyperparameter set |
 Method plan · a multi-phase draft |
 Method notes · environment + config memo |
AI agents produce ten times more output than any human can review. The moment you run more than one agent, or span more than one machine, the existing tools show their seams. Session-bridge apps (Claude Code Remote Control, Happy, Tactic Remote, the Codex app) put a session — or now several — in your pocket, but each is still a window onto agents you launch and babysit; messenger-bridge agents (OpenClaw, Hermes, Claude Code Channels) give you one chat-style assistant across your chat apps. Neither decomposes a goal, dispatches a fleet across your own machines, and governs what those agents may do. TermiPod is built on a different axiom: the human is a director, not an operator.
| Dimension | Remote Control / Happy / Tactic / Codex | TermiPod |
|---|---|---|
| Topology | You ↔ sessions you launch by hand | Director → steward → fleet across M hosts |
| Agent count | Several, but each one started and driven by you | A fleet the steward spawns and coordinates |
| Host span | One machine you keep awake (some sync via the vendor's cloud) | VPS + GPU + laptop, coordinated over a self-hosted A2A relay |
| Agent vendor | Claude Code / Codex | claude-code, codex, gemini-cli, kimi-code — plus any pty CLI |
| Authoring model | You type messages turn by turn | Goal → steward decomposes into a plan + tasks; you ratify |
| Governance | Minimal | Governed-action propose/ratify, policies, budgets, audit log, roles |
| Data ownership | Vendor cloud or laptop-only | Hub holds names/events, hosts hold bytes — you run both |
| Offline | Needs a live connection | SQLite snapshot cache — last-known-good on every list |
| Clients | Phone or web, one at a time | Mobile app and desktop workbench on the same hub |
| Open source | Mixed (Happy: yes; others: no) | Apache 2.0, self-hosted Go hub |
| Solo ML researchers | Nightly sweeps across a VPS + home GPU box — kick off from the phone, review briefings in the morning |
| Indie AI hackers | Multiple agent CLIs across projects — unified inbox, attention queue, per-pane profiles |
| Autonomy-focused startups (1–5 eng) | Budget caps, policy overrides, audit log, team roles — no other mobile agent tool has these |
| Open-source maintainers | Run triage / review agents overnight; approve agent PRs from bed |
| Homelab / self-hosters | Pull work off the laptop onto the phone without exposing raw SSH to the internet |
Be honest: if you run exactly one Claude Code session on one machine and your laptop is always on, use Anthropic's Remote Control or Happy. TermiPod's governance, multi-host, and self-hosting features have a setup cost. You shouldn't pay it unless you need what they buy.
The same control plane at full size — plus a researcher's workbench the phone doesn't have. The desktop client is a React + TypeScript frontend wrapped by an Electron shell (desktop/, ADR-055) — it succeeds the original Tauri shell, retired at the M3.4 cutover. Connect it to your hub, or use the built-in SSH terminal standalone.
Control plane:
- Mission-control shell — activity rail (Fleet · Projects · Read · Author · Inspect · Compare · Replay · Record · Terminal), fleet Navigator (hosts ▸ agents tree, live status dots), persistent status bar, ⌘K command palette with rebindable shortcuts, and a split-pane mode that pins a second surface beside the first
- Transcript workbench — live agent transcripts over SSE with Live / Insight / History modes, a composer, per-session digests, and run insights
- Approvals dock — governed actions surface as always-visible attention cards (permission prompts, propose+override, help requests, remote browser-driving approvals); ratify or reject inline
- Projects & tasks — overview with phase track and deliverables, a master-detail tasks kanban with agent-aware drag-and-drop, runs, plans, and docs
- Spawn with environments — spawn workers and stewards from templates into env profiles, with secret refs sealed client-side to the target host's key (the hub only ever stores ciphertext); teleport a paused session to another host and resume it there
- Assistant dock — a tabbed dock hosting an embedded agent web UI and a per-surface agent Companion; agents on the same host can (opt-in, audited) read webtabs, act in them, ask what you're looking at (
ui_get_focus), and you can point back with an annotation overlay - Admin & governance — team members, editable policy YAML, host/agent/team administration, live audit console, and DB upkeep behind two-click confirms
Research surfaces:
- Read — a Zotero-shaped library with arXiv / Crossref / OpenAlex / PubMed / Semantic Scholar / Unpaywall discovery, an in-app PDF/EPUB reader with annotations, open-access PDF download, and a real browser tab
- Author — Markdown + math writing with an outline nav, WYSIWYG and canvas editors, figures (Mermaid / Graphviz / Vega), draw.io and Excalidraw embeds
- Inspect — code, diffs, logs, and model checkpoints: project trees over local / SFTP / hub / GitHub / HuggingFace roots, a config-only model view with VRAM + FLOPS estimators, and an architecture schematic that handles hybrid linear-attention stacks and diffs one model's config against another's
- Compare — multi-run metric overlays side by side
- Replay — embodied-AI datasets and episodes: a dataset library with digests, an episode player syncing channel plots + multi-camera video to one cursor, URDF forward kinematics driving a 3D pose panel, and Export to Rerun (local or over your own SSH session)
- Record — ADR-shaped capture of decisions and findings
And underneath:
- Breakglass SSH terminal — direct SSH + SFTP with jump hosts (ProxyJump) and SOCKS5,
ssh_configimport/export, in-app ed25519 key generation, TOFU host-key pinning. Keys stay on the device — never sent to the hub - Local PTY & agent CLIs — spawn local terminals and run agent CLIs on the desktop itself
- Vault & sync — WASM vault crypto with cross-device zero-knowledge sync; folder sync over WebDAV, S3, and Zotero-layout backends
- Voice input — streaming dictation into the composer
- Yours to theme — light / dark / system themes and English / 中文 i18n throughout
- Self-updating installers — macOS
.dmg, Windows.exe, Linux.AppImage/.debwith a built-in updater; a one-time migration imports state and secrets from a previous Tauri install
- Ed25519 / RSA keys — generate on-device (RSA 2048 / 3072 / 4096) or import, stored in Android Keystore / iOS Keychain with optional passphrase, one-tap public-key copy
- SSH ProxyJump — connect through bastion/jump hosts to internal machines
- SOCKS5 proxy — route through corporate proxies, VPNs, or Shadowsocks/Clash
- Raw PTY mode — direct shell access for servers without tmux, with a one-tap shortcut from any tmux connection card
- Connection testing — verify SSH + tmux before saving
- Auto-reconnect with exponential backoff — up to 5 retries; commands you type while disconnected are queued and flushed automatically once the link is back
- Latency indicator — live ping in the header (color-coded: green < 100 ms, red > 500 ms) so you know whether the lag is your fingers or the network
- Adaptive polling — refresh rate ramps from 50 ms (active) down to 500 ms (idle) to save battery
- Background connection service — Android foreground service keeps SSH alive while the app is backgrounded; optional keep-screen-on for long sessions
- Dashboard — recent sessions sorted by last access with relative timestamps ("Just now", "5 min ago"); one tap reconnects and restores the last window + pane
- Visual navigation — breadcrumb header: tap Session > Window > Pane to switch
- Pane layout view — accurate proportional split visualization, tap any pane to focus
- Two-finger swipe between panes
- Pinch to zoom the terminal (50%–500%) for quick readability bumps
- Copy / scroll mode — toggle to select text without the screen jumping; updates buffer until you exit and copy lands in the system clipboard
- Create / rename / close sessions and windows
- Bell / Activity / Silence alerts — tmux window flags monitored across all connections; tap any alert to jump straight to that window and pane (alert auto-clears)
- 256-color ANSI terminal rendering with auto-extend scrollback
| Component | What it does |
|---|---|
| Action bar | Swipeable button groups per profile — ESC, Tab, Ctrl+C, arrows, one tap away |
| Compose bar | Multi-line text field with send button. Multi-line input ships as one bracketed paste so AI agents and shells see the block intact, not N separate commands. Long-press send to omit Enter |
| Direct Input mode | Real-time keystroke streaming with a live indicator — every tap goes straight to the pty, ideal for vim, less, htop, REPLs |
| Custom keyboard | Flutter-native QWERTY with Ctrl/Alt/Esc/arrows. Built-in live key strip (Home / End / PgUp / PgDn / Del + pulse indicator) replaces the wasted compose-row gap. Arrow row auto-hides when nav pad / joystick is on. Toggle off entirely for CJK / voice input |
| Navigation pad | D-pad, joystick, or gesture surface for arrow keys + action buttons |
| Snippets | Slash commands with dropdowns for enums, text fields for free-form args. Long-press the bolt key to stash the current compose text as a draft snippet |
| Modifier keys | Ctrl / Alt as toggle buttons — tap to arm, double-tap to lock |
4 built-in profiles — Claude Code, Codex, General Terminal, tmux — each with optimized button groups. Create custom profiles for any CLI. Each pane remembers its profile and auto-detects from pane_current_command.
- SFTP upload/download with progress tracking and remote directory browser
- Image transfer with format conversion, resize presets, and path injection
Opt-in coordination layer for teams running multiple AI agents across machines. Paste a hub URL + bearer token — on the phone (Settings → Hub) or the desktop connect panel — and the shared information architecture comes alive: Projects · Activity · Me · Hosts · Settings.
Research-demo workflow: write a project directive on the phone → a steward agent decomposes it into a plan → workers on GPU hosts execute runs in parallel via cross-host A2A → a briefing agent summarizes overnight into a reviewable document. Every step surfaces on the client; you ratify, not operate. The MVP demo target is the locked ablation-sweep template (nanoGPT-Shakespeare optimizer × size; see docs/decisions/001-locked-candidate-a.md); paper-reproduction and benchmark-comparison templates are deferred until the demo lands.
Me (center, default) — your personal triage: pending approvals, urgent tasks, recent activity digest, and a Vault shortcut. Tap a pending approval to Approve / Reject inline.
Projects — project inventory; tap any row for the Project Detail surface with Overview, Tasks, Plans, Runs, Reviews, Outputs (run-produced checkpoints / curves / reports), Documents, Blobs, Channels, Schedules, and an Agents section walking agent_spawns for a parent→child org chart. FAB spawns workers via YAML with template picker, host picker, and saved presets; the Steward gets its own spawn flow. Metrics digests from trackio / wandb / TensorBoard auto-surface as inline sparklines on Run Detail. Project name / goal / template / docs root / budget are all editable inline.
Activity — team-wide audit feed (audit_events promoted): policy changes, template edits, agent lifecycle, channel posts, run state transitions — all in one filterable timeline.
Hosts — host-runner check-ins with last-seen timestamps; hosts behind NAT publish agent-cards to the hub directory and accept peer A2A calls via a reverse-tunnel relay so steward agents on a VPS can invoke workers on GPU machines end-to-end.
Team screen (header icon on Projects) — Members, Policies, team-scope channels (including the #hub-meta steward room, reachable from the AppBar chip), and Team Settings with cron Schedules, per-agent Usage / budget rollups, an Audit log, and the Templates browser for team-wide agent / prompt / policy YAML. Everything that drives behaviour — project templates, agent skills, launcher commands — is data you can edit on disk; no code changes required to add a new agent kind.
Scaling & capacity. The hub is built to run a real fleet on a single cheap VPS, no external services required. Storage and write-concurrency are sharded per team — events.db and digest.db are separate per-team SQLite files (each with its own writer), while the global hub.db holds names and events — and the per-agent digest fold runs off the ingest hot path on a bounded-staleness trigger, parallelized per team across cores. A writer/reader connection-pool split plus tuned SQLite pragmas (WAL, synchronous=NORMAL, mmap, bounded writer cache) remove the lock-contention cliff: a saturating load test on a 2 GB-RAM / 2-vCPU box sustains ~1,000 events/sec through 200 agents (~760–850 ev/s under deep load) and runs the full sweep up to ~1,000 concurrent agents with zero SQLITE_BUSY errors. The honest ceiling is events/sec, not agent count — and since real agents are bursty, the practical headroom is well above the saturating number. When one box isn't enough — HA, an off-box RAM-starved host, or sustained high write-concurrency — the storage backend is selectable per store (sqlite | postgres): SQLite is the zero-dependency default, an external managed Postgres the opt-in escape hatch (decided in ADR-045; SQLite sharding shipped, the Postgres backend is on the roadmap). Full analysis: docs/discussions/hub-scaling-storage-and-concurrency.md.
The hub itself ships as a separate Go daemon under hub/ — install with go install or run from source. See docs/how-to/install-hub-server.md for hub setup, docs/how-to/install-host-runner.md for adding a worker host, and docs/how-to/run-the-demo.md for the no-GPU dress rehearsal.
- Data export / import — full JSON backup of connections, keys, snippets, history, and settings; restore on a new device or migrate from the legacy MuxPod app
- Built-in file browser — manage SFTP downloads and app storage from Settings, share or delete files in place
- Update checker — Settings → Check for updates queries GitHub releases and links to the latest build (in-app on mobile; self-updating installers on desktop)
- Help & onboarding — cheat sheet for action bar + tmux keybindings, 4-card walkthrough
- Deep linking —
termipod://connect?server=<id>&session=<n>&window=<n>&pane=<i>opens a specific server / session / window / pane from external apps. Each connection has a stable Deep Link ID (set in Edit) so URLs survive renames; pairs with claude-telegram-notify to tap a Telegram alert straight into the right pane. Legacymuxpod://URLs still resolve - Tablet & foldable adaptive layout
- i18n — English and Chinese, follows system locale
Against mobile agent control tools (session-bridge category):
| Feature | TermiPod | Claude Code Remote Control | Happy Coder | Tactic Remote |
|---|---|---|---|---|
| Multi-agent fleet | Yes — steward spawns + coordinates | Sessions, not a fleet | Sessions, not a fleet | Sessions, not a fleet |
| Multi-host (A2A) | Yes — VPS + GPU + NAT via relay | No | No | No |
| Agent-agnostic | Yes — any CLI | Claude Code only | Claude Code + Codex | Claude Code + Codex |
| Director / steward model | Yes — steward decomposes goals | No | No | No |
| Governance (budget, audit, policy) | Yes | No | No | No |
| Self-hosted hub | Yes (Go daemon) | Cloud relay (Anthropic API) | Relay server | Cloudflare Tunnel |
| Offline snapshot cache | Yes (SQLite) | No | No | No |
| Platform | Android + iOS + iPad + macOS + Windows + Linux | iOS + Android + Web | iOS + Android + Web | iOS only |
| Pricing | Free, Apache 2.0 | Claude Max ($100+) | Free, open source | Paid trial |
Against messenger-bridge agents (different thesis, overlapping user question):
| Feature | TermiPod | OpenClaw | Hermes Agent | Claude Code Channels |
|---|---|---|---|---|
| UI surface | Purpose-built mobile + desktop apps | Existing messengers (WhatsApp, Telegram, Slack, Signal, iMessage, Discord, 15+) | Telegram / Discord / Slack / WhatsApp / Signal | Telegram + Discord |
| Primary use case | Fleet cockpit + research ops | Personal assistant across messengers | Personal assistant + self-improving skills | Remote Claude Code via chat |
| Agent topology | Director → steward → fleet | One agent, cross-platform memory | One self-improving agent | One local Claude Code session |
| Multi-host / A2A | Yes | No | No | No |
| Plan ratification | Structured plan + Approve | Conversational | Conversational | Conversational |
| Governance UI | Budgets, policy, audit | None (chat only) | None (chat only) | None |
| Rich UI (plots, kanban, runs) | Native | Text only | Text only | Text only |
| Offline snapshot | Yes | No | No | No |
| Open source | Apache 2.0 | MIT | Open | Plugin repo |
| Vendor lock-in | None | None | None | Requires Claude Pro/Max |
When to pick which: Use a messenger bridge when you want a personal agent answering in the apps you already use 20 hours/day. Use TermiPod when you're directing a fleet across your own infrastructure and need purpose-built screens for plans, runs, reviews, governance. The two coexist happily on the same phone.
Against mobile SSH clients (TermiPod also covers this layer — breakglass, not product):
| Feature | TermiPod | Termux | JuiceSSH | Termius | ConnectBot |
|---|---|---|---|---|---|
| Platform | Android + iOS + iPad + desktop | Android | Android | Multi | Android |
| tmux integration | Native visual | Manual CLI | None | None | None |
| AI agent profiles | Claude Code + Codex, per-pane | None | None | None | None |
| SSH jump host | Built-in | CLI | CLI | Built-in | None |
| SOCKS5 proxy | Built-in | CLI | None | None | None |
| File transfer | SFTP with UI | Local FS | None | SFTP | None |
| Custom keyboard | Flutter-native | None | None | None | None |
| Open source | Yes (Apache 2.0) | Yes | No | No | Yes |
Android: Download the latest APK from Releases and install.
iOS / iPadOS: Build from source with Xcode (see below). TestFlight is on the roadmap.
Desktop (macOS / Windows / Linux): Download the latest desktop installer from Releases (look for electron-v* assets: .dmg, .exe, .AppImage/.deb). Unsigned builds: on macOS, right-click → Open the first time; on Windows, More info → Run anyway past SmartScreen.
git clone https://github.com/physercoe/termipod.git
cd termipod
flutter pub get
# Android
flutter build apk --release
# iOS / iPadOS (requires macOS + Xcode)
flutter build ios --release# Desktop workbench (requires Node 22+)
cd desktop
npm ci && npm run build # the shared React + TS frontend
cd electron && npm install
npm start # dev-launch the Electron shell
# installers: npx electron-builder --mac | --win | --linux
# (see desktop/electron/README.md for packaging, signing, and the update feed)- Add a host — Tap + on the Hosts tab (mobile) or open the connect panel (desktop), enter host / port / username
- Authenticate — Password or SSH key (generate via the Keys tile on the host detail screen)
- Optional — Configure jump host or SOCKS5 proxy in the connection form
- Navigate — Expand host > session > window > pane
- Interact — Action bar for quick keys, compose bar for commands, bolt button for snippets, [+] for file transfers
| Component | Requirement |
|---|---|
| Mobile device | Android 8.0+ (API 26), iOS 13.0+, iPadOS 13.0+ |
| Desktop | macOS (Apple Silicon + Intel), Windows 10+, or a modern Linux distro; Node 22+ only for building from source |
| Server | Any SSH server (OpenSSH, Dropbear, etc.) |
| tmux | Any version (tested 2.9+) — optional with raw PTY mode |
| Network | Direct SSH, or via jump host / SOCKS5 proxy |
| Hub (optional) | The Go daemon under hub/ on any small VPS; clients take a URL + bearer token |
The MVP target is the research demo described in docs/spine/blueprint.md §9 Phase 4: user writes a directive → steward decomposes → fleet executes runs across hosts → briefing agent summarizes overnight → user reviews on phone.
Mobile + hub + host lanes (CalVer YYYY.MMDD.HHMM since 2026-07-22,
tagged per component as mobile-v* / hub-v* / host-v*), phase status
as of 2026.730.1231-alpha:
| Phase | Status |
|---|---|
| P0 — Hub primitives (schema) | ✅ Shipped |
| P1 — Structured wire (protocols) | ✅ Shipped |
| P2 — App UI | ✅ Shipped |
| P3 — Integrations (trackio, A2A relay) | ✅ Shipped |
| P4 — Research demo | 🟡 Backend feature-complete; hardware run remaining |
The demo path is shipped end-to-end on the dress-rehearsal harness
(seed-demo + mock-trainer, no GPU needed). The actual hardware
run of Candidate A (nanoGPT-Shakespeare optimizer × size sweep) is
the MVP milestone — gated on two consecutive walkthrough-clean
device tests.
Desktop lane (electron-v*, CalVer, own changelog): the Electron
migration (ADR-055) is complete — M1 scaffold + hub bridging, M2 native
ports (PTY, SSH/SFTP + keys, folder sync, vault WASM), M3 packaging +
electron-updater + first-boot migration from a Tauri install, M3.4 Tauri-lane
retirement, and M4 Chromium paydown (Playwright-driven e2e harness, native
context menus, <webview> embeds). Since the cutover the lane has shipped the
research surfaces (Read / Author / Inspect / Compare / Replay / Record),
embodied replay (J8), the agent browser bridge + UI-context arc, env profiles +
session teleport, and the split-pane shell. Auto-update stays manual-install
until the signing certs land and a release is promoted onto the
electron-latest feed. Record:
docs/changelog-desktop.md, plan:
docs/plans/desktop-electron-migration.md.
Still open (post-demo):
- Briefing agent overnight schedule — steward schedules the briefing autonomously (today the user fires it).
- iOS TestFlight / App Store distribution — Android APK ships; iOS builds are local-only today.
- A2A peer auth — per-agent tokens on the reverse-tunnel relay so cross-team calls can be authenticated end-to-end.
- Domain packs / marketplace — content-pack extensibility (post-MVP; see docs/discussions/post-mvp-domain-packs.md).
Live trackers:
- docs/roadmap.md — Now / Next / Later
- docs/plans/research-demo-gaps.md — demo-scoped detail
- docs/changelog.md — what shipped per release (mobile + hub)
- docs/changelog-desktop.md — the desktop lane
- docs/decisions/ — ADRs (numbered, append-only)
TermiPod is a derivative work of MuxPod by @moezakura (Copyright 2025 mox), licensed under the Apache License 2.0. The original MuxPod provided SSH connectivity and basic tmux session viewing for Android. TermiPod has since diverged substantially with cross-platform support, input UX redesign, agent profiles, SFTP, ProxyJump, SOCKS5, custom keyboard, the hub control plane, and the desktop workbench. TermiPod is an independent project, not affiliated with the original author. See NOTICE for full attribution.
Found a bug or have a feature request? Open an issue or send feedback from Settings > About in the app.
Flutter on mobile, React + Electron on desktop, Go in the hub. Made for developers who live in the terminal.