The example at a glance

Illustrative example

One Slice, from signal to outcome

Acme Notes users say their drafts vanish when a browser tab closes. Follow one Slice through every stage: from their posts, to a checked change, to a measured drop in support tickets.

Each stage below shows its part of the example beside the real mechanism, in a dashed frame like this one.

Illustrative example. Acme Notes, a fictional app: Signals: 7 cited posts from 3 sources: drafts vanish when a tab closes Then Decision: Admitted by rule, within the objective 'Reduce support load' Then Slice ACME-12: Frozen: scope, checks, allowance, and the outcome, 41 to 20 tickets Then Candidate 1: Verdict: Failed. Saving no longer cleared the draft. Then Candidate 2: Verdict: Verified. The old code fails the new check, as it should. Then Receipt: main moved once, to Candidate 2 Then Release: You approved alpha, then everyone Then Assessment: Supported: 17 tickets in 28 days, guardrails held Each record pins the one before it by its digest.

The words

Factory uses a few words the same way everywhere, capitalised. In plain terms:

Signal
Something customers or public sources said that may point to work, kept with its exact quote and source.
Slice
The smallest useful change, frozen with its scope, its checks, its allowance and how its outcome will be measured.
Allowance
What one Slice may use (build attempts, check runs, branch moves and time), fixed when it is frozen.
Candidate
Proposed edits sealed as an exact commit, so that any later change to them is detected.
Evidence
What a check actually observed, recorded and pinned to the exact Candidate it ran on.
Verdict
The judgement of a Candidate's Evidence: Verified, Failed or Inconclusive. Only Verified moves on.
Assurance
The part that gives Verdicts and never takes the builder's word. Repository Assurance judges changes to a product's code.
Product gate
One record per product holding your grants and a stop switch. It admits each build, check and branch move only within them.
Receipt
Confirmation of what an action actually did, such as a branch moving once.
Assessment
After release, what happened compared with the promised outcome: Supported, Rejected or Inconclusive.
Run, Attempt and Budget
A Run is one recorded piece of work. Each Attempt at it has one owner and a private workspace, and its Budget of Attempts and time is fixed at the start and never extended.
Capability
An ability a product keeps, with an owner and checks that can be run.

Stage 1 of 9

Discover

In development

Factory reads each product's public sources on a schedule: issue trackers, forums, reviews and changelogs. Plain code fetches, de-duplicates and keeps an exact quote and hash of each item; a small, fast model sorts new items into Signals, such as a customer problem, a request or a competitor move. Failures that a product's own services report, such as crashes and slow requests, arrive as Signals too.

Gate
Every source reports its coverage, and every new item is sorted or marked unsorted. Research is never treated as a customer interview.
Evidence it leaves
Cited quotes with their hashes, and a coverage record for each source.
  • Find customer problems in public sources

    In development

    Still missing: Two parts are built and each passed independent review, tried only on test data: the schedule, which names each nightly and weekly pass once and holds its weekly token allowance, and the reader, which fetches only the public pages you commission and keeps exact quotes with their hashes. Research jobs join attributed collection through an explicit caller contract. Live scheduling, semantic triage and synthesis remain unqualified, and the detailed admission policy still awaits your decisions (P-C20 in the project intent).

  • Take in service failures as Signals

    In development

    Still missing: The intake passed independent review on test data. No live service is connected, and each will need a token you provide; Intake and Repair have bounded local evidence, but real service feedback and production recovery remain unqualified.

Illustrative example

Seven posts, one problem

'Lost my meeting notes when the tab reloaded.'

Sources
The issue tracker, the forum and app reviews
Signals
7 in 3 weeks, each with its quote and hash
Sorted as
One problem: a draft is lost when a tab closes

Stage 2 of 9

Decide

Planned

Once a week a larger model turns the strongest clusters of Signals into a few proposals. Rules decide first, at no model cost: is the evidence real, recent and from customers, can the outcome be measured, is there capacity, and does it stay within your authority? A second model may challenge a proposal, but it can only lower it, never approve it.

Gate
Each proposal gets one recorded decision (admitted, parked or rejected) naming the rule or answer behind it. Anything that would widen authority goes to you.
Evidence it leaves
The decision, the rule behind it and the Signals it cites.

Illustrative example

Admitted by rule

Proposal
Keep unsaved drafts across a closed tab
Evidence
Passes: 7 Signals from 3 sources, 5 of them from customers, the newest 2 days old
Measurable
Passes: support tickets are already tagged
Authority
Passes: within the objective 'Reduce support load'
Decision
Admitted. You were not asked, because nothing here widens authority.

Stage 3 of 9

Slice

In development

Planning freezes the smallest useful change as a Slice: the need, what is in and out of scope, the acceptance checks, the allowance of runs and time, and how the outcome will be measured. All of it is fixed before any code is written.

Gate
The Product gate records the frozen Slice under a live grant from you. Nothing later can widen its scope or lower its acceptance.
Evidence it leaves
A frozen Slice record, written once, with the digests of its inputs.
  • Admit delivery work only within your grants

    In development

    Still missing: The Product gate passed bounded local qualification with Delivery, Implementation and Verification. External Workflow adoption and live Product delivery remain open.

  • Plan from each product's saved values

    In development

    Still missing: The bounded local workflow pins owner Guidance before selecting a plan, and a selected plan generation can become a work brief. Automatic planning and implementation for a commissioned real Product remain unqualified.

Illustrative example

Slice ACME-12, frozen

Need
Drafts vanish when a tab closes
In scope
The editor's draft store and its tests
Not in scope
Syncing drafts across devices
Acceptance
A closed tab's draft comes back; saving still clears it; the existing suite passes
Allowance
2 build attempts, 3 check runs, 1 branch move, 2 hours
Outcome
'Lost draft' tickets per 28 days, from 41 to 20 or fewer

Stage 4 of 9

Build

In development

A producer asks one model, once, for small text-file edits within the Slice's scope, with every tool switched off. The answer is only a proposal: Repository seals it as a Candidate, an exact commit and manifest that cannot change afterwards without being detected.

Gate
The proposal must parse within fixed limits, or nothing is sealed. A Candidate that changes anything outside the Slice's frozen paths can never be integrated.
Evidence it leaves
The sealed Candidate: its manifest and its exact bytes.
  • Ask a model for a bounded proposal, through your subscription

    In development

    Still missing: No model route is qualified, so nothing is proposed yet. By the owner's decision of 1 October 2026 the Claude command line stays unavailable for Factory's model roles, and live qualification of the ChatGPT sign-in route through Codex remains open.

  • Seal a proposed change as an exact Candidate

    In development

    Still missing: Repository sealing is exercised by the local synthetic Delivery and Implementation composition. No real Product's code is qualified by that proof.

Illustrative example

Candidate 1, sealed

Proposal
3 edits to 2 files, from one model exchange
Scope
Passes: both files are inside the Slice
Candidate
Sealed as an exact commit and manifest

Stage 5 of 9

Verify

In development

The Slice's frozen checks run against the unchanged code and the Candidate, each once, in a macOS sandbox with no network and nothing writable. What the host observed is stored as Evidence, and Assurance judges it and gives a Verdict: Verified, Failed or Inconclusive. The builder's own claims carry no authority.

Gate
Only Verified moves on. A timeout, a missing record or anything unclear never counts as a pass: the Verdict is Failed if any required check failed, and otherwise Inconclusive.
Evidence it leaves
One Evidence record per check run, and the Verdict with its pins.

Illustrative example

Failed, then Verified

Candidate 1
The draft comes back, but saving no longer clears it. Verdict: Failed.
Repair
A second attempt, within the Slice's allowance
Candidate 2
Every check passes, and the old code fails the new restore check, as it should. Verdict: Verified.

Stage 6 of 9

Integrate

In development

The Product gate works the Verdict out again, inside its decision, and confirms the Candidate stays within the Slice. Then the target branch moves from the Candidate's base to its commit, at most once. If Factory cannot tell whether the move happened, it says unknown and blocks every later move until that is settled.

Gate
A Verified Verdict re-derived at the moment of the move, a live grant, and no unknown move outstanding for the product.
Evidence it leaves
A Receipt for the confirmed move.
  • Move a branch at most once, and say unknown when unsure

    In development

    Still missing: Accepted for fresh local repositories. The independently qualified bounded local flow joins it to the Product gate with retained dispatch identity and a final authority guard. Commissioned real-Product delivery remains open; it contacts no remote.

  • Deliver one useful change, end to end

    In development

    Still missing: The joined flow and command line passed independent bounded local qualification. Complete Workflow adoption and one useful change delivered to a commissioned real Product remain open; see current local evidence (JSON).

Illustrative example

One move, one Receipt

Checked again
Verdict re-derived; scope unchanged; no unknown move pending
Move
main, from the base to Candidate 2, once
Receipt
Recorded. Nothing is released yet: a merge is not a release.

Stage 7 of 9

Release

Planned

Factory drafts release notes and launch copy, rendering every claim from a checked fact. Anything outward-facing (publishing, releasing, contacting customers, spending or changing live traffic) waits for your approval of that exact action. Potentially unsafe changes reach an alpha channel before everyone.

Gate
Your approval of the exact draft and action. Availability is claimed only after the channel's Receipt and a check from the customer's side.
Evidence it leaves
The approved draft's digest, the channel's Receipt and the availability check.

Illustrative example

Your approval, per action

Draft
'Drafts now survive a closed tab.'
You approved
The alpha channel first, then everyone a week later
Available
Confirmed by the channel's Receipt and a check from a customer's side

Stage 8 of 9

Measure

Planned

The measurement was fixed before release: baseline, target, window and guardrails. When the window closes, an Assessment compares what happened with the intended outcome and concludes Supported, Rejected or Inconclusive. Only Supported counts as value; a rejected change closes as learning, never as a win.

Gate
Assurance independently checks the instrumentation and how the decision rule was applied.
Evidence it leaves
The Assessment, with the frozen contract and the observations it rests on.

Illustrative example

Supported

Baseline
41 'lost draft' tickets in 28 days
After
17 in the 28 days after release
Target
20 or fewer: met
Guardrails
Held: editor errors and load time unchanged
Assessment
Supported
Model cost
— not recorded by the provider

Had the target been missed, the Assessment would say Rejected, and the Slice would close as learning, not as a win. The unrecorded cost stays a dash with its reason, never 0.

Stage 9 of 9

Keep, renew or retire

Planned

The improvement becomes a Capability with an owner and executable checks. Factory keeps it while it serves customers, renews it when Evidence shows friction, and retires it deliberately, with migration and notice, when its benefit no longer justifies its cost. If a later clean-up breaks it, Factory restores it.

Gate
Retirement needs evidence beyond low usage, and your decision whenever customers would notice.
Evidence it leaves
Capability records: required, retiring or retired, and healthy, degraded or unknown.

Illustrative example

A Capability to keep

Capability
Draft recovery, with its checks
Disposition
Required
Health
Watched from now on; a clean-up that breaks it is restored

What customers say next becomes new Signals, and the lifecycle starts again.

Explore the implementation

Factory is one Node.js application made of small modules over local SQLite and Git. The latest joint qualification covers 36 installed module families; their individual contracts retain the limits of that proof. Some serve every stage rather than one.

Underneath every stage

  • Record every decision once

    Working today · verified

    Scope: One local SQLite file on one Mac, crash-tested by killing processes; power loss is not tested. Anything a caller does outside the journal can still happen twice.

  • Recover from a controller crash within Budget

    Working today · verified

    Scope: The built-in fixtures on one Mac. Recovery happens when someone runs verify or recover, never in the background.

  • See each product's sourced progress, with unknown shown as unknown

    Working today · verified

    Scope: Six local products, registered for read-only metadata inspection. Facts arrive by trusted local import, the dashboard answers only on this Mac, and customer value always shows as unknown.

  • Keep each product's core values as exact revisions

    Working today · verified

    Scope: Edited in the local dashboard and pinned by owner-selected planning in the bounded local workflow. Values grant no permission; automatic live planning remains unqualified.

  • One list of what needs attention, from sources only

    Working today · verified

    Scope: A blocker resolves only when its source reports it; Factory does not re-check the prerequisite itself.

  • Use a model only where it is needed

    In development

    Still missing: No model is qualified, so every model task refuses today, and nothing dispatches. The priority lists are merged after independent review; acceptance is not claimed.

  • A short digest of what needs you, with its sources

    In development

    Still missing: Each part passed independent review on recorded and test data only. Nothing reads GitHub live, runs on a schedule or sends an update, and no real ask is recorded yet: live polling waits for your commission.

  • Plan dates, capacity and timing without inventing certainty

    In development

    Still missing: Three evaluators passed independent review and were accepted locally on 1 October 2026; each answers only for the data it is given. Nothing stores a plan, proposes a date, reserves capacity or starts work.

  • Use Factory's parts in another system

    In development

    Still missing: The packaging work merged into the main branch on 1 October 2026 after review, and its 24 module families were accepted locally that day, each with a receipt. No package is published. The 4 October independent qualification covers 36 installed families, individually callable stages and two full workflow rehearsals. Complete Workflow adoption, live providers and customer delivery remain separate; see current local evidence (JSON).

The Plumb family

  • A wide blue bob, round spectacles and a ribbon-bound ledger.

    Command journal
    The archivist

  • An indigo bob with curious eyes and a labelled specimen.

    Evidence / Assurance
    The curator

  • A slender blue bob passing a violet relay baton.

    Execution
    The conductor

  • A squat teal bob with a compact toolbox.

    Local fixture worker
    The tinkerer

  • A broad blue bob behind a single-latch gate.

    Attempt fence / workspace
    The gatekeeper

  • A periwinkle bob with a loupe and folded report.

    Guarded verification / recovery
    The double-checker

  • A stout blue bob carrying a gear under glass.

    Confined executor
    The experimenter

  • An indigo bob carrying a tied, sealed parcel.

    Repository
    The packer

  • A teal bob with spectacles and tabbed index cards.

    Portfolio
    The organiser

  • A wide-eyed blue bob holding a three-pane window.

    Dashboard
    The host

  • A slender violet bob with a map and compass.

    Project guidance
    The navigator

  • A small azure bob raising a single bookmark.

    Required actions and blockers
    The spotter

  • A playful violet bob with a pencil and blank sketchbook.

    Producers
    The sketcher

  • An indigo bob inspecting a parcel through a lens.

    Repository Assurance
    The examiner

  • A broad teal bob beside a ticketed turnstile.

    Product gate and delivery records
    The steward

  • A periwinkle bob carrying sample jars on a tray.

    Repository collector
    The field collector

  • A tall violet bob comparing cards with a tuning fork.

    Intelligence
    The matcher

  • A round teal bob with a numberless clock.

    Lifecycle schedule
    The timekeeper

  • A curious azure bob with a small telescope.

    Discovery sources
    The explorer

  • A slate-blue bob carrying two distinct keys.

    Service access
    The custodian

  • A slim teal bob studying a potted sapling with one branch.

    Branch health
    The gardener

  • A compact periwinkle bob holding out a folded letter.

    Owner digest
    The correspondent

  • A slate-blue bob with spectacles, a blank notebook and a pencil.

    Owner policy
    The clerk

  • A tall indigo bob holding up a small hourglass.

    Temporal Planning
    The almanac keeper

  • A wide teal bob carrying three nesting measuring cups.

    Capacity planning
    The quartermaster

  • A slender violet bob steadying a swinging metronome.

    Material timing
    The stage manager

  • A round azure bob listening through an ear trumpet.

    Operational signals
    The listener

  • A compact blue bob ringing a small hand bell.

    Provider events
    The herald

  • A stout periwinkle bob beside a small closed letterbox.

    Provider subscriptions
    The postmaster

  • An upright indigo bob holding up a blank luggage tag.

    Proposal ownership
    The tag keeper

  • A broad teal bob holding a woven tray with one folded sheet.

    Guidance acceptance
    The receiver

  • A slim azure bob wearing a simple headset.

    Provider Events RPC
    The operator

  • A squat violet bob checking an edge with a set square.

    Provider Guidance tools
    The fitter

  • A sturdy teal bob holding a sealed clipboard beside a small safety cone.

    Prevention register
    The safety warden

  • A teal bob with a small megaphone, checking an index card of facts.

    Marketing Workflow
    The careful crier