Give the agent the work.
Keep hold of the outcome.

Your models, harnessed.

Download for macOS

Windows coming soon

Powered by the pi coding agent · Cloud services by mux

Explore the muxcode app
Ask about the code. Keep the answer beside it.

A session reads the repository with you. The conversation, the files it opened and the commands it ran stay in one window.

A plan before implementation.

An Architect plans and reviews. Jev, the classifier, helps choose a worker from your roster.

Every seat, on the record.

The Agents pane follows a workflow as it runs: each stage, the model in each seat, its time, tokens and cost, and every command it asks to run. Pause or cancel it from there.

Read the change before it lands.

Each changed file opens beside the agent with its new lines marked. Stage, commit or merge from the same pane. Nothing leaves your Mac until you say so.

A small model reads along.

Jev answers quick yes-or-no questions while you work: is this command risky, is this turn done. When it isn't sure, nothing changes.

The muxcode desktop app.

What it is for. Four jobs, one app.

Plan first. Then choose who builds.

Your Architect handles planning, review and judgment. Your worker roster handles implementation. muxcode’s host keeps the workflow tied to its scope and checks.

One route for every change

Your Architect plans the change and writes what proves it. A worker builds it. Your checks run, and the Architect judges the result before it comes back to you.

  1. promptYou
  2. planArchitect
  3. buildWorker
  4. gateYour checks
  5. judgeArchitect
  6. branchYou land it
rejected: retried on a different model, then back through the gate

Facts come from your checks

Your typecheck, lint and tests run once before the change. A check that passed there and fails after it fails the change, whatever a model says.

Jev reads along

A small classifier answers quick questions as the work moves. A sure answer is used. An unsure one leaves your configured choice in place.

Follow a change through muxcode

Reads run. Changes ask.

Every call the agent makes goes through a gate on your Mac. What changes nothing runs at once; what reaches past the project is put to you, with the reason on the card.

Reads run on their own

In Auto, reading the code and editing inside the project run without a prompt. A command that changes something, or a file outside the project, waits for you.

Agent Gate
  • Your project
    • rg "split(" src (runs)
    • edit src/ledger.ts (runs)
  • Beyond it
    • pnpm add zod (asks you)
    • edit ~/.zshrc (asks you)

Changes ask, with the reason

The card names the exact call. Allow it once, keep a rule so you are not asked again, or deny it. The run waits until you choose.

Plan mode changes nothing

Plan mode reads and proposes. A call that would change a file or run a changing command is refused, and the agent is told why.

Walk a call through the gate

Swap the model. Keep everything.

muxcode runs on the models you already pay for. Change the model a seat uses and the work around it stays where it was.

  • Seats fill from the sign-ins you already have: Claude Code, Codex, Grok, Muse, Antigravity and OpenRouter
  • Set each seat's model and reasoning effort in Settings
  • Tasks, history, notes and permission rules stay put: switching models loses nothing
Claude Code muxcode
  • Tasks
  • Worktrees
  • History
  • Notes
  • Rules
  • Index

Cloud execution. Desktop control.

The agent session stays on your Mac. File operations and commands run in a task-specific cloud workspace, on Pro and Pro+.

muxcode · your MacConversation · model loop · permissions Authenticated connection Task workspace · mux cloudFiles · shell · container tools Git checkpoint back to you

Where each part runs

The model loop and permissions stay on your desktop; the work runs in a cloud workspace scoped to yours.

Shell
A light shell for everyday commands. No network.
Container
Linux for tools that need it. Allowed hosts only.

Two backends

The container can reach only the hosts on an allowlist. The light shell has no network at all.

  • Move the repository over GitThe task starts from your branch.
  • Read, edit and run checksAll inside the task environment.
  • Files survive sleepIdle compute sleeps; the files stay.
  • Checkpoint and landFetch the branch and review how to land it.

How the sandbox is held in

On by default

Keep working. Keep the original evidence.

Long tasks can continue in a fresh context window. Durable notes carry decisions forward, and scoped history search lets the agent read earlier messages and tool output again.

Earlier work

Read. Investigate. Decide. The full transcript stays available.

Transcriptkept, searchable
Decisionswritten to durable notes

A fresh window

Continue with room to think, and look up the original evidence when needed.

Handoffnotes + history search
Instead ofsummary compaction

Switch back to summary compaction under Settings → Models → Context windows. Editing an earlier prompt keeps the old branch.

File the bug. Get back a branch.

Post an issue from muxcode and a cloud agent takes the first pass: it reads the report, investigates in a clone of the project, and leaves its work on a branch you can land. Pro and Pro+.

  1. Issue

    Empty addresses crash checkout. Steps to reproduce inside.

  2. Investigate

    Read the validator and ran the test suite.

  3. Diff

    validate.ts +4 −1 · validate.test.ts +12

  4. Checkpoint

    muxcode/triage-3fa8 pushed. Ready to fetch.

An example run. Each triage run is scoped to your workspace.

One app for the work around the code.

The harness is more than the chat. It keeps the tools, source and decisions close to the task they belong to.

  • Tasks & worktrees Keep the conversation, working branch and session history together. Give each piece of work a place you can return to.
  • Models & providers Models come from the providers you sign in to, or ones you configure yourself. Set the model and reasoning effort for the work.
  • Skills & agents Use your shared skills and named agents. Pin agents to a provider, model and thinking level for repeatable workflows.
  • Tools & terminal output Follow source reads, edits and commands in the task. Inspect the evidence behind a result before you accept it.

These prompts already work. Swap in your own names.

Paste one into a task, change the file or feature it names, and run it.

  • Onboard Walk me through this repository: what it does, where the entry points are, and which tests cover the core.
  • Onboard Trace a checkout request from the route to the database, and name every file it passes through.
  • Ship Add rate limiting to the public API. Plan it first, then build it with tests for the limit and the reset.
  • Ship Replace moment with date-fns across the app and keep every existing test green.
  • Review Review the change on this branch against main. What could break, and what is untested?
  • Fix The nightly build fails on the date tests after 23:00 UTC. Find why and fix it.
  • Hand off Triage the newest issue: reproduce it, find the cause and leave a branch with the fix.
  • Explain Why does split() give the remainder to the first account? Show me the line and the test that pins it.
Run the work away from your Mac Toolchains you do not have, suites that take an hour, changes you would rather try elsewhere. Secure sandbox

One sign-in. A shared foundation.

Approve muxcode in your browser to connect a workspace. Your device gets its own key, and owners can revoke access from mux.

A code index your agents can share

Find patterns, search by meaning on paid plans and trace each result to its source revision, from the web or over MCP.

A workspace for the team

Keep repositories, integrations and the shared code index together. Switch workspaces and manage devices through mux.

A view of cloud work

See sandbox tasks and triage runs, their activity and checkpoints, from the workspace console.

Explore the mux platform

Bring the work. Build with muxcode.

The desktop harness is free. Connect a workspace to index a repository; Pro and Pro+ add cloud sandboxes and search by meaning.

Compare plans