Anchor's doctrine has always said the same small model performs better as three sequential roles — planner → executor → critic — than as one conversational blob. Until now that split was trust-based: mythos-core rule 2 told the model to plan before acting, and everyone hoped it listened. Small models drift, and "hoped" is not a verification strategy.

The new scripts/roles.py is the single role→capability map. Each role carries writable-path allow/deny globs (reusing scope_gate.path_matches, so there is exactly one glob implementation in the repo), a can_dispatch flag only the orchestrator holds, and the MCP toolset the role may see. Reads stay unrestricted everywhere — only writes and dispatch are gated.

orchestrate.py now snapshots the worktree around every phase and checks the writes made during that phase against the phase's role. Pre-existing dirt is never blamed on a role. A violation is a hard error: it is logged as an explicit event, the offending task is marked failed-role, and the run still emits its plan, review, and JSON report — then exits 4. Role transitions (plan approved → executors spawned → review starts) are logged orchestrator events in the run JSON, so "who was allowed to do what, when" is auditable after the fact.

The project-orchestrator MCP server applies the same map at the toolset level:

# planning session: read-only .plans/ surface — lifecycle tools not registered
python mcp/project-orchestrator/server.py --project /path/to/myapp --role planner

A --role planner or --role critic session never even sees plans_claim, plans_release, or plans_complete — deny by omission, not refusal. There is nothing to jailbreak past; the tools simply are not there. --role executor keeps the lifecycle tools, and omitting --role preserves the full pre-role surface.

The pattern is borrowed from Fable-class harness plan mode, where planning is a state with edit tools disabled and exit is explicit. Prompt text still tells the model its role — small models behave better told and constrained — but the harness is the guarantee.

One honest boundary: this hardens the orchestrated path only. A single-model session with no orchestrator and no MCP server between it and the filesystem is still bound by doctrine alone. That is stated in the docs rather than papered over.

The probe​

Before /work hard-skips overqualified work — or spends a high-reasoning-effort session on small/mid Preferred plans — it now checks scripts/endpoints.yaml for a lesser, reachable executor. The registry tiers map onto Preferred-models fit the same way work_once.py already reads them: swarm→small, executor/executor-heavy/detached→mid, reasoner→reasoner, frontier→frontier. Listed isn't the same as live — an unreachable worker doesn't count as a delegation target.

If a cheaper endpoint is up, /work leaves the plan unclaimed and prints the dispatch line instead of grabbing it itself:

python scripts/work_once.py --once --endpoint h100-executor --registry scripts/endpoints.yaml

When nothing cheaper is reachable​

If the fleet is dark or nothing registered fits, the session doing the checking is the available executor — /work no longer permanently refuses mid work just because it's overqualified. Instead it right-sizes its own cost and emits a pasteable command for the current product:

High reasoning effort on a mid-class model is a cost dial, not a tier promotion — a Grok 4.5 session at high effort is still mid for Preferred matching, not overqualified for mid plans. anchor/model-fitness.md now says so explicitly for Grok 4.5's row.

Where it landed​

The full contract lives in .claude/commands/work.md and its Grok mirror .grok/skills/work/SKILL.md, ported into platforms/grok-build/GROK.md + platforms/grok-build/commands/work.md, and documented on the /work and Grok Build docs pages. True overqualified work with no cheaper worker reachable still gets a one-line suggestion — /work --no-fit-check plus the effort command — rather than a silent claim; underqualified plans still skip outright.

Conform this project (or that one)​

Two /anchor variants share a slash name and different defaults:

• In a scaffolded project (platforms/… → .claude/commands/anchor.md / .grok/skills/anchor/): /anchor means this tree (CWD / git root). The agent finds a local Anchor checkout, runs anchor --check / --upgrade, and only writes after dry-run confirmation.
• In Anchor (base skill): /anchor <project-path> is required so you never accidentally re-scaffold Anchor into itself.

Already-scaffolded trees prefer anchor --upgrade: take clean upstream updates, add newly introduced scaffold files (for example project /anchor itself), keep locally modified managed files unless you pass --force. Status and diffs stay read-only: --check, --diff, --upgrade --dry-run.

# From the Anchor repo
anchor /path/to/app --check
anchor /path/to/app --upgrade --dry-run
anchor /path/to/app --upgrade --yes

# In the project (after upgrade installs the scaffolded skill)
# /anchor
# /anchor --upgrade

Put anchor on PATH safely​

/install-anchor inspects the OS/shell, locates a checkout that has bin/anchor and scripts/anchor.py, and proposes a user-local symlink (usually ~/.local/bin/anchor) — no sudo by default, no silent overwrite of a foreign binary.

What can this box run?​

/local-models (scaffolded into projects only; source under platforms/) probes the machine with scripts/fit_device.py --probe. On WSL it can read bare-metal host facts via powershell.exe, recommend fits from Anchor’s lean catalog, and print clickable install links. After the report it can offer a draft under .plans/drafts/ to wire endpoints later (install steps live in Prerequisites). Routing keeps the operator’s model-priority order primary and never promotes a tiny local into frontier roles.

Docs​

The Skills section of the docs site opens on an overview that states where each skill is best used (sidebar labels include short use-hints). See Skills overview, CLI check/upgrade, and personal devices.

Plan leases already decide which plan an agent owns. They do not give each agent its own checkout. One working tree means one branch tip — so parallel code edits on a shared clone thrash.

scripts/worktree_for_agent.py creates or reuses a worktree per --agent-id:

python scripts/worktree_for_agent.py ensure \
  --project /srv/myapp --agent-id mid-1 --slug fix-login
# → WORKTREE=…/var/worktrees/mid-1
# → BRANCH=feature/fix-login
# → INTEGRATION=dev

# or after a claim:
python scripts/work_once.py --once --tier mid --agent-id mid-1 --ensure-worktree

The helper ensures an integration branch (dev, else develop; if neither exists it creates dev from main/master), then checks out feature/<slug> inside that agent’s tree. Edit only under WORKTREE=. Run /commit-prep before commit; push the feature branch only — never auto-merge to dev/main.

Scaffold and project config (anchor …, --set-orchestrator) now create var/ + var/worktrees/ and append var/ to the project’s root .gitignore, so local worktrees stay untracked.

Full isolation notes: Fleet workers.

Priority orders the backlog​

Value: high | medium | low was the only lever for ordering ready work, and it's blunt — most plans end up "high," so ties fell back to filename. Plans now take a Priority header:

- **Value:** high
- **Priority:** P1        # P1 > P2 > P3; default P2; orders within a lane

Selection — everywhere it happens: interactive /work, headless scripts/work_once.py, and the fleet pullers — now follows one order:

your in-progress → bugs before features → Priority (P1 → P2 → P3) → Value → oldest first

Lane precedence still wins: a P1 feature never jumps a P2 bug. Priority only sorts within a lane. Anything without the header is treated as P2, so existing plans keep their relative order. The parser is tolerant — P1, p1, or bare 1 all read the same — and work_once.py --list grew a priority column so you can see the queue the way a worker will:

python scripts/work_once.py --list --tier mid --agent-id worker-1
# path                       lane      priority  value  preferred  fit   …
# features/scope-diff-gate.md features  P1        high   mid        good  …

Drafts are private until you promote​

A fresh draft is a thought in progress, not a shipped artifact — and it shouldn't be committable by accident. /draft now writes new plans as <slug>.local.md by default, which .plans/.gitignore keeps untracked:

/draft fix flaky login test      # → .plans/drafts/fix-flaky-login-test.local.md (private)

Promotion is the moment a plan becomes real, so that's where it gets published:

/draft --promote fix-flaky-login-test   # → .plans/features/fix-flaky-login-test.local.md (still private)

Update: the .local suffix is sticky — promote and agent lane moves keep the same basename. Agents never drop .local. Only a human manual rename (or create with /draft --shared) makes a plan git-tracked. The earlier “drop .local on promote” rule is withdrawn.

Nothing changed about the tree itself — .plans/ is still tracked, and *.local.md is still the private-plan suffix in any lane. What changed is the default: you now opt in to committing a draft, instead of opting out.

Anchor already had /work, headless work_once, and two MCPs that were either doctrine (anchor-prompts) or global fleet endpoints (model-fleet). What was missing was a project-bound tool plane for .plans/ itself. The new mcp/project-orchestrator/ server fills that gap.

Bind one process to one app root:

python mcp/project-orchestrator/server.py \
  --project /path/to/myapp \
  --agent-id cursor-mid-1 \
  --tier mid

Or register it with Claude Code / any stdio MCP client using the same flags. Optional project config lives at .anchor/mcp.yaml (agent_id, worker_tiers, stale_after, capabilities).

v1 is deliberately L0+L1. Agents get inventory, plan read, conventions, heuristic dependency suggestions (propose only — no LLM, no plan-file writes), stale/tier-gap warnings, claim/release, and move-only complete after the client asserts Done when. Selection and leases reuse plan_select / plan_lease — the same rules as /work. Promote stays human-only. L2 handoff, L3 orchestrate, L4 allowlisted shell, and loopback dashboard stats are deferred follow-ups.

Use a distinct --agent-id from systemd fleet_watch workers so leases do not fight. Full matrix and refuse rules: mcp/project-orchestrator/README.md. Docs overview: MCP servers.

Alongside this, agent process rules are stricter for any Anchor-scaffolded project: run /commit-prep before every commit (project-agnostic tests/changelog/blog), and open feature branches from dev/develop — creating dev from main/master when the integration branch is missing. Those are operator/agent discipline, not new product binaries, but they keep multi-agent work reviewable.

The gap it closes​

Per-agent worktrees gave each worker its own checkout. Leases decided which plan a worker owns. But nothing verified that the diff a worker produced actually stayed inside the files it was told to touch — a small model that "also fixed" an unrelated file would sail through as long as the tests passed.

The scope gate reads the worktree's changes (git diff vs HEAD plus untracked files) and classifies each path against the spec:

python scripts/scope_gate.py --root . --spec task-spec.md && pytest -q

Exit 3 means a path fell outside scope — and because the gate runs before pytest, tests never execute on an out-of-scope diff. In the orchestrator, the same check runs inline:

python scripts/orchestrate.py --plan-file .plans/features/foo.md \
  --scope-spec task-spec.md --worktree . --verify "pytest -q"

An out-of-scope change marks the task failed-scope and routes it back to the planner. It is not a retryable failure — widening scope is the planner's call, not the executor's.

How scope is written​

## Files in scope takes one path or glob per line, gitignore-style:

• * matches within a path segment, ** across segments
• a trailing / marks a whole subtree (scripts/)
• a plain path matches exactly or as a directory prefix

Legitimately generated files — lockfiles, snapshots — go on an Allowed generated files: line so a poetry.lock churn doesn't trip the gate:

## Files in scope
- scripts/scope_gate.py
- tests/test_scope_gate.py

Allowed generated files: *.lock

The classifier (check_scope) is a pure function with no git or I/O, so the matching rules are unit-tested independently of any repo; worktree_changes and enforce_scope layer the git read on top. When a spec declares no scope at all, the gate stays inactive rather than blocking everything — it enforces intent, it doesn't invent it.

The premise is economic: frontier models are becoming metered utilities. The operator skill that matters is knowing which tasks actually deserve frontier pricing — and routing everything else to models that are already good enough, whether that's a cheaper API tier, a Mac Mini on your desk, or an H100 node you own. The Savings page sketches how large that gap can be — please consider donating to help support this project.

The repo ships the whole loop, not just the doctrine: per-platform instruction files (Claude Code, Grok Build, NVIDIA NIM/Nemotron, local models, plain chat UIs), a scaffolder (anchor <project-dir>) that drops the right doctrine into any project, fleet scripts for routing/orchestration/benchmarking, and MCP servers so a frontier agent can delegate keystrokes to your local fleet instead of burning credits on them.

Model quirks — Gemma's missing system role, Qwen3's thinking toggle, DeepSeek-R1's no-system-prompt rule, repetition loops under greedy decoding — live in one place (anchor_client.py), keyed by each endpoint's quirks: block, so every caller stays model-agnostic.

Start with the doctrine, then the playbook for the economics, then run ./config.sh and scaffold your first project. If Anchor is already saving you real money, please consider a donation — see also Savings.

Plans you can run​

Scaffolded projects get a git-tracked .plans/ tree. Path is the status: ready work lives in bugs/ or features/; agents claim into in-progress/, park half-baked or stuck work, and archive to completed/. Drafts stay under drafts/ until you promote them.

Use /draft to write, list, load, or promote a plan (optional --local for *.local.md). Use /work to execute the next fit ready plan — Preferred models and Depends on are honored so the wrong tier does not burn credits on the wrong job.

Fleet without a central assigner​

scripts/work_once.py is the headless companion to /work: claim with a lease, respect fit and dependencies, exit idle when the queue is empty. /fleet-watch (and scripts/fleet_watch.py) turns that into reboot-persistent multi-tier timers so mid, small, and reasoner workers each pull only what they should.

Docs live under Tooling → Fleet workers and Skills → /work, /draft, /fleet-watch.

See the savings​

The new Savings page sketches how the orchestrator pattern cuts API spend over a first year of adoption (with a realistic Q1 ramp), and when solar might help power always-on local boxes. Numbers are illustrative worksheets — plug in your own tokens and rates. Those savings can be significant; please consider donating to help support this project.

Try it​

./config.sh --platform claude,grok --fleet --orchestrator claude:opus
anchor /path/to/your-app
# then in the agent: /draft …  → promote when ready → /work
# durable pullers: /fleet-watch

Doctrine and platforms still apply: verify with tooling, escalate after two failures, and keep public docs about shipped behavior — not the private plan backlog.

Until now, the orchestrator pattern assumed you would park plans somewhere and remember which model should run them. Anchor makes that explicit: scaffold installs a .plans/ tree (bugs/, features/, in-progress/, ambiguous/, blocked/, drafts/, completed/) plus a process contract in .plans/README.md. Plans are markdown; the tree is git-tracked. Private experiments use <slug>.local.md.

/work is the shared entrypoint (Claude: .claude/commands/work.md; Grok: .grok/skills/work/SKILL.md). Bare /work resumes own in-progress/, then picks the highest-priority model-fit ready plan whose Depends on are met. Flags: /work --list, /work --no-fit-check, /work <slug>. For always-on pullers, /fleet-watch installs reboot-persistent timers.

Fit and dependencies are intentional economics. Headers carry Preferred models and Depends on (other plan slugs, or none). Expensive tiers skip cheap work; small models skip architecture; nobody starts a plan while a dependency is still open. Set a Preferred orchestrator per project; if unset, frontier/near-frontier may act as temporary coordinator.

Promotion is human-only (drafts/ → ready). Agents claim ready → in-progress/, finish → completed/, and may park half-baked or stuck work in ambiguous/ / blocked/. Headless: work_once.py or orchestrate.py --plan-file (refuses non-executable lanes). Optional: python scripts/check_plans.py.

Start from Skills → /work and Tooling → Fleet workers.