A coding agent on your Mac with a cloud behind it.

Fluxcode is the desktop app. It keeps the worktree, the session and every permission decision. Behind it, mux keeps the rest: fresh context windows, a sandbox to run a task in, models through one sign-in, and one code index per workspace.

  1. The harnessFluxcode runs the agent
  2. The contextA fresh window, not a summary
  3. The sandboxOne container per task
  4. The workspaceModels and one index
A task starts in the desktop app, keeps its context across windows, can run in a cloud sandbox, and searches the workspace index.

How it works

Five parts, one agent

The app on your Mac is the control plane. The pi coding agent is the model plane, one child process per session. Everything below is where the line between them falls.

  1. 1

    Fluxcode runs the agent

    A native app that starts one agent process per session and owns the worktree, the session file, the sign-in and the model catalog. Every permission is decided in the app, not by the model: a mode says what runs without asking, a card asks about the rest, and a grant can last a session or be written down for the project.

  2. 2

    A full window becomes a fresh one

    When the conversation fills up, the task keeps going in a new window instead of being summarised away. History is append-only: the agent saves notes, hands off what matters, and searches the saved transcript to read the original evidence again. Editing an earlier prompt keeps the old branch. It is on by default, and turning it off restores summary compaction.

  3. 3

    Or it runs in a sandbox

    A task can run in the cloud instead of on your machine: one container per task on Cloudflare, with the repository moved over git and nothing running locally. The agent still runs on your Mac and reaches the sandbox over HTTPS. When the work is done, a commit menu lands it. Included with paid plans.

Models through one sign-in

AI Gateway

Sign in once and the app’s model picker lists the models your workspace can reach. Every call is served through the gateway with the workspace key, and the spend is metered against the workspace that made it. Pro and Team.

One index per workspace

grep_code · search_code · ask_code

Connect GitHub, choose the repositories to index, and search them from the web, from the app, and from any agent over MCP. Pattern search is on every plan; search by meaning and plain-language questions come with Pro and Team, which also re-index on push. Every match names the repository, the file, the lines and the commit it was read at.

The usual arrangement: the agent reads your codebase again on every machine, loses the work to a summary when the window fills, and runs wherever you happen to be sitting.

With mux: one index per workspace, a fresh window with the old one still readable, and a sandbox to run the task in.

The app, the permission gate and fresh context windows are on every plan. The sandbox, hosted models and search by meaning come with Pro and Team.

See what shipped

QUESTIONS

The parts, without the mystery.

What is Fluxcode?

A desktop app for macOS that runs the pi coding agent as its worker, one process per session. Fluxcode makes the worktree, keeps the session and the event log, answers every dialog and decides every permission; pi runs the model loop and the tools. The agent ships inside the app, so there is nothing to install beside it.

Who decides what the agent may run?

The app does, in its own process rather than in the model’s. The permission mode says what runs without asking: plan reads only, auto runs read-only commands and edits inside the project, manual asks about everything. Anything else draws a card you answer, and a grant lasts the session or is written down for that project. A subagent’s calls go through the same gate.

How does orchestration work?

A run is handed to seats on a roster you write, and a classifier reads the ticket and scores it so the run starts on the right rung: a replan moves up, a retry never returns to the seat that failed, and an unclear ticket stays on the roster’s own seat. The classifier reads and answers questions. It is never a seat, and it never widens a permission.

What happens when the context window fills?

The task continues in a fresh window. The agent can ask for one, or reach it by running out of room, and the boundary is only committed once the tool batch that requested it has succeeded. Nothing is deleted: the saved transcript stays searchable, notes carry the decisions forward, and the workspace, files and permissions survive the rollover.

Where does a sandboxed task run?

On Cloudflare, one container per task, reached over HTTPS with your workspace key. Nothing runs in a virtual machine on your laptop. The repository moves over git, the agent stays on your Mac, and the change comes back through a commit menu. The sandbox is included with paid plans.

What is a mux workspace?

A workspace is your code index and what reaches it: the repositories you chose, the mirrors kept of them, the chunks searched, the people and Macs you granted access, and the keys your agents use. Hobby is one personal workspace; Team is Pro with members. Deselecting a repository removes its mirror and its part of the index, and deleting a workspace destroys its data after 30 days.

GET STARTED

Give the agent somewhere to work.

Create a workspace, connect GitHub, and index one repository—then run the agent against it from your Mac, and from the cloud when the task is better off there.

Free for your first repository · No credit card · Disconnect anytime