Usage Guide

How to use imux from first launch to daily execution.

imux is a terminal-first AI command center for macOS — built for multi-agent execution in the agent era, not a full VS Code/Cursor IDE clone. Claude, Codex, and your agents are the workers; imux is the workshop. Use this guide as the baseline operating manual: pick a default path and keep execution, verification, remote ops, and Git-visible work in one native workbench.

Quick start
  1. 01

    Download the current macOS build and install imux as your daily workbench.

  2. 02

    Open a workspace from a local repo or a configured SSH host — one goal per workspace.

  3. 03

    Pick one default path: terminal agent CLI (most power users), Agent Chat (in-app LLM), or Mission Control (goal → fleet → verify).

  4. 04

    Verify with explorers, in-app edit, browser surfaces, Git sidebar, and Mission Control predicates without leaving imux.

Default paths by persona

Do not open every surface at once. Choose one primary path for the session. imux is the daily driver — multi-agent execution, files, SCM, browser, and remotes in one command center.

A. Terminal agent CLI (recommended for power users)

Run Claude Code, Codex, Aider, Cursor Agent CLI, or your own tools as real terminal processes — side by side. imux is the host workbench; the agents are the workers.

  • Split panes for implement / review / test agents when useful.
  • Start the agent in the Ghostty terminal with files and SCM visible.
  • Watch Git dirty state and open diffs/previews in imux as first-class evidence.

B. Agent Chat (in-app LLM for focused tasks)

Use Agent Chat when you want streaming chat, @file/@symbol context, slash commands, and reviewable diffs inside imux.

  • Open Agent Chat (Cmd+Shift+L) with the repo workspace already selected.
  • Prefer /review, /fix, /test for bounded tasks; apply diffs only after you inspect them.
  • Keep the terminal visible for builds and tests the chat cannot replace.

C. Mission Control (multi-agent fleet orchestration)

Open Supervisor → Mission Control after you have a concrete goal. Set done-when predicates, Start Mission to dispatch ready fleet panes, and Verify without relying on LLM self-grade alone.

  • Write a one-sentence goal and completion checks (git clean, shell, HTTP) before starting.
  • Start Mission enqueues a mesh task and injects a brief into idle Claude/Codex/terminal peers.
  • Use the fleet roster (Needs input / Working / Ready) at transitions — not for every keystroke.

D. Switch from VS Code / Cursor

Treat imux as the terminal-first command center beside (or instead of) Electron IDEs for agent-era work on macOS. Move agent runs, file inspect, SCM, remote, and browser verification into one native workbench.

  • Open the same git root you used in VS Code or Cursor.
  • Run agent CLIs and long builds in Ghostty terminals instead of the integrated terminal.
  • Use explorers, in-app edit, browser, and SCM for the full loop — no second IDE required for daily work.

E. Remote operations loop

Treat each SSH host as a first-class workspace with the same discipline as local work.

  • Connect only after confirming the SSH target and credentials.
  • Wait for the remote shell before browsing the remote explorer.
  • Use one workspace per host so logs and paths never mix.

1. Start with a workspace, not a loose terminal

imux is optimized around a workspace model. The workspace should represent one concrete project or one concrete remote host so the terminal, files, browser tasks, and supervisor all reference the same operating context.

  • Create a local workspace from the repo or folder you actually want to work on.
  • Use a dedicated remote workspace for each SSH target instead of mixing unrelated hosts together.
  • Keep one goal per workspace when possible. That keeps supervisor plans and file context cleaner.

2. Use the local and remote explorers as your control plane

The explorer is not decorative. It is the fastest way to inspect project shape, open files, confirm paths, and stay oriented while the terminal conversation is active.

  • Use the local explorer to inspect repo structure before editing or delegating work.
  • Use the remote explorer only after the SSH session is actually connected and authenticated.
  • Drag file paths into the active terminal conversation when you want the path to become part of the task context.

3. Use the in-app editor as part of the workbench loop

imux can open and edit files so inspect, small fixes, and agent-diff review stay on the same deck as terminals and Git. Keep the loop inside imux for daily work.

  • Click a file to preview or edit; use agent CLIs for large multi-file rewrites when that is the better tool.
  • Save and return to the terminal/agent thread without losing workspace context.
  • Confirm exact contents before applying agent diffs or continuing a supervisor loop.

4. Treat the supervisor as an execution layer, not a chat toy

The supervisor works best when you give it a concrete target, enough repo context, and a bounded objective. It should reduce ambiguity and compress the next move into a plan that can actually be executed.

  • Give each workspace a clear objective before asking the supervisor to take over.
  • Review the proposed next steps instead of accepting vague plans blindly.
  • Use the supervisor to frame work, track progress, and keep multiple active tasks from drifting.

5. Keep source control visible while changes are happening

imux is most useful when Git state stays visible during execution rather than becoming an afterthought at the end of the task.

  • Check branch and working tree state before you start editing.
  • Use visible file paths and repo context to avoid accidental edits in the wrong place.
  • Review current changes before packaging or publishing any result.

6. Upgrade with a release-first habit

Do not treat upgrades as a blind overwrite. imux should be updated with the same discipline you apply to any other developer tool that controls project context, remote access, or model settings.

  • Read the changelog before replacing the app build.
  • Reconfirm model settings, SSH behavior, and any saved connection preferences after updating.
  • Use one clean workspace to validate the new build before you move all active work onto it.
Best practices that improve the experience fast

A few habits change imux from a promising shell wrapper into a much more reliable command center.

Pick one default path per session: terminal agent CLI, Agent Chat, or Supervisor — not all three at once.
Keep one repo or one remote host per workspace whenever possible.
Set the workspace objective before handing control to the supervisor.
Keep the full loop in imux: agents, files, tests, browser, remote, and Git evidence on one surface.
Drag precise file paths into the active thread instead of describing files vaguely.
Check Git state early, not only at the end of the task.
Use the in-app file view for confirmation after non-trivial generated changes.
Validate one clean local path and one clean remote path after every upgrade.
How to brief imux so execution starts in 2 to 3 turns

Most slow starts come from vague goals, not from missing features. A short, concrete brief usually gets imux into execution mode fast.

Name the exact repo, folder, or SSH target first.
State one outcome you need now instead of bundling several unrelated goals together.
Mention the most relevant files, commands, or URLs if you already know them.
Define what done looks like in one measurable sentence.
Use the next reply to tighten scope or priorities instead of rewriting the full request.
Troubleshooting and recovery

When imux feels slow, noisy, or unreliable, the fix is usually operational rather than magical. These are the first checks worth making.

SSH connection looks stuck

Most remote failures are caused by incomplete authentication, mismatched SSH config, or trying to browse files before the connection has fully settled.

  • Reconfirm the target in your SSH config and reconnect cleanly.
  • Wait for the terminal to show the connected shell state before using the remote explorer.
  • Test the target in a normal SSH session if the explorer still cannot populate.

The workspace feels noisy or unfocused

This usually means the workspace goal is too broad or too many unrelated paths and tasks are sharing the same surface.

  • Split unrelated efforts into separate workspaces.
  • Narrow the active objective to one concrete outcome.
  • Close files and panes that are no longer part of the current decision path.

The supervisor is suggesting vague next steps

That usually means it is missing a bounded objective, fresh file evidence, or a clear signal about what counts as done.

  • Restate the objective in one sentence with a measurable end condition.
  • Open the most relevant files before asking it to continue.
  • Point it at the current repo state instead of relying on old chat context.
Safe update checklist
Download the latest DMG from the imux website download endpoint.
Quit the current app cleanly so open writes or active sessions are not interrupted mid-task.
Install the new build, reopen imux, and verify LLM settings plus SSH connections before resuming important work.
Check the changelog for behavior changes in explorers, supervisor flow, file editing, or routing.
imux
imux
AI macOS için Komuta Merkezi

Yerel Swift ve AppKit. Ghostty dereceli oluşturma. Operatörün öncelikli olduğu tek bir çalışma alanında yerel ve uzak bağlam, dosya işlemleri, tarayıcı yürütme, kaynak kontrolü ve denetim.

© 2026 imux. Terminal öncelikli AI uygulaması için bir kokpit.

www.iccjk.com