OpenSpec-native change harness

Prove the change.
Skip the ceremony.

A lean control plane for brownfield software work. OpenSpec holds the agreement. Your native coding agent builds it. Deterministic providers prove every observable claim.

Install the harness → See the loop ↓
  • No lifecycle-agent relay
  • No task-size quality downgrade
  • No implicit commit or push
A content-bound run
profile-auth · sandbox API 35
❯ claude-foundation advance profile-auth --through proven

plan 4 capabilities · 3 executions

reuse static-analysis receipt 19d8…

run test + discovery one process

run browser chromium · 2 claims

proof workspace 7f31… PASS

reusable receipt unique execution hash-bound proof
8agent slash commands
5executable adapter types
19evidence capabilities
1task ledger: tasks.md

The harness, rebuilt

Quality was already high.
The control plane was too expensive.

Long phase chains and lifecycle personas made orchestration dominate latency and token cost. Change Loop keeps judgment in one short loop and moves repeatable work into deterministic execution.

Rigor scales with risk and evidence—not with a task-size phase matrix.

01

One native owner

The coding agent reads a compact change packet and owns implementation. No relay race between PM, lead, engineer, QA, and retro personas.

02

Executable evidence

Claims select provider capabilities. Provider contracts run project-owned tools and produce receipts the runtime can validate.

03

Reuse before rerun

Receipts bind to code, agreement, claims, configuration, environment, protocol, and artifacts. Unchanged proof work is reused.

04

Transactional finish

Land checks proof freshness, applies only the proven sandbox, verifies identity, syncs specs, archives, and safely cleans up. An interrupted or multi-repository Land resumes from its journal.

The change loop

Move backward when reality changes.
Move forward only with evidence.

Not a waterfall. Investigation is optional; Land is the explicit completion boundary.

Requirements changed? Change ⇄ Build ⇄ Prove Revise the same change. Sync. Invalidate stale proof.
Outside the loop /changes · /dev /changes lists active work. /dev composes the same workflow. The agent drives one advance coordinator; users never assemble the internal CLI chain.

Evidence, not confidence

A passing command is not automatically proof.

Every observable acceptance scenario receives a stable claim ID. Each claim requires the capabilities that can actually demonstrate it. Missing, stale, failed, erroneous, or inconclusive evidence blocks landing.

The behavioral contract and ordinary derived wiring live in evidence.yaml. Conditional execution.yaml overrides custom commands, reports, services, or readiness—invalidating only the provider fingerprints it touches.

ONE PROVIDER · ONE COMMAND

command

Run one deterministic project command for one evidence capability.

// execution.yaml
"static-analysis": {
  "adapter": "command",
  "command": ["npm", "run", "check"],
  "timeoutMs": 120000
}

Capability catalog

Select what the claim needs—never the full catalog by default.

testdiscoverybrowsermutation state-identityintegrationcompatibilityperformance security-staticcross-repo-contractreviewacceptance static-analysisdata-migrationaccessibilityresilience observabilitydeploymentdependency-supply-chain

Less waiting, less paying

The scheduler spends work once.

Providers run from one canonical proof decision. Independent readers can execute together; conflicting resources serialize; identical commands deduplicate.

0s4s8s12s
static reused
test + discovery one process
browser 2 claims
mutation workspace-write
↻

Persistent reuse

Valid receipts survive across proof attempts while all bound inputs remain identical.

≡

In-flight dedup

Same command, arguments, environment, working directory, timeout, and readiness run once.

⇉

Resource-aware parallelism

Read-only work overlaps safely. Browser, server, database, and workspace writes remain exclusive.

⌁

Measured cost

Wall time, unique executions, requests, tokens, cache, cost, and orchestrator share stay inspectable.

Committed execution policy

Spend judgment where the risk lives.

foundation.json makes model routing, budgets, escalation, and review policy visible in the repository. Portable tiers describe the work; the native host selects the configured model family.

Configure the policy →
03 parallel agents max 45m workspace lease 16K global packet ceiling
FASThaiku

Scan the ground.

Inventory, logs, and mechanical documentation.

fallback → standard
STANDARDsonnet

Build the change.

Implementation, tests, and focused investigation.

fallback → deep
DEEPopus

Resolve the risk.

Architecture, security, migration, and independent review.

no lower-confidence exit

Explicit review policy

Start with one model. Tighten when needed.

The shipped self + single-model policy works with Claude alone. Projects that need separation of duties can require an independent identity, another provider, or both.

BUILDnative agent → FULL REVIEWClaude Opus · fresh session → DELTAfresh session · when required

Clear ownership

Three layers. No duplicated truth.

The AI decides what requires judgment. The harness executes what should be deterministic.

01 · AGREEMENT

OpenSpec

Proposal, delta specs, design, tasks, claims, and provider contracts.

openspec/changes/<id>/
02 · IMPLEMENTATION

Native coding agent

Reads a bounded packet, edits the sandbox, and updates one task ledger.

.foundation/sandboxes/<id>
03 · VERIFICATION

Change Loop runtime

Hashes, schedules, validates receipts, finalizes proof, and guards landing.

.foundation/receipts/<id>/

How the agent knows

Instructions route. Commands specify. Runtime enforces.

CLAUDE.mdloads orchestrator.mdroutes commands/*.mdcalls claude-foundationruns foundation.mjscomposes runtime/

Readable state

Resume from files, not conversation history.

The compact packet carries only what the next step consumes. Durable intent stays in OpenSpec; machine lifecycle, receipts, logs, metrics, and sandboxes stay under .foundation/. 

openspec/changes/profile-auth/
├── proposal.md
├── tasks.md          # sole task ledger
├── evidence.yaml     # stable claims + capabilities
├── specs/            # standard lane
├── design.md         # conditional context
├── grounding.yaml    # conditional decisions
├── execution.yaml    # conditional custom wiring
├── repositories.yaml # conditional multi-repo scope
└── handoffs.yaml      # conditional external work

.foundation/
├── runtime/          # lifecycle + resolver
├── receipts/         # content-bound evidence
├── authority/        # review + acceptance requests
├── transactions/     # recoverable Land journals
├── logs/             # provider output + events
├── recovery/         # abandoned change records
└── sandboxes/        # isolated worktrees

The compiled OpenSpec packet is the source of truth. Semantic drafts and runtime actions are inputs and projections, not parallel requirement ledgers.

Install once per project

Bring the loop into an existing repository.

Change Loop-managed workflow files refresh on update. Project-owned specs, active changes, dependencies, and runtime state stay yours.

brew tap maximumsoft-co-ltd/claude-foundation \
  https://github.com/Maximumsoft-Co-LTD/claude-foundation
brew install claude-foundation
claude-foundation init /path/to/project --yes
  1. 1
    Check readinessclaude-foundation doctor --stage change
  2. 2
    Define the change/change add profile authentication
  3. 3
    Build and prove/build profile-auth → /prove profile-auth
  4. 4
    Accept explicitly/land profile-auth
REQ
Before you install.

Node.js 20.19 or later, Git for worktree isolation, jq for the Claude settings merge, and the OpenSpec CLI for spec synchronization and archive: npm install -g @fission-ai/openspec@1.7.0. Open a new agent session in the target project afterwards so the slash commands register.

HOST
More hosts than Claude Code.

claude-foundation init --host cursor|opencode|codex layers a host adapter over the same install: Cursor gets the commands and an always-on rule, OpenCode gets the commands plus a plugin that replays the live guards, and Codex gets the prompts with Land gates as the enforcement. Worktree sandboxes can also install their own dependencies via sandbox.setupCommand in foundation.json.

PW
Browser proof stays project-owned.

Install and lock @playwright/test and browser binaries in the application. Change Loop validates and executes the local tool; it never downloads an unpinned browser framework during proof.

Operator surface

One coordinator for the loop. Primitives when you need them.

change start <draft.json>compile one semantic brief into a valid OpenSpec change
change amend <id> <amendment.json>apply a linked semantic amendment transactionally
advance <id> --through build|proven|archivedrun the safe lifecycle chain and stop only at a real boundary
doctor --change <id>check runtime, provider, and lifecycle readiness
changeslist active work and the next useful action for each
packet <id>compact handoff without replaying history
evidence detect <id>find project-owned providers without executing them
proof readiness <id>see typed blockers and canonical next actions
proof run <id>advanced primitive: run the proof phase only
authority request <id>open a resumable human review or acceptance
evidence verify-ci <id>verify signed CI provenance bound to the workspace
metrics <id>inspect latency, execution, token, and cost data
land check <id>verify the completion boundary
land archive <id>apply, verify, sync, archive, clean up
land resume <id>resume an interrupted or multi-repository Land
change waive <id> --capability <c>withdraw one failed gate's enforcement on a recorded decision
change abandon <id>quarantine a change that cannot be proven
describe [command]explain the six intent commands and every advanced primitive

Brownfield changes, without blind spots

Keep the quality.
Cut the orchestration.

One agreement, one implementation owner, executable evidence, and an explicit landing boundary.

View source ↗ Read the docs →