Skip to content

muxcode: advanced guide

Guide

For people who already run tasks in muxcode, the desktop app, and want more from it: which kind of task to start and where it runs, context that is never summarised away, memory across sessions, your workspace’s code index, your own MCP servers, skills, landing the work, and running on your Mac alone, on any plan. How Clef works covers the classifier that reads along.

This guide describes muxcode 1.0.30, the current download. Cowork, How Context works and How Memory works each have a guide of their own. Settings shows which version you run.

  1. Download muxcode for your Mac from the download page, install it in Applications, and open it.
  2. Open the workspace settings and choose Connect to mux. In the browser, sign in on usemux.com, choose or create your Personal workspace, check that the device code matches, and approve Connect this Mac. Wait for muxcode itself to show the connected workspace; the browser’s Connected message alone does not confirm that the desktop received the connection. This step is optional: muxcode runs on your Mac without it. See Run on your Mac only.
  3. Open Settings → Models and sign in to your model provider. Choose OpenAI → Sign in with ChatGPT or Anthropic → Sign in. Your mux account connects the workspace and cloud services; it does not sign you in to either model provider. On Hobby the default workflow needs both. On Pro, Pro+ and Team it runs without either: a seat you have not signed in for runs on DeepSeek until you do.
  4. Attach a repository you can use for the task. You can work on its checkout before configuring the shared code index. Choose a model and thinking level in the composer, then send a small read-only question first.
  5. Check the plan pill beside your avatar. If a trial is active, open it to see the remaining time, sandbox usage and reset date. The three-day trial includes 3 sandbox hours and one running sandbox at a time. Paid-plan allowances are on the pricing page.

More workspaces. Create workspace, in the workspace switcher at the foot of the sidebar, opens mux’s workspaces page, where you give the workspace a name and a short name. A team workspace has no plan of its own: each member brings their own. Connect workspace then signs this Mac in to the one you pick there, and it shows in the switcher under the name mux gives it. To take a workspace other than Personal off this Mac, hover it in the switcher and press ×, or choose Remove from this Mac in its Workspace Settings. Stop its running tasks first. Its repositories move to Personal and its keys on this Mac are cleared; nothing is deleted from disk, and the workspace stays on mux with its members and plan.

Sandbox by default, in Settings → Models → Cloud sandbox, decides where new tasks run. It starts on with a paid plan or a live trial, once this Mac is connected to mux, so your first task there runs in the cloud unless you choose otherwise. With it on, a new task’s mode picker opens on Sandbox, under Cloud, and lists Ask every time, Auto, Plan and Bypass permissions under This Mac: pick one of those to run a single task on your Mac without touching the switch. Turn it off and new tasks start on your Mac, with only those four in the picker. Changing it does not move a task that already started. On Hobby in your own workspace the switch stays off, and every task runs on your Mac. In a team workspace, a Hobby member sees Sandbox by default on, but mux refuses a sandbox on Hobby, so switch it off to run tasks on your Mac.

On your Mac, muxcode’s permission gate answers every tool call. Ask every time asks before each command and edit unless a rule you saved allows it. Auto runs read-only commands and edits inside the project, and asks for the rest. Plan reads and plans, and changes nothing. Bypass permissions runs tools without asking; Clef can still put a risky command to you. A card names the exact call and offers Allow once, allow for this session, Always allow and Deny, in that order. Some calls, such as an edit inside a .git folder, offer only the first and last.

Cloud: listed while Sandbox by default is on

SandboxRuns in your cloud sandbox without prompts. It holds no credentials from this Mac.

This Mac: listed with the switch on or off

Ask every timeAsks before commands and edits, unless your rules already allow them.

AutoAllows project edits and read-only commands. Asks when it needs more.

PlanExplores files and plans changes, without editing or running commands.

Bypass permissionsRuns tools on your Mac without asking.

a card, under Ask every time Allow bash? ls
Allow oncethis call only Allow `ls` this sessionuntil the app quits Always allow `ls`a rule for the project Denywith an optional note
Why not, or what to do instead
Always allow saves a rule for the project, so the same call does not ask again; Deny can tell the agent what to do instead.

If provider sign-in fails, fix the named provider connection before starting its workflow. Reconnecting to mux does not repair a model-provider sign-in. Use the version shown in Settings when reporting a sign-in error.

The composer starts four kinds of work, and Cowork starts a fifth from its own page. Choosing the right one matters more than the prompt.

Shape Use it for Start it with
Chat a question, a small edit, a look around type in the composer
Workflow a change you want planned, checked and judged the workflow’s root model, or /muxcode-workflow
Analysis a broad, read-only investigation ask for one in your own words
Sandbox isolation, long runs, Linux Sandbox by default on, then Sandbox in the mode picker
Cowork a GitHub issue, or a bug or feature in your words, to a draft pull request ⌘I, Cowork in the sidebar, or a message that starts with @Cowork

Chat is one model under your permission mode, with no plan. A workflow first has Clef pick the change’s lane, then runs it through these steps:

  1. An Architect plans it.
  2. A worker writes it inside a contract.
  3. A gate checks that the worker stayed in scope.
  4. Your checks run.
  5. A judge accepts or rejects the result.

From muxcode 1.0.12, a change Clef is sure is confined to one place and provable by your project’s checks runs solo on your Mac: one worker, no plan, review or judge, with your checks run before and after as the proof. A failing check, a risk the gate flags, an empty change or a project with no checks sends it to the full workflow. A change whose mistakes would likely pass the tests, or that the gate reads as High risk, gets a second reviewer after the judge, on a model that neither wrote nor judged it. When none of your sign-ins offers such a model, no second reviewer sits and the judge’s accept stands. How Clef works has the bars.

An analysis sends readers out in parallel and brings their findings back as one answer. A sandbox runs any of these in a cloud container instead of on your Mac.

The cloud sandbox comes with Pro, Pro+ and the trial, within the allowance shown in the plan sheet. Pro runs 5 sandboxes at once and 40 sandbox hours a month, Pro+ 12 and 300, and the trial 1, for 3 hours over the whole trial. mux warns at 90% of the hours, and stops running sandboxes at the cap.

running at once sandbox hours Pro 5 at once 40 h a month Pro+ 12 at once 300 h a month Trial 1 at once 3 h in all Hobby no sandboxtasks run on your Mac
Hours drawn to scale: Pro+ has 300 a month, Pro 40 and the trial 3 in all.

In a team workspace, each member uses their own plan’s sandbox. Hobby has none. Cowork runs in the cloud too, on mux’s included model, so it needs Pro or Pro+, your own plan in a team workspace; a trial does not include that model.

There are three ways in, and all three go to the same place:

  • Pick the root model. Choose the workflow’s root model in the composer. For the roster muxcode ships, that is DeepSeek V4.1 Flash, listed under AI Gateway, which mux includes with Pro and Pro+. On Hobby or the trial, pick a root from your own sign-ins on the Agents page. The workflow’s skill tells that model to send every change through the workflow.
  • Use the command. Type /muxcode-workflow <name> <goal>, for example /muxcode-workflow default add a summary() to the ledger. Use the name shown in your Agents panel; older saved rosters may have another name.
  • Ask for it. Say so in plain words: “run this through the workflow: …”.

The shipped roster’s root is DeepSeek V4.1 Flash on mux. From muxcode 1.0.27 the other seats use one sign-in, Anthropic, under Settings → Models: Claude Opus 5.5 as the Architect, at high, the worker, at medium, the retry, at high, and the judge, at high.

Each seat runs at the reasoning level set for it, for the whole attempt; from muxcode 1.0.12, Clef no longer raises a seat’s effort or picks its worker. The judge reads the finished change in a context of its own, and you can put it on any model, the worker’s included; a second reviewer is always on a model that neither wrote nor judged the change. Every seat can be changed on the Agents page. If the judge’s sign-in is missing, muxcode seats another model that wrote nothing in the run. With the shipped root, a seat whose sign-in is missing runs on DeepSeek V4.1 Flash at its own level until you sign in, and the judge falls back to DeepSeek only when no other model is offered. A workflow rooted on one of your own sign-ins stops before its first step and names the sign-in it needs.

Every seat is handed your own messages word for word, beside the root’s summary: up to 12 of them, 2,000 characters each and 8,000 in all. A constraint you typed reaches the planner and the judge even if the summary leaves it out.

The shipped root needs mux’s included model. On Hobby or the trial, root the workflow on one of your own sign-ins, and every seat runs on them. Clef’s readings in a run, the solo lane included, need Pro, Pro+, the trial or a Cloudflare token of your own; without them, every change takes the full workflow and the code’s own checks decide. Each workflow has an on and off switch on the Agents page. A workflow you switch off refuses to start until you turn it back on.

A workflow’s controls are in the Agents panel.

Control Where What happens to the run
Pause Agents panel It waits; the attempt in flight finishes.
Resume Agents panel It carries on with the same run and contract.
Cancel Agents panel It ends; partial changes stay in your tree.
Stop composer It is cancelled along with the chat turn.

Asking again after Stop starts a new run from the plan. The planner reads the tree as the stopped run left it and works from there. A run that muxcode pauses by itself also waits for you in the Agents panel; that happens when a file changes outside the contract, a tool the run needs is missing, the judge rejects the work after the retry, or a seat reaches its time limit (20, 30 or 45 minutes, by the repository’s size). From 1.0.22, a judge’s rejection keeps the verified work, and Resume tries once more on the judge’s points.

Sandbox by default is on from the start with a paid plan or a live trial; First run says how the mode picker reads with it on and off.

A cloud task does not run on your Mac. Each task gets its own container on Cloudflare, a standard-3 with 2 vCPU, 8 GiB of memory and 16 GB of disk. Its agent runs on mux beside that container, in a Durable Object of its own. How the sandbox is held in explains each wall.

The container carries Node 24 with npm, pnpm, Yarn and Bun; Rust with clippy and rustfmt; Go; Python 3 with uv and pytest; a JDK with Maven and Gradle; PHP with Composer; and git, git-lfs, ripgrep, fd and jq. Nothing installs a package manager that is not on that list. muxcode’s checks pick their runner from the lockfile: pnpm, Yarn or Bun when theirs is present, npm otherwise. A project that declares another package manager can only be installed without its lockfile, which can resolve other versions than the ones you pinned, so its checks can fail on files the task never touched. For such a project, commit a lockfile one of those four reads, or run the task on your Mac.

your Mac muxcodeattaches to the task sign-ins stay here
mux, on Cloudflare: one task
agentin a Durable Object container2 vCPU · 8 GiB · 16 GB disk gatewayreads only
credentials from your Mac permission cards your MCP servers commands on your Mac
out through the gateway package registries GitHub, to read upload, publish, push
The loan reaches the agent, never the container. What the container lacks is what keeps the task without permission cards.
  • Your sign-ins stay on your Mac. Your Mac attaches to the task and lends it a short-lived access token or API key for your model provider, never a refresh token. The agent’s model requests leave from mux; the container holds no credential from your Mac: no provider keys, no gh or wrangler sign-in.
  • It keeps going without you, for a while. A chat turn goes on while the lent sign-in lasts, then waits for your Mac to attach again. A workflow run moves only while your Mac is attached.
  • No cards. Commands and edits inside it do not show permission cards. From muxcode 1.0.6, Clef does not read its commands, and none is refused on its reading. The sandbox’s network allows reads only: it refuses an upload, a publish or a push the agent runs.
  • No reach into your Mac. The container reaches package registries and GitHub for reads only. It cannot run commands on your Mac, and your MCP servers are not offered to it. Push or open a pull request with the commit menu, or use a task on your Mac.
  • Pictures up to a size. The agent can look at a PNG, JPEG, GIF or WebP file in the task of up to 700 KiB and 2,000 pixels a side. A larger one is not sent to the model; the agent can make a smaller copy in the sandbox, or ask you what it shows. Images you attach to a prompt may come to 700 KiB in all. From muxcode 1.0.7, muxcode makes them smaller to fit, at most 2,000 pixels a side; one that still does not fit goes into the task as a file. An older muxcode sends larger ones, and the task refuses a prompt with more; attach a smaller copy, such as a crop or a JPEG.
  • Private to you. A cloud task belongs to the member who started it. Other members see that it exists, not its conversation, files or commands. Share what they need through workspace memory.
  • On the web. The Sessions page on usemux.com lists your cloud tasks. Open one to read its thread. There you can send plain prompts while your Mac’s sign-in is lent, and stop the agent’s current turn; workflows, approvals and questions stay in muxcode.

Starting, stopping and keeping files:

  • A task starts from your checkout as it stands, uncommitted edits included. A clean checkout starts from your last commit. Files whose names look like credentials are left out.
  • Start from a clean checkout when you want a small, reviewable change. Files present before the task starts can otherwise become part of its snapshot.
  • From muxcode 1.0.21, a task starts before your project reaches the sandbox, and the first command it runs waits for the project. On mux on 2 November 2026, a fresh task reached its first turn in a median 3.7 s on a small repository and 4.1 s on a 1,684-file one. Sandbox hours begin only when the project arrives.
  • If a start is slow, muxcode waits up to five minutes, says so after 45 seconds, and joins a start that is still running rather than stopping it. If the start runs out of time, muxcode says so, and the task stays in the sidebar: send again to use it.
  • A stop sent while a task first starts ends that start, and nothing is left running.
  • Stop sandbox · retain files stops it and keeps the files; your next message starts it again with the files intact.
  • While the app is open, muxcode closes its link to a task idle for 10 minutes. That stops nothing: the agent’s run goes on. Change it in Settings → Sandbox → On this Mac → Close idle sandbox links after; 0 turns this timer off. mux stops any task 10 minutes after its last work, whether muxcode is open or not, or 20 when a process you started is still running; the agent’s work then waits for the next start.
  • A stop saves the work in progress to the task’s own copy of the repository and keeps a snapshot of the container. While a task runs, mux also saves its work in progress every five minutes. mux deletes a task 14 days after it stopped. The Discard stopped sandbox files after and Discard finished sandbox files after settings can act sooner: muxcode asks mux to delete the task and moves the copy on your Mac to Trash. Its conversation stays.
  • Tools may call the tree /workspace, as the sandbox does. It is the same set of files.
minutes since the task last did work
muxcodewhile the app is open

10 min by default, 0 for off: closes its link, stops nothing

muxalways

10 min: the agent's work waits for the next start

every stop, in order
save the work in progressto the task's own repository snapshot the containerits disk remove the containerthe files stay

while it runs: work in progress saved every 5 min deleted 14 days after it stopped

The files survive every stop. A stopped task is deleted 14 days later.

⌘ is Cmd on a Mac; muxcode also accepts Ctrl.

Keys Does
⌘N new task
⌘K the command palette: sessions, projects, files, commands and settings
⌘⇧F search every chat
⌘I Cowork
⌘E open or close the right pane
⌘J the task’s terminal
⌘2 Changes
⌘R refresh what the pane shows
⌘⇧[ / ⌘⇧] step through the pane’s tabs
⌘B sidebar
⌘, settings

Sessions sit in a folder for each repository. Drag a folder’s heading above or below another, or use Move up and Move down in its ⋮ or right-click menu. muxcode keeps the order across launches, ⌘⇧↑ and ⌘⇧↓ step through sessions in that order, and each workspace keeps its own. Pin, on a session’s hover buttons or in its right-click menu, moves it to the Pinned group. Search, Cowork and Pull requests sit under New Chat, a row each.

When a conversation fills up, muxcode does not summarise it. It opens a fresh context window: the system prompt, the tools, a short handoff, then new messages. Nothing is thrown away. The whole conversation stays on your Mac, and the agent reads back what it needs with its notes and history tools. Fresh windows work on every plan, Hobby included, with or without a mux sign-in.

The line sits at the window less pi’s reserve of 16,384 tokens: 983,617 on a 1,000,000-token window. The handoff holds at most 20,000 characters. No compaction explains why.

what the model sees
window 1, full
messages
line: window − 16,384 983,617 of 1,000,000
handoffup to 20,000 characters no summary call
window 2, fresh
prompt, tools handoff new messages sketch, not to scale
what the agent reads back with tools
task notesnotes · outlive every window workspace and private memoryworkspace_memory · across sessions the whole conversationhistory · branch, task, project
The model sees one window. Notes, memory and the whole conversation stay one tool call away.

So write down what matters as you go, and expect the agent to look things up rather than remember them.

Ask for a note before a long step, for example “write a task note with the plan and what you’ve ruled out”. A note outlives every window, and the handoff lists the task’s notes so the next window finds them.

  • Task notes belong to the task, and writing one needs no approval.
  • Workspace memory carries lessons across sessions and projects in the same workspace. See Remember across sessions.
  • A note is replaced only against its current revision, so two writers cannot silently overwrite each other. Older revisions stay readable: every one on your Mac, the newest 5 on a cloud task.

Each workspace has one shared memory repo, and each member has a private one. Both are private Git repos kept by mux, not GitHub repositories. Each starts at MEMORY.md, which links to topic files with [[path]]. muxcode uses memory from version 1.0.5. How Memory works has the limits, the waits and every answer a save can get.

  • How the agent uses it. In a workspace signed in to mux, the agent reads both MEMORY.md files at the start of a task. It searches memory and saves lessons with the workspace_memory tool. Saves go to your private memory unless the agent names the shared one. Each save is a Git commit, checked against the revision the agent read, so two sessions cannot silently overwrite each other. Old versions stay in the Git history.
  • Who saves. Saving needs no card. Plan mode only reads. In a workflow, only the worker seat saves; the other seats read. A read-only subagent reads only. From 1.0.22, a session Auto-fix prompted with a pull request’s checks and comments saves nothing, and both MEMORY.md files are screened as outside text before the agent reads them.
  • What it is. Memory is agent-written context, separate from findings an owner approved. get_context includes relevant memory beside code evidence, marked with its scope and revision. Saved text never grants permission.
  • Plans. Memory needs your own plan to be Pro, Pro+ or the trial, and a workspace signed in to mux. Hobby has none, in a team too: every memory call answers 403 plan_refused. Reads, saves and searches count against your plan’s search and memory hours, 50 a month on Pro and the trial, 300 on Pro+, across your workspaces and teams.
  • Cloud tasks use the same memory directly on mux, without your Mac. Their private memory is that of the member who started them. A new cloud task reads both MEMORY.md files while it starts, so they are ready for its first turn.

Your old project notes are copied into your private memory, under legacy/, with their content and revision references. The copy runs in the background once memory has loaded at a task’s start, a few notes at a time, except in plan mode. A note too large for memory stays on your Mac, and the originals are never changed. Once the workspace is signed in, project-scope notes are refused, and the agent uses workspace_memory instead.

Without a mux sign-in, workspace_memory reads your old project notes on this Mac and saves nothing. Shared memory needs mux. Project-scope notes still save on your Mac, after you allow each one.

No switch turns memory off. To keep it on your Mac, do not sign the workspace in to mux, or choose Sign out. Plan mode reads memory but never saves to it. Memory also works when fresh windows are off. muxcode saves lessons as you work; it does not schedule background passes over memory.

history searches the stored conversation for a phrase and reads an entry back by id. It has three scopes:

  • branch: this line of the conversation.
  • task: everything in the task, including edited-away branches and the work of subagents and workflow seats.
  • project: up to 200 earlier sessions in the project.

A stopped subagent’s card says where its work went, for example “Use history search with scope task”. Ask the agent to do just that.

Between phases, ask the agent to start a fresh window: “finish this step, note the result, then start a new context”. The agent writes its own handoff, up to 20,000 characters. The new window starts only if every tool call in that step succeeded.

A new window is not an undo. Changed files and commands you ran stay changed: it clears the conversation, not the tree.

Workbench → Summary → Context & memory shows how full the window is, part by part, and whether that figure comes from the provider or is an estimate. For a cloud task it shows the provider’s total as one row. How Context works has every line and what the handoff keeps.

Settings → Models → Context windows. Fresh context windows is on by default. Turning it off restores pi’s summary compaction for new tasks; restart the app to change tasks that are already open. Saved notes and window history stay readable. Keep fresh windows on unless a model misbehaves after a rollover: with summaries, a long task loses detail at each one, and nothing brings it back.

Window cap, in the same card, starts a fresh window earlier on models with a large window, such as Opus 5.5 at 1,000,000 tokens. Choose Off, 256K, 400K or 600K. It applies to new tasks while fresh windows are on.

With Clef, the last stretch of a window does more: it times the checkpoint reminder for a clean stopping point, hides old tool results the task no longer needs from the model’s view, and carries up to six findings into the handoff. A hidden result stays whole in history. Without Clef, the window still rolls over the same way, and no tool result is hidden early; only the newest two images stay in view, as they do with Clef.

A task sees two things:

  • The live tree is the checkout it works in, including your uncommitted changes. The agent reads it with read, grep and find.
  • Your workspace’s code index holds every repository the workspace indexes, as of each one’s last indexed commit. The agent reads it with the workspace_corpus tool.

muxcode ships a workspace-index skill that teaches the agent this order:

  1. Call get_context for the task.
  2. Read the freshness of each repository.
  3. Search, grep or trace.
  4. Open the files.
  5. Record what was checked.

Mention the index in a prompt, for example “check how the other services consume this event”, and the agent follows it.

get_context answers a task, not a query. One call returns the evidence from across the workspace:

  • passages bound to the commit they were read at;
  • the files two hops out on the code graph: imports, tests, and the routes one repository calls in another;
  • any finding an owner has approved;
  • relevant notes from workspace memory and your private memory.

When the checkout is an indexed repository, muxcode adds the files your branch changed.

Read the freshness before the evidence. A repository that is behind was read at an older commit, and the agent should say so beside anything it takes from there. Pro, Pro+ and the trial refresh on every push. Hobby has no code search and refuses every code tool; that is the plan, not a fault.

Ask one question per search. A broad query answers none of them well.

Tool Use it for Note
search_code concepts, flows, similar code by meaning; Pro, Pro+ and the trial
grep_code structure, such as every call shaped like foo(…) \NAME stands for one node
ask_code a conceptual question returns passages, not a written answer
trace_code one file’s graph needs both repository and path
list_repositories names for the repository filter owner/name

record_context_outcome proposes a finding for the workspace to keep. It takes a one- or two-sentence statement, the packet’s receiptId, the repository and revision, and the paths it rests on.

Always name paths, and only the files the statement depends on. A push carries the finding forward while those files are unchanged, and a change to any of them marks it outdated. Without paths, a finding depends on every file the packet read, so almost any push outdates it. A proposal is not trusted until an owner approves it; only then does get_context hand it out.

Every hit is a pointer. Open the file, read the tests beside it, and cite path:line from what you actually read. Your uncommitted edits exist only in the live tree; the index has never seen them. And “no results” does not mean “no integration”: dotfiles, .github/, generated files and unsupported formats may be missing from the index, so check them directly.

Claude Code, Codex and GitHub Copilot CLI can read the same index, with the same tools, over MCP. The MCP guide has the key, the endpoint and each client’s setup. muxcode needs none of this: it signs itself in, and you never paste a key into it.

Settings → Integrations → MCP servers adds MCP servers to the tasks that run on your Mac. Settings has two Integrations tabs: this one is in the Personal scope, where Settings opens, beside Models and Sandbox; the Workspace scope’s holds the workspace’s accounts. A server either runs on this Mac, as a command with arguments and environment, or is remote, at an https:// URL with headers. A remote server saved with no Authorization header signs in with OAuth: run /mcp login <name> in a task on your Mac. The form’s OAuth client fields are only for a client you registered with that server. muxcode keeps them in ~/.muxcode/mcp.json and never shows a stored key.

  • A server on this Mac starts only after you allow it. muxcode asks once each time the task’s agent starts, so a task you come back to after it sat idle, or after muxcode restarts, asks again. The card offers Allow once or Deny, and Bypass permissions does not skip it.
  • Each tool call asks on its own card, in every mode but Plan, unless a rule you saved already allows that tool.
  • Plan mode starts no MCP servers. From muxcode 1.0.5, a cloud task gets none of them, and its transcript says so once.
  • Each server has its own switch. Turn it off to keep it saved but unused, or press Remove.

MCP servers need no plan and no mux sign-in.

A skill is a folder with a SKILL.md file in ~/.agents/skills, the one folder muxcode shares with other agents on your Mac. The skill’s description says when it applies. The agent loads the body when a task matches, or when you name it with /skill:<name>.

The Agents page lists skills under the workflows: muxcode’s own first, then yours, grouped by any prefix that three or more share.

Kind Examples
Yours team conventions, deploy steps, review checklists
Workflows muxcode-<name>, written when you save a workflow
Shipped workspace-index

Write a good one.

  • Make the description specific: name the situations, files and words that should call it up. A vague description never gets chosen.
  • In the body, put what the agent cannot work out from the code: the order of steps, the checks that prove a change, the traps you have already hit.
  • Keep secrets out of shared skills. Every agent on your Mac reads the same folder.

Workflow skills are generated. Edit a workflow’s roster on the Agents page, not its files; the next save or launch rewrites them. A roster you edited keeps every seat you set, including ones the page has no row for.

For a local task, edits already affect its checkout or worktree. For a cloud task, Refresh changes fetches what the task has done, and Cloud changes shows it for review. Refresh changes needs the sandbox running: on a stopped task, choose Start sandbox in the Sandbox menu first. Apply changes stages it on your branch, or a commit action brings it into your local repository. The commit menu, in the row above the composer, has eight actions. The last, Create PR, opens a pull request from commits you already made.

cloud taskits own copy of the repository Refresh changes fetches the work
Cloud changesreview the file list and diff Apply changes stages it on your branch
the commit menu, your own Git stays on your Mac
  • Commit
  • Create Branch
  • Create Branch & Commit
also reaches your remote
  • Commit & Push
  • Push
  • Create Branch, Commit & Push
  • Commit & Create PR
  • Create PR

a cloud task never pushes to your remote a local task's edits are already in its checkout

Local tasks, cloud tasks and Cowork tasks all use the same menu. Pushes use your own Git on your Mac.

From a cloud task:

  • An action that creates a branch cuts it at your checkout’s current commit, not at the commit the task started from, and applies the task’s reviewed changes there. Commits you made in the meantime stay in the branch’s history; only the changes are the task’s.
  • Commit & Create PR asks for the branch name, then pushes and opens the pull request. The first line of the message becomes the title.
  • An action that squashes the work refuses to run while your checkout has uncommitted changes of its own, rather than burying them.

Review the file list and diff before committing, then inspect the resulting local commit before choosing Push. If a change count disagrees with the diff, stop and report the mismatch; do not treat the count alone as the commit’s scope. Commit does not push.

Hand an issue to Cowork. Press ⌘I, pick the project, and paste an issue of the project’s own repository, as a URL, owner/repo#123 or #123. Or describe a bug or a feature, and Cowork writes up the issue with you first. The task works in the cloud, with no Mac after you press Start, and ends in a draft pull request that the mux GitHub App opens for you; nothing merges on its own. A run that spends its allowance of tokens or active time pauses with its work kept until you press Resume. A change Cowork will not push, such as one to CI files, lands through the task’s commit menu. The Cowork and Pull requests pages share the same project choice. Cowork has the whole guide, and From a GitHub issue to a draft pull request, in one live Cowork run follows one live run step by step.

muxcode runs pi, its agent, on your Mac with your own model sign-ins. mux adds shared services on top: the code index, memory, the cloud sandbox, Clef and Cowork. Hobby is free, and in your own workspace it keeps every task on your Mac. In a team workspace, Sandbox by default shows on for a Hobby member too: switch it off there, or mux refuses each task’s sandbox. Each paid part has its own switch, so any plan can run the same way.

Part What it needs Without a mux sign-in Turn it off
Fresh context windows nothing; every plan full; works offline Settings → Models → Context windows → Fresh context windows
Workflows your own model sign-ins; the shipped root is mux’s included model full with a root of your own, without Clef’s readings the workflow’s switch on Settings → Agents
Clef Pro, Pro+ or the trial; or your own Cloudflare API token and Account ID, on any plan only with your own token Settings → Classifier → Read along; leave Stand-in model empty
Cloud sandbox Pro, Pro+ or the trial not offered; tasks run on your Mac Settings → Models → Cloud sandbox → Sandbox by default
Workspace memory muxcode 1.0.5, a mux sign-in, and Pro, Pro+ or the trial reads old project notes, saves nothing no switch: sign out, or use Plan mode to read only
Code index a mux sign-in, and Pro, Pro+ or the trial; Hobby indexes nothing Local CocoIndex in the workspace settings sign out, or choose Local CocoIndex
Your MCP servers nothing full, for tasks on your Mac each server’s switch on Settings → Integrations
Cowork Pro or Pro+, your own plan in a team workspace not available nothing runs until you start a task or make a coworker
stop what this Mac sends to mux

Sandbox by default Settings → Models → Cloud sandbox

Read along Settings → Classifier; leave Stand-in model empty

Sign out Memory and the hosted index Sign out, in the workspace Overview; or Local CocoIndex for the index alone

optional: muxcode's own extras, no mux involved

The workflow its switch on the Agents page

Each MCP server Settings → Personal → Integrations → MCP servers

Fresh context windows Settings → Models → Context windows; restart for open tasks

still on: the permission gate your model providers pi, on your Mac

The first three stop everything this Mac sends to mux. The last three are optional; they need no mux.

To run plain pi on your Mac with nothing from mux:

  1. Do not sign the workspace in to mux, or choose Sign out in the workspace’s Overview. The account line then reads Only on this Mac. Sign out removes only this Mac’s key; other Macs keep theirs.
  2. On a paid plan, turn off Sandbox by default.
  3. Turn off Read along, and leave Stand-in model empty, so no model answers Clef’s questions.
  4. Switch the workflow off on the Agents page, or chat on a model that is not its root.
  5. To use pi’s own summary compaction, turn off Fresh context windows.

The permission gate, your model providers and your MCP servers still run: they are muxcode, not mux.