Milestone 01

THE FIRST PUBLIC PROOF POINT

Both passed the tests.
Only one ran the engineering process for you.

We gave the same public issue and baseline to the same primary implementer and reviewer models. Selvage and a carefully constructed manual workflow both reached a verified, reviewed, built, documented, locally merged endpoint. The difference was who had to operate the system.

THE RESULT Same primary models. Comparable model cost. Far less orchestration risk.
Hidden evaluator
7/7 both arms
Independent review
Approve both arms
Provider cost
$1.7371 / $1.7405 effectively tied
Human workflow
1 command / manual protocol

A single controlled engineering experiment—not an official SWE-bench result, not a claim of universal code superiority, and not evidence of lower total token use.

AT A GLANCE

Without Selvage / with Selvage

Both routes passed. The difference is who ran the engineering process around the models.

At-a-glance comparison of manual orchestration without Selvage and automated orchestration with Selvage
Engineering responsibilityWithout Selvage Arm CWith Selvage Arm B
Final acceptance and review7/7 + approve7/7 + approve
Start from the public issueHuman builds protocolslv run 1
Run checks and route recoveryHuman coordinatesAutomatic
Launch fresh independent reviewHuman promptsAutomatic
Interpret verdict and choose next stepHuman decidesPolicy-routed
Capture evidence and usageHuman assemblesAutomatic
Merge the approved local resultHuman fast-forwardsAutomatic

means human-operated in Arm C, not impossible. The manual arm completed every step.

WHAT WE TESTED

Two routes to the same engineering endpoint.

The task added configurable think/eat timing and bounded shared byte accounting to a small Python Dining Philosophers project. Both arms started at commit 408fa95 and were judged by the same evaluator, frozen before either final run.

ARM BSELVAGE

Autonomous orchestration

slv run 1

From that invocation, Selvage coordinated implementation, four verification/recovery cycles in one continued Sonnet session, a fresh Opus review, evidence capture, and a local auto-merge.

  • Official Selvage v0.2.32
  • Sonnet 5 implementer
  • Fresh Opus 5 reviewer
  • Automatic audit artifacts
ARM CMANUAL ENDPOINT PARITY

Human-operated orchestration

human builds the protocol

A human constructed and coordinated the implementation prompt, project verification, independent reviewer prompt, verdict interpretation, hidden evaluation, artifact aggregation, and local fast-forward merge.

  • Sonnet 5 implementer
  • Fresh Opus 5 reviewer
  • No human code edits
  • Manually assembled evidence
Why Arm C matters: it demonstrates that endpoint parity is possible without Selvage. It also makes the missing layer visible: the human becomes the workflow engine.

WORKFLOW COMPARISON

The models did comparable jobs.
The orchestration did not.

The top lane is the path initiated by slv run 1. The lower lane shows the human coordination required to construct an endpoint-equivalent manual run.

Arm B and Arm C engineering workflow comparison Arm B flows from issue through Sonnet, automatic verification and recovery, fresh Opus review, and automatic local merge under Selvage. Arm C requires a human to set up the run, prompt Sonnet, verify, prompt Opus, interpret the verdict, run the hidden evaluator, merge, and assemble the report. ARM B · SELVAGE one human action starts the complete loop Issue #1 slv run 1 Sonnet 5 implement Verify + recover 4 cycles · same session scheduler-owned evidence Fresh Opus 5 independent review Local merge automatic + recorded ARM C · MANUAL PARITY human coordination connects every model and tool boundary Set up clone + prompt Sonnet 5 implement Verify human runs checks Prompt Opus fresh reviewer read-only Interpret human reads verdict decides next step Evaluate hidden suite capture artifacts Merge human fast-forward assemble report Cyan = Selvage-controlled transition · Amber = human-controlled handoff
Arm C needed no human code edits and no revision prompt. It still required the human to construct and operate the delivery protocol around the models.

PROVIDER-REPORTED COST

The totals tied.
The work moved to different places.

Provider-reported cost is the canonical measure here. Arm B spent more on iterative Sonnet implementation and recovery; Arm C spent far more on its long, manually prompted Opus review. Support-model calls in Arm C are grouped with the phase they supported.

Provider-reported model cost allocation for Arm B and Arm C Arm B cost 1.7371 dollars: 1.3805 dollars for Sonnet implementation and recovery, and 0.3566 dollars for Opus review. Arm C cost 1.7405 dollars: 0.5423 dollars for implementation and support, and 1.1982 dollars for review and support. The total difference was 0.0034 dollars. COST BY PHASE · USD ARM B Selvage SONNET · $1.3805 implementation + recovery OPUS $0.3566 $1.7371 ARM C manual parity IMPLEMENT $0.5423 OPUS REVIEW · $1.1982 review + support $1.7405 implementation / recovery independent review TOTAL DIFFERENCE · $0.0034
Effectively the same provider cost. The result does not support a claim that Selvage was cheaper in this run.
Primary-model output47,182Arm B
Primary-model output43,235Arm C
Opus output6,740Arm B
Opus output24,161Arm C

Arm B did not use fewer total raw tokens: it also recorded 3,293,377 cache-read tokens versus 1,466,574 for Arm C. Its measurable gain was automated coordination, with much less expensive reviewer output, at essentially the same total provider cost.

ENDPOINT EVIDENCE

Both reached the bar.
Only one owned the path.

Comparison of final outcomes for Selvage Arm B and manual endpoint parity Arm C
MeasureArm B · SelvageArm C · Manual parity
Frozen hidden evaluator7/7 passed7/7 passed
Final project suite13/13 passed19/19 passed
Package buildPassedPassed
DocumentationUpdatedUpdated
Independent reviewFresh Opus · approveFresh Opus · approve
Provider-reported cost$1.7371$1.7405
Elapsed time9m 24s pipeline12m 21s wall time
Merge endpointAutomatic local mergeManual local fast-forward
Human orchestrationslv run 1Full manual protocol
Audit artifactsGenerated automaticallyAssembled manually

The project-suite counts are not a quality ranking: each implementation added a different number of regression tests. Reviewer finding counts are omitted because Arm C’s review prompt was deliberately more exhaustive, making raw counts non-comparable.

THE CLAIM BOUNDARY

What this proves—and what it does not.

SUPPORTED BY THIS RUN

Selvage can own the engineering loop.

  • One command initiated issue-to-implementation-to-verification-to-review-to-local-merge execution.
  • Verification failure and recovery stayed inside the same continued implementer session.
  • A fresh reviewer judged the diff after scheduler-run checks had produced evidence.
  • The workflow automatically preserved a repeatable audit trail.
  • Manual endpoint parity was possible, but the human had to become the workflow engine.
NOT ESTABLISHED

This is not a universal model-quality claim.

  • It does not show that Selvage always writes better code.
  • It does not show fewer total tokens or lower provider cost.
  • It does not show that manual orchestration failed; Arm C passed.
  • It is not an official SWE-bench result or an independently standardized score.
  • One task cannot establish statistical superiority across repositories or task types.

A cheap patch is only cheap if you ignore the work required to ship it.

Selvage automates the testing, recovery, verification, review, evidence, and merge workflow that follows the first prompt.

THE PUBLIC JOURNEY

A milestone, not a finish line.

This page is the beginning of a durable evidence trail. Future entries will add repeated runs, stronger controls, and efficiency measurements without rewriting what earlier milestones actually proved.

  1. 01
    ACHIEVED

    Autonomous engineering loop proven

    From a public issue to verified, independently reviewed, documented, built, locally merged code—initiated with slv run 1.

  2. 02
    Next studyPLANNED

    Context efficiency

    Measure AST/Tree-sitter context selection and context compaction against the same outcome bar.

  3. 03
    Future studyPLANNED

    Verification efficiency

    Test verification deduplication and evidence reuse while preserving or strengthening coverage.

  4. 04
    Future studyPLANNED

    Repeated public benchmarks

    Repeat controlled comparisons across task shapes and repositories, publishing failures as well as wins.

  5. 05
    Future studyPLANNED

    Preregistered external rubric

    Define scoring and acceptance criteria before execution and seek independent evaluation.

Planned items are research directions, not shipped product claims or release commitments.

REPRODUCIBILITY & DISCLOSURE

The exact substrate behind the claim.

Public repository
venkatq3/dining-philosophers
Public task
Issue #1
Baseline commit
408fa9517c0
Runtime
Python 3.12.12
Selvage release
v0.2.32 · ebee2f2e0b69
Arm B invocation
slv run 1
Arm B task ID
4debfc65-e67c-46bd-8592-de4ed62c28c1
Evaluator status
Frozen before final Arm B/C runs
01

Evaluator boundary

The out-of-tree evaluator covered API compatibility, timing, wait reporting, shared byte accounting, partial final meals, repeated concurrent consumption, and deadlock freedom. The baseline passed 1 of 7 tests; both final arms passed 7 of 7.

02

Endpoint boundary

Both experiments ended in a clean local merge. Arm B merged automatically; Arm C was fast-forwarded manually. Neither experiment result was pushed to the public repository.

03

Post-hoc boundary

An additional total_bytes plus default bytes_per_meal case was found after the frozen run. It is not counted among the seven preregistered acceptance checks.

04

Artifact boundary

Provider-reported usage, local reports, review artifacts, and evaluator output were used to prepare this page. Raw private run artifacts are not presented here as independently audited evidence.

MILESTONE 01 · ACHIEVED

The first prompt was not the product.
The completed engineering process was.

Selvage reached autonomous issue-to-verified-review-to-merge execution. The next milestones will test how efficiently, repeatedly, and broadly it can do it.