All posts

Cowork on the web: start from a shelf, see what was done, preview an app

Cowork in mux on the web now starts from a shelf of ready-made coworkers, opens with what your coworkers finished by themselves, and lets a coworker keep files and build an app that only you can preview. Here is what each part does, what mux's code decides rather than a model, and where the limits are.

At a glance

  • In mux on the web, Cowork starts from five ready-made coworkers. A Guide answers questions from your code, a Watcher tells you when a web page changes, and a Builder builds a web page or a small app. Each is an ordinary coworker with its rules set for its job.
  • Home and Cowork's overview open with what your coworkers finished by themselves in the last 7 days. A thing counts only when something other than you started the work, and like things share one row.
  • A coworker keeps text files from one turn to the next and can build an app from them. mux's code checks the app, and only the coworker's maker previews it, in a sandboxed frame that loads nothing from outside.

Cowork is in muxcode on your Mac and in mux on the web. As of 17 November 2026 it does three new things on the web. It starts from a shelf of ready-made coworkers. It opens with what your coworkers finished while you were away. And a coworker can keep files and build an app from them, which you preview in private.

A coworker is a standing teammate on mux, with a name, a job, a model and rules for what it may do. It works on mux, so it keeps working with your laptop closed.

Cowork starts from a shelf

An owner or admin who opens Cowork with no coworker yet sees five ready-made ones, and New coworker opens the same shelf. Each row says what the coworker does and what it needs. When something is missing, such as a repository in the Code Index, the row’s button leads to the fix.

  • Reviewer reviews each pull request that touches the paths you name, with the callers of the change in view. Reviewer reads the code your diff breaks explains how.
  • Guide answers questions about how your product works, from up to 20 repositories you tick in the Code Index. Only its maker can ask it for now.
  • Watcher tells you when a web page changes: a price list, a status page, a changelog. You give it the address and when to look: every hour, every day or one weekday, at an hour in your own time zone.
  • Builder builds a web page or a small app from what you tell it: a portfolio, a product page, a form. It needs no repository, and each app it builds opens from its Apps tab.
  • Write your own takes a name and a job in your own words, on one repository.

A ready-made coworker is a recipe, not a new kind of coworker. mux makes an ordinary coworker, gives it mux’s included model where your plan offers it, and sets its rules. For a Watcher it then adds the routine that watches the page and runs it once, so the first reading shows at once. If a step fails, mux removes what it made and says why.

Rule Guide Watcher
Edit files allow, its own notes block
Run commands block block
Read the web block block
Drive its browser block block
Use connected apps block block
Message coworkers block block
Schedule routines block block
Start tasks block block
Reads with no rule the Code Index the workspace's notes its one page, read by mux's code
Each recipe blocks what its job does not need. A Guide writes only its own notes. A Watcher can do nothing at all: mux’s code reads the page and hands it the text.

The rules carry the design. A Guide’s web rule stays blocked because a run that has read text from outside, such as a web page, can no longer search the Code Index. A Watcher needs no tool: on each scheduled look, mux’s code reads the first 64 KB of the page and wakes the Watcher only when the page’s text changed. A change in the markup that leaves the text as it was wakes nobody. A Builder has a Guide’s rules: it may write its own files and nothing else. Its web rule stays blocked, so no web page’s text enters what it builds.

What was done while you were away

Home and Cowork’s overview now open with a short list of what your coworkers finished by themselves. On Home it sits under the search once a repository can be searched. On the overview it comes before what needs you, your coworkers, each with a robot in its own colour, and your five newest tasks.

A thing counts only when something other than you started the work. Like things share one row: the same coworker doing the same kind of thing, such as “3 reviews” or “Daily report ran 2 times”.

counts: it did this by itself
  • a routine ran Routine · Watch acme.example
  • a check-in Check-in
  • a webhook Webhook
  • an email Email, sender not shown
  • another coworker Message from Release Bot
  • a review ended Review
  • a task finished Task
does not count
  • its answer to you
  • a review that waits
  • a task that starts
  • a notice
the last 7 days after your last Clear all like things as one row newest first 5 rows at most
Only ends count. A review counts when it is drafted, posted or fails, and a task when it finishes, never while either is under way.

A row of one thing opens to the whole reply. A row of several opens on the list of them, newest first, and each opens on what the coworker said. An email’s sender is never shown, since it is text from outside. Clear all keeps the time you pressed it in a cookie in this browser, for you and this workspace. Neither page waits for the list: each draws a placeholder and asks for the list once it is on screen.

A coworker keeps files and builds apps from them

A coworker now keeps text files of its own: a page, a note, a list. They last from one turn to the next, no other coworker reads them, and they go when the coworker goes. It keeps up to 500 files, 1 MB each and 50 MB in all, and a write past a bound is refused and changes nothing. Its Files tab lists each file’s path, size and when it changed, never the text.

A folder apps/<name>/ of those files with an index.html in it is an app: a portfolio, a product page, a form. The Builder is made for this: tell it what to build, and its Apps tab lists each app with its check. Preview opens one.

  1. Its files apps/product-page/
    index.html specs.html site.css

    200 files and 8 MB at most

  2. The check mux's code, not a model
    its own files onlyno form posts outno password fieldno frames or refreshno javascript:links to pages it has

    Each problem names its file and the fix.

  3. One page, one document styles and scripts written in

    What breaks a rule is left out and listed. A link to another page of the app does not open in the frame; you pick the page above it.

  4. A sandboxed frame only the coworker's maker
    loads nothing elseno networkno form postan origin of its own scripts off once outside text changed a file
The check explains; the frame enforces. mux’s code checks the app before you see it, and the preview’s own policy holds the page in place whatever the check missed.

The check is mux’s code, not a model. It reads every page each way a browser could, with and without scripts, and where it is unsure it reports a problem. Each problem names its file and says what to do, and the coworker can run the same check while it works.

The check is the explanation, not the guarantee. The guarantee is the preview’s own policy. The page runs in a sandboxed frame with an origin of its own, so it never sees your mux session. It may use styles and scripts only from inside the page and pictures and fonts only as data: addresses. It cannot fetch anything, post a form or open a frame.

Text from outside gets one more rule. A file written in a run that read text from outside, such as a web page, an email or a webhook, is marked. Once any file of an app carries that mark, the preview drops every script and event handler, and the screen says why.

The working where each number comes from

Every fact is read from the helios repository on main at abf34410, 17 November 2026, unless noted. The Builder and the grouped rows are read on main at c4db0781, the same day.

  • The shelf, its five rows, what each needs, and New coworker: Shelf in apps/app/src/web/pages/cowork-shelf.tsx, and CoworkHomePage in cowork-home.tsx, which draws it for an owner or admin with no coworker.
  • The Builder, its words and rules, no repository, its Apps tab: BUILDER_SAYS, BUILDER_MAY, BUILDER_RULES and BUILDER_JOB in apps/app/src/lib/cowork-recipes.ts, CreateBuilder in cowork-shelf.tsx, and the /cowork/coworkers/builder route in apps/app/src/routes/cowork.tsx (c4db0781).
  • Like things as one row, “3 reviews”, “ran 2 times”, the newest 50: awayGroups, groupTitle and AWAY_KEPT in apps/app/src/lib/cowork-away.ts, and AwayItem in home-away.tsx (c4db0781).
  • Guide and Watcher rules, their words, the two pickers and the time zone: GUIDE_RULES, WATCHER_RULES, EVERY, cronOf and zoneLabel in apps/app/src/lib/cowork-recipes.ts. Up to 20 repositories: GUIDE_REPOS_MAX in apps/app/src/routes/cowork.tsx.
  • The recipe’s steps, the included model, the first run and the take-back: makeFromRecipe in apps/app/src/routes/cowork.tsx; the rule on the web rule and the Code Index: docs/markdown/project.md, “Cowork’s ready-made coworkers”.
  • 64 KB, and a Watcher woken only when the text changed: apps/sandbox/PROTOCOL.md, “Turns and wakes”.
  • What counts as done while you were away, 7 days, 5 rows, newest first, the cookie: doneOf, awayRows, AWAY_WINDOW_MS, AWAY_SHOWN and seenAtOf in apps/app/src/lib/cowork-away.ts; the rows, the hidden email sender and the placeholder in apps/app/src/web/pages/home-away.tsx; Home’s searchable rule in home-overview.tsx.
  • 500 files, 1 MB each, 50 MB in all; refused writes; marked files: apps/sandbox/PROTOCOL.md, “Files”.
  • An app’s folder, 200 files and 8 MB, the check’s rules and readings, scripts off after outside text, the one document: apps/sandbox/PROTOCOL.md, “Apps”, and checkApp in apps/sandbox/src/coworker/apps.ts.
  • The frame’s policy, its own origin, maker only, links between pages: previewPolicy, framedHere and OPEN_FROM_APPS in apps/app/src/lib/app-preview.ts, and AppPreviewPage in apps/app/src/web/pages/coworker-apps.tsx.