Automates source code changes and unit tests using local MLX models on macOS, verified by a machine-run gate to ensure compilation and test success.
Also known as lvlrSajjad/sidecrew
- Stars
- 0
- Tools
- 13
- Downloads, 30 days
- —
- Latest version
- 0.2.0
- Last commit
- Sep 25, 2026
- License
- MIT
What is sidecrew MCP?
sidecrew automates source code changes and unit tests using local MLX models on macOS, verified by a machine-run gate to ensure compilation and test success. It exposes 13 tools, such as sidecrew_status, sidecrew_generate, sidecrew_verify.
Summary generated from the project's README
About sidecrew MCP server
Automating source code modifications and unit tests on macOS is what sidecrew enables for developers using Apple silicon. By combining high-level planning from Claude Opus with local MLX models for executing specific tasks, this tool allows you to perform code changes without consuming additional Claude tokens for the worker tasks. The system operates locally on your machine, utilizing a machine-run gate to verify that every change maintains compilation through tsc and passes existing tests before any output is presented to you.
To use sidecrew, you must have at least 24 GB of installed RAM, as the server refuses to run on lower-spec machines to prevent memory pressure from causing false failures. It requires Node.js version 20 or higher and a manual installation of mlx-lm via pip. While the planning phase involves token costs for Opus, the actual editing is performed by a local 7B model. This setup ensures that you only see code changes that have successfully survived the verification process, providing a layer of safety that standard frontier models lack when delivering unverified diffs.
What you can do with it
- 1Automated code refactoringRequest a complex rename or symbol change and have a local model execute the tasks while a gate ensures the project still compiles.
- 2Verifying unit test integrityRun a workload of unit tests using a mutation-kill gate to ensure code changes do not break existing functionality.
- 3System requirement validationCheck if your Mac meets the necessary hardware specifications before starting a large coding task.
Written from the project's README. Every use case is checked against a quote from it.
How to install sidecrew MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall sidecrew MCP in Claude Code
$ claude mcp add sidecrew -- npx -y sidecrewInstall sidecrew MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"sidecrew": {
"command": "npx",
"args": [
"-y",
"sidecrew"
]
}
}
}Install sidecrew MCP in VS Code
.vscode/mcp.json
{
"servers": {
"sidecrew": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"sidecrew"
]
}
}
}Install sidecrew MCP in VS Code CLI
$ code --add-mcp '{"name":"sidecrew","type":"stdio","command":"npx","args":["-y","sidecrew"]}'Install sidecrew MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"sidecrew": {
"command": "npx",
"args": [
"-y",
"sidecrew"
]
}
}
}Install sidecrew MCP in Codex
$ codex mcp add sidecrew -- npx -y sidecrewInstall sidecrew MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.sidecrew] command = "npx" args = ["-y", "sidecrew"]
Install sidecrew MCP in Gemini CLI
$ gemini mcp add -s user sidecrew npx -- -y sidecrewInstall sidecrew MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"sidecrew": {
"command": "npx",
"args": [
"-y",
"sidecrew"
]
}
}
}sidecrew MCP tools 13
Detected from the READMEsidecrew_statussidecrew_generatesidecrew_verifysidecrew_run_batchsidecrew_plan_validatesidecrew_escalatesidecrew_reviewsidecrew_fix_plan_validatesidecrew_fixsidecrew_fix_escalatesidecrew_reconsidecrew_query
| sidecrew_status | — | |
| sidecrew_generate | — | |
| sidecrew_verify | — | |
| sidecrew_run_batch | — | |
| sidecrew_plan_validate | — | |
| sidecrew_escalate | — | |
| sidecrew_review | — | |
| sidecrew_fix_plan_validate | — | |
| sidecrew_fix | — | |
| sidecrew_fix_escalate | — | |
| sidecrew_recon | — | |
| sidecrew_query | — |
Show all 13 toolsShow fewer tools
sidecrew_read
| sidecrew_read | — |
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablelvlrsajjad/sidecrew is public and reachablegithub.com/lvlrsajjad/sidecrew ↗Pass
- Package names this repository as its sourcesidecrew names lvlrsajjad/sidecrew as sourcenpmjs.com/package/sidecrew ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for sidecrewnpmjs.com/package/sidecrew/v/0.2.0#provenance ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-09-25github.com/lvlrsajjad/sidecrew ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from sidecrewPass
- No critical advisory in the package or its dependencies99 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model13 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubsidecrew
You ask for a change to your source code, and you get it — made on your Mac, by models that cost you no Claude tokens, and only after a machine has checked it.
Claude Opus plans the work and reviews what came back. Small models running locally (MLX, no
network) do the narrow parts. Between them sits a gate a machine can run — for a code change: the diff
stayed where it was asked to, tsc is clean, and every test that passed before still passes. Claude
never sees anything that did not survive it.
$ sidecrew fix change_plan.json
fix 2026-09-20T09-14-02Z-rename: 1 step, 12 tasks, 13.0 GB free ÷ 6.5 GB per slot = 2; 1 worker up
step 1/1 "rename the helper": capturing the baseline
rename-01: survived (src/util/asset.util.ts)
rename-02: survived (src/util/asset.util.ts, src/util/asset.util.spec.ts)
…
multi-06: failed at compile · escalating — renamed the symbol 7 times over, 5 compile errors
11/12 survived · 0 → 0 tsc errors · .sidecrew/runs/2026-09-20T09-14-02Z-rename/result.json
Illustrative shape, not a captured transcript — it is the real output format with the counts from the
React measurement below, and no client's file names. 11 of 12 with a
95 % interval of [0.615, 0.998] is the number; the line above is what it looks like while it runs.
Unit tests are workload #1 — the same shape with a mutation-kill gate instead — and the numbers for both are below, each with its interval.
sidecrew needs 24 GB of installed RAM. Below that a 7B cannot sit beside a normal working set
(measured), so sidecrew refuses to run and tells you why rather than quietly becoming a different
tool (ADR-0073). sidecrew doctor answers this before you plan anything.
And the other half of the ledger, measured 19–20 Sep 2026: the workers are free, the coordination is not. Opus planning costs 8,400–22,100 tokens per task, depending almost entirely on how many tasks are in the plan — see What this costs to run below. A page that says "the work is free" without saying that is telling you half of it.
Before any number below: how tightly to read it
Every rate on this page is an interval, never a point, and the reason is measured. Replaying a
frontier model's own diffs — which the gate finds no defect in — through the gate a second time, it
disagreed with itself on 2 of 19 candidates: D = 0.105, 95 % interval [0.013, 0.331]
(experiments/gate-error-rate/, against a rule frozen before the first replay). That rule's own
verdict at D > 0.10 is UNACCEPTABLE, and its consequence is this paragraph: no survival rate here
is published as a bare fraction, D travels beside each of them, and no two of our rates are compared
without asking whether their difference survives it.
What that does and does not damage. D counts the gate refusing changes that were fine.
Nothing in it is evidence of the gate admitting something bad. So:
The gate admits nothing that fails — stands. The gate refuses only things that fail — measured false, at roughly one evaluation in ten, and unproven at any tighter bound.
Two of the three known causes are now recorded on every verdict — memory pressure (ADR-0066) and a
baseline captured on a different calendar day (ADR-0069). The third is undiagnosed, and both measured
disagreements happened on a quiet machine, so it is neither of the first two. D was measured on
workload #2a's gate; it says nothing about workload #1's mutation gate, which is a different oracle
(§4.4 of the rule).
Workload #2a — behaviour-preserving changes, measured
Against a decision rule frozen before the tool had produced a single verdict
(experiments/go-no-go-2a/results/REPORT.md). S is survival, A is a blind reviewer's approval of
the diff. Every cell is k/n with its exact 95 % interval; D = 0.105 [0.013, 0.331] applies to
every S.
| input | S, local 7B |
S, Haiku control |
A, local 7B |
A, control |
|---|---|---|---|---|
| fixture | 3/3 [0.292, 1.000] |
3/3 [0.292, 1.000] |
1/3 [0.008, 0.906] |
3/3 [0.292, 1.000] |
| a commercial Nest/jest codebase | 12/12 [0.735, 1.000] |
12/12 [0.735, 1.000] |
9/10 [0.555, 0.997] |
10/10 [0.692, 1.000] |
| a commercial React/jest codebase | 11/12 [0.615, 0.998] |
12/12 [0.735, 1.000] |
9/10 [0.555, 0.997] |
10/10 [0.692, 1.000] |
Read the intervals, not the fractions: at these sample sizes 12/12 and 11/12 are not
distinguishable, and neither is the 7B from the control on A. Both real projects passed the frozen
rule by a margin of exactly zero, on a sample of ten. The survival rate decided nothing — five of
six measurable cells sit at or above 0.917, so the rule's ratio clauses were inert, and the only thing
that separated a local 7B from a network model was the approval rate.
What that approval rate is about, measured: the local model makes unrequested cosmetic edits — a
deleted docblock, a reworded comment, a stray blank line — in 4 of 23 [0.050, 0.388] sampled
survivors, against the control's 0 of 23 [0.000, 0.148]. confined ∧ compiles ∧ tests pass
cannot see any of it, which is the point.
What you gain over just asking Opus
Measured 18–19 Sep 2026 against the thing a colleague actually does today — asking a frontier model directly, one task at a time, with no plan and no gate. Same 19 hand-written tasks, same two codebases, four arms.
| Opus alone | Sonnet alone | sidecrew | |
|---|---|---|---|
| tokens, 19 tasks, Nest codebase | 80,131 | 88,820 | 0 |
| tokens, 19 tasks, React codebase | 95,335 | 88,680 | 0 |
| output vs Opus, Nest codebase | — | identical 19/19 | identical on 18 of 19 |
| changes delivered and verified, Nest | 19 (unverified) | 19 (unverified) | 19/19 [0.824, 1.000] survived |
| changes delivered and verified, React | 19 (unverified) | 19 (unverified) | 15/19 [0.544, 0.939] survived; 4 escalated |
The token columns are counts and are exact. The survival rows are rates, so they carry their
intervals, and D = 0.105 [0.013, 0.331] applies to both of them.
A fourth arm ran the same gate over Opus's own diffs, to separate the gate's contribution from the
worker's: 19/19 [0.824, 1.000] on the Nest codebase and 18/19 [0.740, 0.999] on the React
one. Two things follow, and the second is the more useful.
The gate found nothing wrong with a frontier model's work. Its single rejection there is a
tsc fragility it rejects from both arms — so on these tasks the gate adds no safety on top of
Opus. Its entire value is that it makes the free worker usable, not that it second-guesses the
expensive one.
And it is what separates a worker defect from a project defect. Of the four React failures, three
vanish when Opus writes the diff — genuine worker defects — and one reproduces exactly, because the
7B's output for that task was byte-identical to Opus's. Worker-attributable survival is therefore
15/18 [0.586, 0.964], not 15/19. Without that control the small model would have been blamed for
a third more failures than it caused — and note that the two intervals overlap almost entirely, so the
correction changes the attribution rather than the number.
Three things that buys you, and one it costs.
- The work is free. Not cheaper — zero worker tokens. Opus plans and reviews survivors; the editing happens on your Mac.
- On work a compiler and a suite can check, you give up nothing for it. Eighteen of nineteen diffs were byte-identical to what Opus produced. Not "comparable quality" — the same file.
- When it is wrong, you get told, loudly, and nothing is applied. The four React failures were a
symbol renamed seven times over (5 compile errors), a rename that also hit a type, a module path
and a public property key (122 compile errors), a change that renamed the file it was given,
and one that a frontier model produced identically. Each printed as
escalated, each with the exact errors, none merged. Asking Opus directly gives you a diff and the sentence "nothing else changed" — accurate here, and unverified. - It costs wall-clock. ~25 s per task interactively with Opus; 216–271 s with sidecrew
(15 s to generate, 200–255 s for the project's own suite and
tsc). It is free and unattended, not fast.
What is not claimed. The frozen rule's verdict is WITHHELD: every task in these runs is a
rename, and the rule refuses a verdict until at least half are null guards, API migrations or
dead-code removal. The measurement vindicated that clause rather than surviving it — two frontier
models and a 7B emitted identical bytes on 18 of 19 Nest tasks, so that task set cannot rank
anything. experiments/status-quo/ has the arms, the protocol frozen before they ran, and the
defects.
Requirements
| OS | macOS on Apple silicon. The local worker is MLX, which is Apple's. Not a port away — a different inference stack. |
| RAM | 24 GB installed or more for the local tier and everything this page measures. The threshold is on installed RAM, never free, so a machine that can host a worker never falls back silently. |
| Node | ≥ 20. A project whose own engines demands newer is honoured — run sidecrew under the project's Node (ADR-0049 cost a night to learn). |
| Python | mlx-lm, installed by you: pip install mlx-lm. Deliberately not bundled — external capabilities are shelled out and reported by doctor, never vendored. |
| Disk | ~4 GB for the 7B (downloaded on first sidecrew serve, pinned revision), plus ~500 MB per verification sandbox while a run is in flight. |
| The project | TypeScript with a green-ish tsc and a test suite that runs. Workload #1 also does Swift/XCTest. |
Under 24 GB: sidecrew still runs, on the api tier, with Haiku as the worker billed to your key
— and none of the numbers on this page describe that tier, because they have not been measured
(Phase 13 §5). Supported, and unpriced. If that matters to you, 24 GB is the line.
Windows and Linux: no. The TypeScript verifier would port, but the worker would not, and memory
and pressure detection are sysctl/vm_stat. sidecrew doctor tells you rather than failing oddly.
What to expect on your machine
The check is on installed RAM, never free RAM — free RAM swings by 8 GB when you open Xcode, and a tool that changes what it is based on that is a tool you cannot reason about. The floor is 24 GB and below it sidecrew refuses (ADR-0073).
| installed | tier | worker | gates in flight | what that means for you |
|---|---|---|---|---|
| under 24 GB | — | none: sidecrew refuses | — | A 7B cannot sit beside a normal working set here (measured), and trying anyway means swapping — which makes the gate reject changes that were fine (ADR-0066). You are told your RAM, the floor and the reason. There is an unsupported escape hatch (SIDECREW_TIER=api, Haiku over the network, billed to your key, never measured); it is not what any number on this page describes. |
| 24–32 GB | local |
7B on your Mac | 1 | Everything on this page was measured here. Worker tokens are zero. One task at a time: ~4 min each, so a 19-task plan is ~70 min, unattended. Memory is the binding constraint — see the false-negative note below. |
| 48–64 GB | local |
7B, or a 14B comfortably | ~3 (estimated) | The gate stops competing with the model for memory. The same 19-task plan should land nearer ~25 min (estimated), and ADR-0066's whole false-negative class — a starved gate failing closed — stops applying. You can keep using the machine. |
Measured vs estimated, because it matters here. The 24–32 GB row is measured: 15 s to generate,
200–255 s of the project's own tsc and suite, per task, on a 32 GB M2 Pro. The 48–64 GB row is an
estimate derived from two measured quantities — the per-task gate cost above, and the memory a
single gate actually holds (up to 8 GB of tsc on a large React project, plus 7–10 GB of jest
workers). Nobody has run sidecrew on 64 GB. The concurrency arithmetic is the tool's own
(slot_gb = model.ram_gb + headroom), so doctor will tell your machine what it can do.
More RAM buys wall clock and reliability — not better changes. Of the four failures the gate caught on the React codebase, none would have been prevented by more memory: one was a symbol renamed seven times over, one renamed a file it was given, one touched a type declared in a file the worker was never shown, and one was byte-identical to what Opus produced. The first two are the model; the third wants retrieval, not RAM.
How loosely to read every survival number here is the top of this page — D = 0.105 [0.013, 0.331], the gate disagreeing with itself. It is repeated there rather than here because it
governs every rate below it, not just this table.
Two further defects changed the gate itself (ADR-0067, ADR-0068), so the Phase 11 table above was measured on a gate that has since been fixed in two ways.
Both real projects are unmodified and neither of them ours, and every arm above ran on the
local tier at zero worker tokens. The api tier has no survival, approval or dollar figure of its
own — Phase 13 §5 was never run, and nothing on this page describes it.
experiments/go-no-go-2a/results/REPORT.md has the funnel, the frozen rule, and the six defects it
cost to get a number at all.
Not a test framework. Vitest, Jest and XCTest run the tests; StrykerJS/Muter mutate the code. sidecrew orchestrates. The runner is a seam: same plan, same seed, Vitest and Jest return identical verdicts (ADR-0028).
What this costs to run
Workers are free. Coordination is not, and this is the number that says by how much.
Measured 19–20 September 2026 on an unmodified commercial Nest/jest codebase, against a rule frozen
before the planner existed (experiments/planner-cost/):
| plan size | Opus tokens to plan | per task | vs. paying a model per task |
|---|---|---|---|
| 12 tasks | 265,607 | 22,134 | 2.84× |
| 41 tasks | 343,144 | 8,369 | 1.07× |
Planning cost barely moved for 3.4× the work — 1.29×. It is a large fixed cost (reading the codebase, ~233k tokens) plus a small per-task one (~2,700). So:
sidecrew's coordination is not worth paying for on a dozen tasks, and the economics move sharply in its favour as the job gets bigger.
Both rows are above 1.0, so by the frozen rule both fail — planning still costs more than handing each task to a paid model would. The honest reading is the sentence above, not "it fails": one plan size would have supported a much harsher and much less true claim, which is exactly why the rule demands two.
Never quote a per-task figure without the plan size. Same planner, same project, same week, 2.6× apart.
The correction round is off, and that is measured too. Giving a failing worker one Opus-written
note — after the free retry that already carries the compiler's own words — rescued 0 of 29
[0.000, 0.119] tasks,
and 27 of 29 landed at exactly the same gate stage as the free retry had
(experiments/correction-round/). On the tasks where the worker simply returned the file unchanged,
16 of 17 did it again after being told specifically that returning it unchanged was the failure.
On the shape that work belongs to — adding a null guard — the local 7B survived
1 of 30 [0.001, 0.172] tasks, and returned the file unchanged on 17 of them. Rewording an
instruction does not move that, which is why sidecrew fix ships with the round switched off.
It is not, however, a capability ceiling, and a later measurement says so. Phase 14b put a 14B on
the same 30 tasks and narrowed the asks to a single named function on another pass. Both cut the
"returned it unchanged" failure sharply — 17 tasks → 3 on the 14B, 17 → 10 on the narrowed ask — and
neither moved survival, which went 1 → 2 [0.008, 0.221]. The workers do the work; the gate cannot
credit it. See What v0.1.0 does not have below.
Why, on workload #1 (tests)
| Claude writes every test | sidecrew | |
|---|---|---|
| Tokens per test | full generation, every function | planning + one exemplar per shape + review of survivors |
| Latency bound | API | your hardware — 40 tok/s per 7B worker, measured below |
| What Claude reads | raw output | only tests that compiled, passed and killed ≥ 1 mutant |
| Network for generation | yes | none |
The token and survival columns were measured in Phase 6 and the answer is not a clean yes:
experiments/go-no-go/results/REPORT.md has the funnel, the decision rule that was frozen before the run,
and the cell it could not name. TypeScript is a conditional go; Swift is a no-go. The speed column:
M2 Pro, 32 GB, macOS 26.6.2, mlx_lm 0.31.3, with Xcode and a simulator open —
experiments/go-no-go/results/bench-2026-09-11.json, every field "measured": true:
| model | decode | TTFT (warm) | peak RSS | swapped | 5× same prompt |
|---|---|---|---|---|---|
| Qwen2.5-Coder-7B-Instruct-4bit | 40.5 tok/s | 159 ms | 4.4 GB | 0 | byte-identical |
| Qwen2.5-Coder-14B-Instruct-4bit | 21.1 tok/s | 199 ms | 8.1 GB | 0 | byte-identical |
On a quiet machine: 42.3 and 21.2 tok/s — a full Xcode working set costs the 7B about 4 % and the 14B almost nothing. What Xcode costs is memory, not speed: at 9.1 GB free the 14B swapped 3.2 GB. That is why the 7B is the default and why starting a worker is gated on free RAM at that instant (ADR-0011).
Install
Requirement: an Apple Silicon Mac with at least 24 GB of installed RAM. Below that a 7B cannot sit
beside a normal working set (ADR-0009, measured), and sidecrew refuses to start, naming your RAM,
the floor and the reason. sidecrew doctor answers it before you plan anything.
Refusing is deliberate rather than lazy. Running anyway means swapping, and swapping makes this gate reject changes that were fine, in a way its own verdict cannot distinguish from a real defect (ADR-0066, measured). Handing that to the users least able to spot it is worse than saying no.
There is one escape hatch and it is unsupported. SIDECREW_TIER=api runs the worker as
claude-haiku-4-5 over the Anthropic API, behind the same gate, billed to your key. It is built and
tested, its survival and dollar-per-task figures have never been measured, and no number on this
page describes it (ADR-0073). doctor labels it unsupported, opted in.
Everything except generation (planning, validating, verifying) works anywhere node does.
npm install -g sidecrew
sidecrew doctor
doctor checks each capability separately:
ok platform darwin/arm64
ok node v20.20.0
ok tier 32.0 GB installed → local tier · qwen2.5-coder-7b-4bit
ok mlx_lm python3 -m mlx_lm server available
MISSING worker nothing on http://localhost:8000/v1 — start one with: sidecrew serve
ok memory 32.0 GB total · 12.5 GB free
ok tsc Version 5.9.3
ok vitest vitest/2.1.9 darwin-arm64 node-v20.20.0
MISSING stryker stryker 8.7.1 is not in sidecrew's tool cache — run: sidecrew tools install (~62 MB, never into a project)
ok swift Apple Swift version 6.3.3
MISSING muter not installed — brew install muter-mutation-testing/formulae/muter
ok line-ranges from the TypeScript compiler's own tree (ADR-0076)
DEGRADED tsconfig-include sidecrew writes candidates to test/, and no file there is in the program
tsconfig.json builds — every candidate would be compiled by a stage that
never opens it (ADR-0037)
ok ts-jest ts-jest does not resolve here — the shim is not needed
ok tsc-heap this project's own scripts ask for no extra heap
ok jest-tests jest does not resolve here — not this project's runner
The bottom five rows are the ones worth reading, and each was a run that failed — or worse, one
that quietly succeeded. "Is it installed" answers yes for all of them; the defect is one layer down,
in how a particular project is laid out. tsconfig-include is the worst of the six real-world
blockers and the only one that ever failed open: a compile stage that type-checked the project
without ever opening the candidate, and said compile ok about a file with three type errors in it.
Claude Code
claude mcp add --scope user sidecrew -- npx -y sidecrew mcp
Then claude mcp list should say sidecrew: … ✔ Connected, and sidecrew_status is callable from a
new Claude Code session. Installing the skill and agents adds /sidecrew plan|run|review|escalate:
cp -r $(npm root -g)/sidecrew/claude/skills/sidecrew ~/.claude/skills/
cp $(npm root -g)/sidecrew/claude/agents/*.md ~/.claude/agents/
The same files are a Claude Code plugin — claude/.claude-plugin/plugin.json is its manifest, and its
version moves with package.json and server.json.
The skill is what keeps generation on the local worker: a Claude Code subagent can only pick haiku/sonnet/opus on the session endpoint, so workers cannot be subagents and the skill says so in as many words (ADR-0001).
Any other MCP client
{ "mcpServers": { "sidecrew": { "command": "npx", "args": ["-y", "sidecrew", "mcp"] } } }
Capabilities are independent
| Capability | Needs | Without it |
|---|---|---|
| Plan, validate, verify TypeScript | node, and the project's own tsc and vitest or jest. Stryker is sidecrew's: sidecrew tools install |
— |
| Verify Swift | Xcode CLT, muter |
TS only |
| Local workers | pip install mlx-lm (Apple Silicon) |
verify-only; Claude writes tests itself |
pip install mlx-lm # workers
brew install muter-mutation-testing/formulae/muter # Swift mutation
sidecrew tools install # sidecrew's own pinned Stryker, once per machine
Nothing is installed into the project being tested. Stryker is sidecrew's, pinned at 8.7.1 in
~/.sidecrew/tools, and each run uses a throwaway copy of it wired to the project's own compiler and
test runner. Every run and fix fingerprints the project before and after (git status,
package.json, every lockfile, node_modules) and fails loudly if anything changed (ADR-0088).
sidecrew doctor --project <dir> reports whether the project has a runner of its own — jest or vitest —
since that part is the project's.
sidecrew MCP questions
How do I add sidecrew MCP to Claude Code?
Run claude mcp add sidecrew -- npx -y sidecrew in your terminal. Add --scope user to make it available in every project.
How do I add sidecrew MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does sidecrew MCP provide?
It exposes 13 tools, including sidecrew_status, sidecrew_generate, sidecrew_verify, sidecrew_run_batch, sidecrew_plan_validate.
What are the hardware requirements for sidecrew?
sidecrew requires a Mac with Apple silicon and at least 24 GB of installed RAM to run the local worker tier.
How does sidecrew ensure code changes are safe?
It uses a machine-run gate that verifies the diff stays within the requested scope, ensures tsc (TypeScript compiler) is clean, and confirms all existing tests still pass.
What is the cost of running the local worker?
The worker tokens are free because the editing happens locally on your Mac using MLX models.