From a GitHub issue to a draft pull request, in one live Cowork run
We pressed Start on a real bug report. mux wrote a failing test, fixed the bug, checked both and opened a draft pull request 91 minutes later. Here is every step, how long it took, the five mistakes the run showed us in Cowork, and how each is now fixed.
At a glance
- On 31 October 2026 we started Cowork on a real bug report, on a pre-release build of muxcode against mux's release of 31 October. mux opened the draft pull request 91 min 27 s later. Apart from one Resume, no Mac took part after Start.
- The run proved the bug first. Its new test failed on the untouched code, "expected 4 to be 3", and passed on the fix.
- Eight model turns took 42.4 minutes, and four gates, which run checks and no model, took 41.1. The run paused once for 6 min 18 s at its 60-minute allowance.
- The run showed five mistakes in Cowork itself. Every fix went live on 2 November 2026, in muxcode 1.0.21 and on mux, and the run allowance now grows with the repository.
- A second live run on 2 November took a feature request to a draft pull request in 3 min 49 s, with no pause, and its description named the commit it started from.
On 31 October 2026 at 23:55:22 UTC, we started Cowork on a real bug report in mux’s own web app repository. At 01:26:49 UTC on 1 November, the mux GitHub App opened draft pull request #269. It held a test that failed on the old code, the fix that made it pass, and a record of every check. Apart from one Resume, sent by our QA script at 01:04:21 UTC, no Mac took part after Start. The run took 91 min 27 s, and 6 min 18 s of that was a pause waiting for that Resume.
We ran it on a pre-release build of muxcode, against mux’s release of 31 October, whose workflow still had the mistakes below. Since muxcode 1.0.21 shipped on 2 November 2026, Cowork needs no Mac after Start, and the pull request comes from the mux GitHub App, not from gh on your Mac.
The run also showed five mistakes in Cowork itself, one near miss that mux had already fixed, and one fault in the repository’s own typecheck. Every one of those fixes is now live. This post walks through the run step by step, with its times, its checks and what it got wrong, then a second run from 2 November that shows two of the fixes at work.
What Cowork does
Cowork is a page in muxcode. You pick a GitHub issue from your project’s repository, mark it a bug or a feature request, and press Start. Since muxcode 1.0.21, mux works the issue to a draft pull request with no Mac at all after Start: you can close the lid or quit muxcode. You can also describe a change on the page instead. Cowork files it as an issue with gh issue create and starts on it the same way.
Every run proves the issue before it changes the code. Its first step writes a test that fails on the untouched code, for the reason the issue reports. Then a fix makes that test pass.
Every run has a planner, a worker and a judge. Each of these roles is a seat: one model turn with one job. Every seat runs on DeepSeek V4.1 Flash, the model mux includes with Pro and Pro+, at max reasoning, and the judge does too. A judge on the writers’ own model is safe here because a failing test and the gate decide, not the judge alone. The gate is muxcode’s own code. It runs the checks and compares their exit codes with the untouched tree’s.
What your Mac does, and what mux does
Your Mac asks once, then only follows.
- The Mac sends one request. It carries the repository, the issue number, the kind, the project, the skills you picked, the checks, and your git name and email when git holds both. The Mac fetches nothing and copies nothing.
- mux claims the issue and answers at once. If another task already works the issue, mux refuses and can name that task and its pull request.
- mux boots a container, fetches the tip of the default branch and installs the dependencies. The workflow runs inside the task’s own server on mux, which drives each step.
- mux opens the draft pull request as the mux GitHub App when the run completes. The commits carry your name.
- Your Mac only watches. Opening the task shows a read-only session: you cannot type in it, and a dropped link or a closed Mac leaves the task running. The Mac can wake a paused task in two ways: Resume, and Open PR or Check again.
The issue
Issue #267, opened on 30 October 2026 and labelled bug, reads “Tab from the email on the sign-in form lands on Forgot password, not the password field”. Type an email on the sign-in page and press Tab, and focus lands on “Forgot password?” instead of the password field. The report also asks that the link stay reachable by keyboard and keep its look and place, at the end of the password label’s row.
The run started from main at 56f794d, the commit of mux’s release of 31 October 2026. The Mac’s one local change, an untracked notes file, stayed on the Mac.
A task from an attempt on 30 October still held the issue. Before Start, our QA script used a reader’s Stop to cancel that older task. The cancel took 19 s.
The run, step by step
Each seat ran DeepSeek V4.1 Flash at max. The gates run no model. Route 1 wrote the failing test, and route 2 was the fix. A route is one contract worked to a pass, and a contract names the files a step may change and the command that proves it.
| Step | Route | What ran | Time (UTC) | How long | Outcome |
|---|---|---|---|---|---|
| Start | Boot, fetch, install | 23:55:22–23:56:46 | 84.2 s | ||
| 1 | 1 | Plan | 23:56:46–00:01:53 | 5.1 min | completed |
| 2 | 1 | Critic | 00:01:53–00:06:42 | 4.8 min | completed |
| 3 | 1 | Worker writes the failing test | 00:06:42–00:14:34 | 7.9 min | completed |
| 4 | 1 | Gate | 00:14:34–00:27:44 | 13.2 min | failed, wrongly (see below) |
| 5 | 1 | Worker, retry | 00:27:44–00:38:24 | 10.7 min | completed |
| 6 | 1 | Gate | 00:38:24–00:51:54 | 13.5 min | passed |
| 7 | 1 | Judge | 00:51:54–00:55:53 | 4.0 min | completed |
| 8 | 2 | Worker writes the fix | 00:55:53–00:58:03 | 2.2 min | completed, then paused |
| Pause | Waiting for Resume | 00:58:03–01:04:21 | 6 min 18 s | resumed | |
| 9 | 2 | Gate | 01:04:21–01:11:29 | 7.1 min | passed |
| 10 | 2 | Judge | 01:11:29–01:15:35 | 4.1 min | accept |
| 11 | both | Gate over the whole change | 01:15:35–01:22:52 | 7.3 min | passed |
| 12 | both | Judge over the whole change | 01:22:52–01:26:36 | 3.7 min | accept |
| PR | Opening the pull request | 01:26:36–01:26:49 | 14.3 s | draft opened |
From Start to the draft took 91 min 27 s. The run itself took 89.8 min from creation to completion, and 83.5 min without the pause. The eight model seats took 42.4 min in all, and the four gates took 41.1 min.
At the pause, the run had used 453,488 tokens of its 750,000-token allowance. We did not record the count after the Resume.
The test that proved the bug
The worker wrote auth-tab-order.unit.test.ts, with one test: “sign-in keyboard order > tabs from email to password before reaching Forgot password”. On the untouched code it failed on its assertion, not its setup:
AssertionError: Tab from email must reach the password field next; order is
auth-home-link -> theme-toggle auth-theme-toggle -> auth-email -> auth-forgot-link
-> auth-password -> password-toggle -> auth-submit -> a -> a -> a:
expected 4 to be 3 // Object.is equality
That is the bug in one line: after the email field, Tab reaches the “Forgot password?” link before the password. The attempt on 30 October wrote a test that failed the same way.
The fix moves the link after the password input in the page’s order, which is the order Tab follows. A CSS grid keeps the link where it was on screen, at the end of the password label’s row, at the same size and weight. On the pull request’s branch, the test file and its one test pass, in 482 ms.
What each gate checked
A gate runs each check on the untouched tree and again with the change, and compares the exit codes. A check that already failed on the untouched tree can still count, but only if it fails in a new way: more failures, a failing test it did not name before, or Clef reading its output as a new failure. Clef is the small model that answers yes-or-no questions about check output with a confidence, and its answer counts at 0.60 or more.
Gate 1, route 1, failed. The new test failed on both trees, exit 1 and exit 1, as it must. The typecheck failed on both, and the gate ruled it failing before. The full test suite, CI=1 pnpm run test, also failed on both trees and took 390.9 s. Clef read its output as a new failure at 0.63, and the gate failed the route. That was wrong, as the next section shows.
Gate 2, route 1, passed. The same three checks, with the same exits. This time the gate ruled the full suite by exit codes, as failing before.
Gate 3, route 2, passed.
| Check | Untouched tree | With the fix | How long | Verdict |
|---|---|---|---|---|
| The new test | exit 1 | exit 0 | 2.2 s | fixed |
| Three related unit test files | exit 0 | exit 0 | 2.0 s | passing |
| The auth worker test | exit 0 | exit 0 | 20.0 s | passing |
CI=1 pnpm run typecheck |
exit 1 | exit 1, twice | 2.6 s | failing before |
CI=1 pnpm run test |
exit 1 | exit 0 | 396.0 s | “fixed”, wrongly |
The gate over the whole change passed on the same five checks, with the same exits. For the route checks, the untouched tree’s exits came from routes 1 and 2.
Every gate left out pnpm run check, because its script runs a step that installs packages. Route 2’s judge and the judge over the whole change both accepted. The last judge passed the change on the contract, the tests, the scope and the reader’s words, and noted that the typecheck failure was there before and outside the changed paths. No second reviewer was seated.
The pause and the Resume
At 00:58:03 the run paused with this sentence: “This issue run has used its allowance (453488 of 750000 tokens, 61 of 60 minutes). Resume to give it as much again, or cancel it.”
Time ran out, not tokens. The 60 minutes counted the project’s checks as well as the models’ time. By muxcode’s own count, the checks take 34 of a run’s first 60 minutes on this repository. That figure is muxcode’s estimate, not a measure of this run: the run’s records did not time its untouched-tree checks on their own.
At 01:04:21 our QA script, on the Mac, sent the Resume the Cowork page sends. The run went on from route 2’s gate, and the draft opened 22 min 28 s later.
The pull request
The draft changes 6 files, 62 lines added and 7 removed, in one commit authored by Abayomi Popoola, who started the task. Its branch is muxcode/issue-267-f1dade6d, and its author is the mux GitHub App.
| File | Change |
|---|---|
The new test, auth-tab-order.unit.test.ts |
added, +45 |
| The sign-in page | +7 / −5 |
| The page’s stylesheet | +5 |
| The built stylesheet | +1 / −1 |
| The asset versions | +1 / −1 |
| The stylesheet’s unit test | +3 |
The description starts “Fixes” and the issue, says the mux GitHub App opened it for Abayomi Popoola from muxcode’s Cowork, rates the risk Medium and gives the steps to revert. Two of its lines are wrong, and the next section says which.
What the run got wrong
On 1 November 2026, mux ran its release of 31 October, whose copy of muxcode’s workflow predates the fixes below. The fixes for items 1 to 5 went live on 2 November 2026: in muxcode 1.0.21, and in mux’s release of that day, which carries the same workflow for Cowork.
1. A false failure on a cut-off baseline. Gate 1 failed route 1 on the full test suite, which already failed on the untouched tree. muxcode kept only the last 4,000 characters of the untouched tree’s output, so Clef compared the change’s output with a fragment and read a new failure at 0.63. The failure it named was a test in another app that the change never touched. Gate 2 ruled the same suite by exit codes. The mistake cost about 24.2 minutes: the retry worker’s 10.7 and gate 2’s 13.5. Now a Clef reading or a newly named failing test counts only against untouched-tree output that muxcode saw whole.
2. Checks that already failed ran a second time. The typecheck and the full suite failed on the untouched tree and still ran again. The typecheck ran twice at all four gates, and the full suite at gates 1 and 2. A suite run took 391 to 405 s. Now a check that failed on the untouched tree runs once at a gate. It runs again only when its output shows a new failing test or more failures. On the untouched tree, second runs wait until every check has run once.
3. The description called the test suite fixed. The draft lists CI=1 pnpm run test as “exit 1 → exit 0, fixed”, and counts “2 fixed”. The change touched only the sign-in page and its CSS, and the untouched tree’s failure was never confirmed, because the saved results dropped its second run.
Now “fixed” needs the untouched tree to fail twice. Otherwise the verdict reads “passes now; failed once on the untouched tree”, and the saved results keep the second run.
4. The description named the wrong start commit. The draft says “The run started from 8e55b1f”. That is the container’s own first commit, which nobody else can find. The run started from 56f794d.
Now the record carries the repository’s start commit, and the revert steps use it. The pull request from the second run, below, says “The run started from 65a2afc”, the commit on origin that its start read.
5. The allowance counted check time and ignored repository size. The checks spend no model, yet by muxcode’s own count they take 34 of a run’s first 60 minutes on this repository. Now active time leaves out the gates and the untouched-tree checks. The allowance is also sized once, from the untouched tree’s file count, and each Resume grants the same again. The pause sentence names the size.
| Files in the repository | Size | Tokens | Active time |
|---|---|---|---|
| under 300 | small | 750,000 | 60 min |
| 300 to 999 | medium | 1,125,000 | 90 min |
| 1,000 or more | large | 3,000,000 | 180 min |
muxcode 1.0.21 shipped the large row at 1,500,000 tokens and 120 minutes. muxcode 1.0.22 raised it to 3,000,000 and 180.
On one muxcode developer’s Mac, 42 of 65 repositories hold fewer than 300 files. The repository in this run holds 1,663, so it now gets the large allowance.
6. The gate’s script nearly hit Linux’s limit on one argument. It reached the container as one 116 KB argument, 15 KB under Linux’s limit of 131,072 bytes. The run did not fail on it. In mux’s release of 31 October, tagged at 23:30 UTC, 25 minutes before Start, mux writes a Python program over 8 KiB into the container once, by its digest, and runs it through a loader that refuses any other bytes. Every command stays within 64 KiB. Cloud tasks your Mac drives got the same bound in muxcode 1.0.21.
7. The repository’s typecheck failed on a fresh install. It failed on the untouched tree at every gate, so it could never catch a type error. A fresh install lacked generated types, with errors such as Property 'Egress' does not exist on type 'Exports', and two modules a browser-test fixture needs. Once the types were generated, the typecheck passed on a Mac in 4.1 s. The fix makes the typecheck generate them first, and moves the browser-test project to a check of its own. It shipped in mux’s release of 2 November.
What changed on 2 November
On 2 November 2026, muxcode 1.0.21 reached the stable update channel, and mux’s release of that day went live at 03:03 UTC. Between them they carry every fix above, a cloud start that sends your project while the task boots, and a fix that keeps a new task’s copy of the project from carrying another member’s start.
That morning we ran Cowork again, on a feature request in a private test repository of 4 files: “Count the items in a checkout”. The task started at 05:18:39 UTC, and the mux GitHub App opened draft pull request #3 at 05:22:28, 3 min 49 s later. The run took 3 min 32 s from creation to completion, with no pause and no retry: seven model seats, all DeepSeek V4.1 Flash at max, and three gates, which all passed. Its description says “The run started from 65a2afc”, the commit on origin that the start read (item 4), and mux recorded the run’s allowance as small: 4 files, 750,000 tokens and 60 minutes (item 5). A 4-file repository with nothing to install is not a 1,663-file one, so these times do not compare with the first run’s.
Cloud tasks also reach their first turn sooner. On production on 2 November, on a six-file repository, a fresh cloud task reached its first turn in a median 3.7 s, against 12.9 s on 31 October. Reopening a running task took 2.0 s, against 4.3 s, and resuming a stopped one took 1.8 s, against 4.2 s. On a 1,684-file repository, a fresh task reached its first turn in 4.1 s. These numbers time ordinary cloud tasks from send to first turn, not Cowork starts, and sandbox hours still begin only when the project arrives.
Who pays
A Cowork start goes through the same admission as any cloud task, charged to the member who pressed Start. It spends that member’s sandbox hours and awake sandboxes, and a member past a cap is refused at Start.
| Plan | Sandboxes at once | Sandbox hours | Included model |
|---|---|---|---|
| Pro | 5 | 40 a month | $2.50 a month, $0.625 a day |
| Pro+ | 12 | 300 a month | $35 a month, $8.75 a day |
A trial can’t start Cowork: it includes no model. In a team workspace, each member spends their own plan’s allowance, not a pooled one. DeepSeek V4.1 Flash costs $0.30 per million input tokens, $0.006 per million cached and $1.20 per million output, plus a 5% gateway fee. Each seat’s model call is charged to the member who started the task, and signs in with the task’s own ticket, so no key leaves your Mac or enters the container.
Clef’s readings count against the same member’s Clef allowance: on Pro, 280,000 input tokens a UTC day and 100,000 per five hours, and ten times both on Pro+. When the hours run out, the run pauses with its tree kept, and a Resume after they return carries on.
What keeps it in
- Commands run without asking, inside a closed container. Every Cowork seat runs in Bypass, the permission mode that runs commands without a card. Commands on your Mac, MCP servers and writes to shared notes are refused, with no card. The container starts with no internet. Every request goes through mux’s gateway, which forwards only reads from package registries, GitHub and Debian mirrors, and the task’s own fork.
- The GitHub App’s tokens never enter the container. Each token covers one repository. The fetch at Start gets read access to contents and metadata. The pull request gets write access to contents and pull requests, and never to workflows. A token never reaches a log, or any reply but the task’s own private route.
- Only people who can push can start. That is the workspace’s owner, or a member whose GitHub account is linked to mux and who can push to the repository. mux asks GitHub again when it opens the pull request.
- The pull request holds only what the last gate read. Each file must match what that gate recorded, and links and submodules are refused. Cowork never pushes on its own what a pushed branch would run or reconfigure, such as
.github, other hidden folders, CI, build and task files, manifests, lockfiles and agent guides. - The issue is a report, not an order. Its text reaches the run quoted, after Cowork removes what GitHub would not show a reader: HTML comments, link definitions and invisible characters. Cowork reads no pull request comments. When the issue’s author is outside the repository’s people, the pull request says so.
Limits
- Repository size: mux refuses a start before spending anything when the tree is past about 4,000 files. It measures the size of the file list, not the count, so long paths reach the limit sooner.
- Steps: 40 steps end a run for good, since a run that needs 40 is going in circles. A Resume does not lift it.
- Allowance: sized once by the repository’s file count, as the table in item 5 shows, with check time left out. A spent run pauses with its verified tree kept, and Resume grants the same again.
- Changed paths: a gate keeps digests of at most 500 paths, so a larger change ends the run at the first gate it passes.
- Questions only you can answer: a run never waits on one, or on a program the container lacks. It stops with what to do instead, and the issue is free for a new start.
The working where each number comes from
Every figure comes from the first live run’s evidence, saved on 1 November 2026, unless noted. Times are UTC.
- 91 min 27 s: from the task’s start at 23:55:22 to the pull request’s creation at 01:26:49, as GitHub reports it.
- Each step’s times and outcome; 84.2 s and 14.3 s: the run summary’s attempts and stages. Every seat logged DeepSeek V4.1 Flash on mux at max.
- 89.8, 83.5, 42.4 and 41.1 min: the run’s creation to its last update, the same less the 377,385 ms pause, and the sums of the eight seats and the four gates.
- 453,488 of 750,000 tokens, 61 of 60 minutes: the pause sentence, word for word. The 750,000 and the 60 minutes were the run limits then, the same for every repository.
- 34 of the first 60 minutes: muxcode’s own note on its active-time count, next to the fix in item 5. It is an estimate; the run’s records did not measure the untouched-tree checks on their own.
- The test’s failure and 482 ms: the test run on
mainand on the pull request’s branch. - Exits, durations, verdicts and 0.63: each gate’s record. 0.60 is muxcode’s bar for a new failure.
- The pull request: 6 files, +62 / −7, one commit
04cb7c4, as GitHub showed it on 1 November 2026. - 4,000 characters, 24.2 minutes, 391 to 405 s: the baseline cut in muxcode’s workflow engine, and the retry and gate 2, and the suite’s runs, from the gate records.
- The allowance table, 42 of 65 and 1,663 files: muxcode 1.0.21’s workflow and the note beside it. The large row’s 3,000,000 tokens and 180 minutes:
allowancein muxcode’sworkflow/engine.rs, commit41c0fe92of 3 November 2026, shipped in 1.0.22 and read at commite8e813b2on 4 November 2026. - 116 KB, 131,072 bytes, 8 KiB, 64 KiB, 23:30 UTC: mux’s fix and its release tag of 31 October 2026.
- 4.1 s: the typecheck on a Mac after the types were generated.
- Plans, prices and Clef’s allowance: mux’s plan limits and meters in its release of 31 October 2026, unchanged in its release of 2 November. Each team member spends their own allowance:
docs/markdown/billing.mdand the pricing page, read on 4 November 2026. - 2 November releases: muxcode 1.0.21’s release notes; mux’s release of 2 November, deployed at 03:03 UTC, carries the workflow built from the fixed muxcode source and the typecheck fix.
- The second run: its run summary and gate records, saved on 2 November 2026; 3 min 49 s is from the task’s start at 05:18:39 to the pull request’s creation at 05:22:28, as GitHub reports it; 3 min 32 s is the run’s creation to its completion; the description’s start commit was read with GitHub’s CLI that day.
- Start times: medians from 16 runs each on the six-file repository and 11 on the 1,684-file one, timed on production between 03:09 and 03:57 UTC on 2 November 2026, against the same measures on 31 October.
- 4,000 files, 40 steps, 500 paths: muxcode’s Cowork rules; mux’s start counts each tracked file’s path length plus 111 bytes, up to 723,155 bytes.