Official site/v1.10.11

One cockpit for terminal-first AI execution and source control.

imux is a native macOS workspace for serious AI work. Keep terminal execution, local and remote files, Git state, GitHub links, browser tasks, and supervisor-driven next steps inside one deliberate workspace.

Download for macOS View on GitHub Docs

Platform

Native macOS

Swift, AppKit, Ghostty-grade rendering.

Workspace

Local + remote

One model for projects, SSH targets, files, and Git state.

Operating style

Zero-config first

Infer context early, expose controls only when needed.

workspace: /Users/operator/work/imux

Rail

terminal / build

repo / imux

remote / prod-ssh

browser / review

Ready to continue

Terminal conversationready

$ icc connect prod-ssh

Connected. Reading remote workspace and shell state.

$ git status --short

M Sources/WorkspaceSupervisor.swift

$ open file explorer

Paths, files, remote tree, and next action remain visible together.

agent: browser check and source review queued

Supervisor

Status

Ready to continue

Goal inferred from current repo, files, and recent task history.

Files

Open, inspect, edit, and save without leaving the workspace.

Remote

SSH-backed browsing, same layout, same path handling.

Start in one workspace

Open imux, choose a repo or SSH host, then run the agent you already trust.

imux does not replace Claude Code, Codex, Cursor, Aider, or your shell tools. It gives them a native macOS command deck with files, browser state, source control, and remote context kept in view.

quick startmacOS

$ open /Applications/imux.app

$ cd ~/work/product && claude

$ icc browser open http://localhost:3000 --split right

Terminal agents run in the Ghostty-backed shell.

Files, Git state, and browser surfaces stay attached to the workspace.

The compatibility CLI remains icc for automation scripts.

Agent stack

Bring the coding agents and command-line tools you already use.

Competitor products optimize for a single assistant or editor surface. imux is terminal-first: it keeps multiple agents, long-running processes, preview browsers, and remote sessions organized without forcing them into a new IDE model.

Agent CLIs

Claude Code, Codex, Gemini CLI, OpenCode, Aider

Run one agent per workspace, keep its terminal live, and jump back when it needs input.

Dev tools

git, gh, npm, pnpm, docker, ssh, deploy scripts

Use the same commands you already trust, with a visible workspace around them.

Human control

Operator-first instead of autopilot-only

Review paths, browser output, tests, and source-control state before moving to the next step.

Capabilities

Built for operators who want context visible while work is happening.

imux is not another browser dashboard sitting on top of a terminal. It is a command center that keeps execution, files, Git evidence, remote state, and guidance within the same working surface.

Terminal-first execution

Run serious AI work in a native macOS shell surface instead of bouncing between wrappers and detached browser tabs.

Local and remote explorers

Browse local projects and SSH-connected hosts from the same workspace, using the same mental model and the same right-side control plane.

In-app file editing

Open, inspect, edit, and save files without breaking terminal flow. Drag paths directly into the active conversation when needed.

Supervisor mode

Turn a few lines of user intent, project context, and recent work into a concrete execution brief with bounded next steps.

Browser and automation

Keep browser-backed tasks beside the terminal and expose them to the same operator workflow instead of juggling separate tools.

Source control visibility

Keep branch state, changed files, recent commits, commit diffs, and GitHub links visible while agents or operators are pushing real work forward.

Product surfaces

A complete operating surface around the terminal.

The homepage now mirrors how imux is actually used: terminal execution in the center, files and source control close by, browser automation on demand, and remote workspaces using the same layout.

01 / Terminal

Ghostty-backed terminal sessions

Fast native rendering for agent sessions, builds, logs, shells, and long-running development processes.

02 / Files

Local and remote file explorers

Browse, inspect, edit, and save project files without sending the operator into a separate editor window for every check.

03 / Source control

Branch, diff, commit, and GitHub context

Keep working-tree state and repository evidence visible while agents are writing and tests are running.

04 / Browser

Embedded browser plus automation API

Open a preview beside the shell, inspect page state, click, fill forms, capture screenshots, and read console errors.

05 / Remote

SSH workspaces with real remote files

Connect to a host, browse remote paths, edit real remote contents, and keep path context tied to the active shell.

06 / Supervisor

Execution briefs and handoffs

Compress current repo, task, files, and recent activity into concrete next steps instead of vague status chatter.

Why it lands differently

The fastest path from a few user turns to a real execution surface.

Files stay beside the active terminal instead of hiding behind a separate app.

Remote hosts use the same explorer and editing workflow as local projects.

Branch state, changed files, commit history, and project context remain visible while changes are happening.

Supervisor mode frames the next move without forcing a heavyweight setup ritual.

Product profile

RenderingGhostty-grade terminal engine with a native macOS shell surface.

Surface modelWorkspace-first layout with files, source control, browser tasks, and remote state in-view.

AutomationSupervisor, browser control, CLI compatibility, and task-ready context compression.

Release linev1.10.11 on www.iccjk.com

Best use cases

Designed for the AI workflows that become messy in normal terminals.

imux is strongest when the work has multiple moving parts: more than one agent, real code review, browser verification, remote hosts, or source-control-sensitive changes.

Run multiple coding agents without losing the active one

Use separate workspaces for parallel agent sessions, builds, and investigations. Notification rings and workspace metadata make it clear which task needs attention.

01Create one workspace per repo or task.

02Launch the agent in the terminal surface.

03Use the sidebar and notification jump to return when input is needed.

Turn a local feature request into a verified change

Keep the issue, file tree, edited files, test output, browser preview, and Git state in one command deck from plan to review.

01Open the repo and inspect the affected paths.

02Ask the agent to implement a bounded change.

03Verify files, run tests, inspect the browser, then review Git state.

Operate production or staging boxes over SSH

Remote work becomes safer when shell output, remote files, paths, and current objective remain tied to the same workspace.

01Connect to a named SSH target.

02Wait for the remote explorer to populate the actual remote tree.

03Inspect logs or files before running a risky command.

Automate web checks from the same workspace

Open the app preview next to the shell, use the browser API for deterministic checks, and keep debug artifacts with the terminal session.

01Split a browser beside the local dev server.

02Use the icc browser commands for navigation and inspection.

03Capture console errors, screenshots, and DOM snapshots on failure.

Workflow

Zero-config where it should be. Explicit control where it matters.

The product philosophy is simple: infer first, ask second. You should be able to open a project, connect a host, and start moving before you get buried in setup panels.

Open a workspace

Point imux at a local repo or connect an SSH target. Zero-config flow infers enough structure to begin immediately.

Read the working surface

Terminal state, files, branch status, changed paths, GitHub context, remote paths, and recent interaction notes stay visible in the same command deck.

Let the supervisor frame the next move

imux can compress current context into a startup plan, execution brief, or operator handoff without turning the workflow into ceremony.

Execute without losing context

Browse files, edit code, inspect output, and move between local and remote targets while the conversation stays anchored.

Automation API

Script the workspace instead of clicking through it.

The compatibility CLI and Unix socket expose the same control model used by the app: windows, workspaces, panes, surfaces, notifications, metadata, and browser actions.

Workspace control

Create, target, and inspect workspaces

Use the CLI from hooks, build scripts, or your own launchers.

$ icc list-workspaces --json

$ icc new-workspace

$ icc identify --json

Attention routing

Show what needs the operator

Send notifications and sidebar metadata from agents or scripts.

$ icc notify --title "Tests" --body "Review failures"

$ icc sidebar status set ci --label "CI" --value "running"

$ icc sidebar log --level success "Preview deployed"

Browser checks

Drive the embedded browser

Navigate, wait, inspect, and capture evidence without leaving imux.

$ icc browser open http://localhost:3000

$ icc browser surface:2 wait --text "Dashboard"

$ icc browser surface:2 screenshot --out /tmp/imux-check.png

Operating posture

Built for high-context work where mistakes are expensive.

The product language should be explicit: imux is a local macOS application with operator approval, visible context, and a scriptable control plane. It is not a cloud IDE and it is not a black-box agent runner.

Native macOS, not Electron

Swift/AppKit UI with Ghostty-grade terminal rendering keeps heavy agent workflows responsive on the desktop.

Local-first control surface

Agents and shell tools run in your terminal environment. imux wraps them with layout, navigation, browser, and automation surfaces.

Explicit automation access

Socket access can be disabled, limited to imux-managed processes, or opened deliberately for trusted local automation.

Release chain you can verify

The website exposes the stable DMG, Sparkle appcast, latest manifest, changelog, and remote helper manifest from one public source.

Documentation

From landing page to operating manual.

The site now routes users into practical workflows instead of stopping at a feature list. Start with installation, then move into agent loops, remote workspaces, supervisor usage, and automation.

Getting started

Install the macOS app, wire the compatibility CLI, and understand the update path.

Open setup guide->

Agent workflows

Recommended patterns for Claude Code, Codex, Aider, Gemini CLI, OpenCode, and parallel sessions.

Plan agent work->

Remote workspaces

Use SSH workspaces safely with remote explorers, real remote files, and path-aware operations.

Operate remote hosts->

Supervisor mode

Brief imux, turn current context into an execution plan, and keep handoffs concrete.

Use the supervisor->

Browser automation

Drive the embedded browser for preview checks, DOM inspection, screenshots, and console evidence.

Automate browser checks->

CLI and socket API

Control workspaces, surfaces, notifications, metadata, and browser state from scripts.

Read the API->

Resources

Use imux with less guesswork and track what changes release by release.

The site now includes a practical product guide plus a changelog that records what shipped, what public copy changed, and how to upgrade without losing context.

Usage Guide

A complete operating guide for local workspaces, remote hosts, file editing, supervisor flow, source-control-aware workflows, and safe upgrades.

Open guide->

Upgrade Log

A structured release history for imux, including the first public line, website rollout, localization updates, and upgrade notes.

View changelog->

FAQ

Direct answers for what people ask first.

The product stays opinionated about workflow quality, while remaining practical to adopt.

Is imux just a Ghostty fork?

No. imux is a native macOS command center built on Ghostty-grade terminal rendering. The product expands that foundation with explorers, editing, browser execution, supervision, and workspace orchestration.

Who is imux for?

Operators, engineers, founders, and power users who already run multiple AI-assisted workflows and want one sharper control surface instead of more window sprawl.

What makes the workflow different?

imux keeps the terminal first-class while adding the missing surfaces around it: files, remote hosts, branch and commit context, browser context, and an execution-focused supervisor.

Does it support remote work?

Yes. imux reads SSH configuration, connects to remote targets, and exposes remote files in the same explorer model used for local work.

Launch imux

Move from intent to execution without losing the shape of the work.

Download the current macOS build or track releases and source on GitHub. The public site, release line, and repository are now aligned to one identity: imux.

Download for macOS View on GitHub