v0.11.0 macOS 12+ · Open source · AGPL 3.0

Your terminal, but way better.

Name: Agents UI
Author: Fusionbase

A native terminal with AI agents, SSH, a code editor, split views, and the agent-native agsh POSIX shell built in — so you ship from one window instead of six.

AI Agents Run Claude, Codex & more side-by-side in persistent split sessions.

Full-Stack SSH Browse, edit, and transfer remote files — no separate SFTP client needed.

MCP Automation Automate any workflow with visible, auditable tool calls.

Download for macOS View on GitHub

Free & open source · No account required · Signed and notarized for Apple Silicon

Agents UI

Workspace Fusionbase

Projects New

Client Portal

Indie SaaS 2

~/dev/indie-saas

codex-1

claude-1

>_ shell-1

>_ ssh-prod

Data Pipelines

Docs Site

Split views

Split view right

A codex-1 B claude-1

claude-1 codex-1 ~/dev/indie-saas ×

Claude Code v2.1.170

Fable 5 with xhigh effort · Claude Max

~/dev/indie-saas

Fable 5 is here! Our newest model for complex, long-running work

Included in your plan limits until Jun 22, then switch to usage credits to continue.

> Refactor the auth module and add tests.

⏺ I’ll map the auth module, then add coverage.

⏺ Read(src/auth/session.ts)

⎿ Read 212 lines

⏺ Update(src/auth/session.ts)

⎿ Added refresh-token rotation

⏺ Bash(npm run test:auth)

⎿ 18 passed in 1.4s

✶ Churning… (14s · ↑ 1.2k tokens · esc to interrupt)

? for shortcuts · tab to plan mode

>_ OpenAI Codex (v0.81.0)

model: gpt-5.2-codex medium · /model to change

directory: ~/dev/indie-saas

› Ship the new pricing page, then run lint and tests.

• Explored

└ Read pricing.tsx, plans.ts

• Updated Plan

└ ✓ Add annual billing toggle

✓ Wire Stripe price IDs

□ Run lint + tests

• Ran npm test

└ ✓ 48 passed in 2.1s

⠇ Polishing pricing copy (2m 11s · esc to interrupt)

›

97% context left · ? for shortcuts

train.py

report.pdf

metrics.csv

README.md

ssh: deploy@gpu-prod · /srv/ml/train.py

41def train_epoch(model, loader):

42 model.train()

43 for batch in loader:

44 loss = step(model, batch)

45 optimizer.zero_grad()

46 loss.backward()

47 optimizer.step()

48 return loss.item()

Training Report — run 42

Indie SaaS ML · deploy@gpu-prod · June 2026

Six epochs on the v3 dataset (48k samples). Validation accuracy reached 83.4% with cosine learning-rate decay; no signs of overfitting after epoch 4.

Fig. 1 — accuracy (solid) vs. loss (dashed) per epoch

Checkpoint model.pt was exported at epoch 6 and promoted to staging for evaluation against the held-out set.

#	epoch	loss	acc	lr
1	1	2.314	0.412	3e-4
2	2	1.872	0.534	3e-4
3	3	1.401	0.638	2e-4
4	4	1.083	0.717	2e-4
5	5	0.842	0.789	1e-4
6	6	0.671	0.834	1e-4

Indie SaaS ML

Training pipeline for the recommendation model. Runs on the GPU box over SSH.

Quick start

Install deps: pip install -r requirements.txt
Train: python train.py --epochs 6
Metrics land in metrics.csv

$ python train.py --epochs 6
epoch 6/6  loss 0.671  acc 0.834

~/indie-saas main ❯ git status

On branch main · up to date with 'origin/main'

nothing to commit, working tree clean

~/indie-saas main ❯ keep -- npm run dev

VITE v6.3.1 ready in 384 ms

➤ Local: http://localhost:5173/

kept as [k1] · closing this terminal only detaches it

~/indie-saas main ❯ docker compose ps

NAME STATUS PORTS

api Up 2 hours 0.0.0.0:8080->8080

postgres Up 2 hours 5432/tcp

~/indie-saas main ❯

PricingToggle.tsx

plans.ts

~/dev/indie-saas/src/billing/PricingToggle.tsx

14export function PricingToggle({ plans }: Props) {

15 const [annual, setAnnual] = useState(true);

16 const price = annual ? plans.yearly : plans.monthly;

17 // Stripe price IDs live in plans.ts

18 return <Toggle value={annual} onChange={setAnnual} />;

19}

metrics.csv 1,204 rows · 4 cols ×

monthmrrsignupschurn

2025-09$5,1601982.6%

2025-10$5,9302242.4%

2025-11$6,7102512.2%

2025-12$7,5402802.0%

2026-01$8,4203121.8%

2026-02$9,1803481.6%

2026-03$10,2404011.4%

2026-04$11,6154441.2%

2026-05$12,9304891.1%

Streaming preview · loaded in 64 ms

patrick@mbp ~ % ssh deploy@prod

Welcome to Ubuntu 24.04.2 LTS (GNU/Linux 6.8.0)

Last login: Tue Jun 9 07:14:02 2026 from 10.0.0.4

deploy@prod:~$ systemctl status api --no-pager

● api.service — Indie SaaS API

Active: active (running) since Tue 06:02; 3h ago

deploy@prod:~$ tail -f /var/log/api/out.log

[09:48:05] POST /orders 201 38ms

[09:48:09] GET /health 200 2ms

deploy@prod:~$

Claude Code & Codex, one click apart Switch agents with the claude / codex tabs — beside built-in code, PDF, CSV & Markdown viewers on files from your GPU box over SSH.

Sessions

Persistent shells + split views keep active work alive across restarts.

Orchestrate

Convert a goal into tasks, dispatch parallel runs, and monitor plan status.

MCP Tools

Automate sessions, files, projects, and SSH with visible tool call history.

Built for solo shippers

For solo shippers who live in the terminal.

Keep coding, remote work, orchestration, and release prep in one place instead of bouncing between terminal, SSH app, editor, and notes.

Who this is for

Solo founders and lean teams shipping product continuously with AI coding agents and terminal-heavy workflows.

What it replaces

Window juggling across terminal app, SSH client, file browser, editor, and ad-hoc notes for tracking agent progress.

What improves

Fewer context switches, faster release prep, and repeatable execution with MCP tool automation plus persistent session state.

Fully programmable

Steer the terminal from Python.

Agents UI exposes every action — sessions, commands, files, projects — as a programmable API. The open-source Python SDK lets you script, orchestrate, and automate the terminal from any Python environment.

from agents_ui import SyncAgentsUIClient

with SyncAgentsUIClient() as client:
    # Create a project and session
    project = client.projects.create("deploy", base_path="/app")
    session = client.sessions.create(project.id, name="build")

    # Run a command in the terminal
    client.sessions.write(session.id, "npm run build\r")

    # Read and write files
    entries = client.files.list("/app", "src")
    content = client.files.read("/app", "src/config.json")
    client.files.write("/app", "src/config.json", new_cfg)

Full terminal control — create sessions, send commands, read output, and manage files programmatically.
Workflow automation — chain commands, wait for results, and build complex deployment or testing pipelines.
Agent orchestration — spin up parallel sessions, dispatch tasks, and collect results from Python scripts.
Open source — MIT licensed, pip-installable, and ready to extend.

View Python SDK on GitHub

pip install agents-ui-sdk

How it works

Goal to deploy in four moves.

01

Define the goal

Start in agent or orchestrate mode and convert your intent into tasks with explicit ownership and status.
02

Dispatch work in parallel

Run Codex, Claude, and durable agsh sessions side-by-side with project grouping, split views, and resumable shell state.
03

Automate repetitive glue via MCP

Use MCP tools for sessions, projects, files, and SSH flows while keeping tool-call history visible and auditable.
04

Ship with confidence

Review in Monaco, run terminal checks, record/replay key sessions, and move directly to release from the same workspace.

Feature matrix

What you get out of the box.

Everything needed for agent-heavy terminal work, without assembling a stack of separate apps and glue scripts first.

Programmable core

MCP tools Session, project, file, SSH, and UI operations exposed as executable tools for agent automation.

Orchestrate mode Generate plans, dispatch tasks, and monitor progress in a dedicated plan board.

Tool-call observability Structured cards show what each agent action did and where it applied.

Workspace depth

Persistent sessions + split views Keep active coding, shell, and review contexts alive across restarts.

agsh + command timeline Use the bundled agent-native POSIX-style shell by default, with structured command status, timing, output, and live directory context.

Local + SSH files + Monaco Edit, transfer, and validate code in one place without switching apps.

Command palette + recordings Trigger actions fast and replay critical terminal runs for repeatability.

Platform

Native macOS app Built with Tauri + Rust for low overhead and fast startup.

Open source + local-first Core workflows run on your machine with transparent, inspectable behavior.

Signed and notarized Apple-notarized macOS release that opens normally after download.

Built with React · TypeScript · Tauri · Rust · MCP · agsh · zellij

Install the terminal you won't outgrow.

Latest release · macOS 12+ · Apple Silicon · Signed & notarized

Get Agents UI View source on GitHub

AGPL 3.0 license · Release notes · Report an issue

What you get on day one

Requirements: macOS 12+ on Apple Silicon; agsh is bundled, so no separate shell install is required.
Best fit: Codex and Claude CLI workflows with project-based sessions.
Trust note: Local-first core workflows with no required hosted backend.

FAQ

Common questions.

What makes Agents UI a programmable terminal?

Agents UI includes MCP tools for sessions, projects, files, and SSH so agents can execute real workspace actions, not only chat.

Does the app run locally?

Yes. Agents UI runs on your machine. Core workflows are local-first and do not require a hosted backend.

Can I orchestrate multiple tasks for one goal?

Yes. Orchestrate mode converts a goal into tasks, dispatches them across sessions, and tracks completion in a plan board.

Does it support SSH for remote development?

Yes. SSH host management, file transfer, and port forwarding are all built in. Reads your existing SSH config.

Which shell does Agents UI use?

New terminals use the bundled agsh POSIX-style shell by default. You can still choose bundled Nushell, your login shell, or another installed shell globally, per project, or for a single terminal.