Formation

Formation studies how a language model that starts each call with no memory of prior work can still become a particular skilled practitioner through later experience. The model weights stay frozen. What must change is the governed system around the model: what experience is kept, what changes are proposed, which changes may affect later action, and how those changes are checked or revoked.

Its working thesis is:

A frozen, intermittently invoked model can develop into a particular practitioner when a governed system converts experience and consequence into durable, selective changes in future behavior that later counterevidence can revise, suspend, or revoke.

Here cold means the model itself carries no project memory between calls. The practitioner is the model plus the developmental system that persists across calls.

Game mastering, coding, writing, research, and operations are useful places to test formation. None of them is the project. They are contact domains where formation can be observed and adjusted.

The question

The ordinary agent loop is good at continuing work:

assemble context -> infer -> act -> observe -> append -> repeat

Appending an observation can change the next answer without earning a change that should transfer to a later, related situation. More context is not the same as development.

Formation adds a second, governed loop:

practice loop:    orient -> decide -> act -> observe consequence
formation loop:   attribute -> propose change -> govern eligibility
                  -> activate selectively -> revise or revoke

A bounded trial may be part of governance. The project does not treat trial as a required stage before every permitted influence.

The central research question is whether an experience can cause a warranted change that improves action in a later, novel, structurally related situation, and stays silent where that structure does not apply.

The system boundary

Formation begins with three distinct roles:

• The cold model supplies inference. It is replaceable and receives no weight updates within the project boundary.
• The formation runtime acts with the model, preserves developmental lineage, and governs changes in the practitioner.
• The trajectory harness creates controlled histories, forks identical starting states, schedules environments and declared consequence oracles, assigns ablations, and captures evidence for prospective scoring.

The separation matters because of a concrete failure mode. If the harness interprets a consequence and quietly hands the correct lesson to the model, the experiment measures oracle assistance rather than formation.

What counts as progress

A formation claim requires more than changed behavior. At minimum, the system must show:

1. Acquisition: consequential experience causes a later behavioral change.
2. Transfer: the change helps on prospective cases that do not permit answer copying or simple episode matching.
3. Selectivity: the change stays silent where its structure does not apply.
4. Revision: later counterevidence can revise, suspend, or revoke an admitted change.
5. Causal contribution: ablation or controlled branching attributes the improvement to the acquired change.
6. Net value: the benefit survives the costs of context, checks, latency, maintenance, and negative transfer.

“Exceptional” is comparative. A formed practitioner must beat the same cold model with static instructions and ordinary persistence on novel work, while remaining governable.

Relationship to Construct

Construct is the immediate experimental ancestor. It produced bounded results on offer quality, consequence-earned authority, cross-session influence, selective eviction and recovery, and governed continuity. Formation accepts those results within their original evidence bounds.

Formation does not inherit Construct's provisional runtime objects or vocabularies as requirements. Those are prior art and candidate instruments. Formation must earn its own objects and mechanisms.

Construct remains the lab that owns its findings and should stay reproducible. New trajectory experiments and formation-runtime code belong here.

Present state

No formation effect has been earned. What exists today is a reviewed account of what the system may do, plus ten small code slices that prove identity and role separation in one deterministic scenario.

The Phase 0 packet — concept, authority, record, evaluation, fixture, and instrument map — defines roles, records, baselines, and refusal outcomes in Markdown. Independent readers from two model families reconstructed one compatible semantic object from that packet. Agreement on meaning closed the semantic gate. It did not select a machine schema or prove any developmental effect.

Markdown serves as a semantic prototype here. It states who may decide what, what must be recorded, what must be refused, and what result would prove the account wrong. Independent readers then reconstruct the implied system without seeing an implementation. Their disagreements expose missing or contradictory rules before code turns those rules into incidental architecture. Code begins only when the fixture needs a machine to compute identity, validation, or an exchange between components.

The current code uses exact bytes where byte equality matters and typed objects where equal-looking data must not be allowed to substitute for its source or authority. Ten fixture-local slices are implemented and tested:

1. Shared acquisition prefix. Every fork starts from the same six developmental records as exact bytes with a content binding. Eleven tests refuse forged handoffs, replacement bytes, mutated sources, altered bindings, and post-binding tampering.
2. Condition append. After the fork, each runtime records only its public formation condition. Hidden branch assignments stay in trajectory evidence. The six-line prefix stays unchanged. Twenty-six tests cover both this slice and the prefix.
3. Admitted roots. On the two treatment branches, a distinct interpreter authors one candidate from retained experience, and a distinct governor admits that exact proposal once within an explicit scope. The harness schedules and witnesses; it does not author or admit. Forty-five tests preserve and revalidate the source-to-admission chain.
4. Replay-constraint append. The ablation branch receives one public constraint bound at the exact admitted head. The slice does not implement constrained replay itself. Sixty-four tests cover the combined boundary.
5. Shared foreground delivery. One protocol source is frozen once, then delivered once to each exact current branch head. The runtime returns the received value; the harness checks it against the same freeze. Eighty tests cover the combined boundary.
6. Positive encounter opening. Each exact received foreground becomes one runtime-authored encounter opened append and one new current root. A sealed binding keeps freeze and comparison-group state unreachable from developmental lineage. Ninety-six tests cover the combined boundary.
7. Positive activation decisions. The baseline applies the public activation policy to an empty eligible set and withholds. Governed activates the exact admission reached through its own encounter lineage and originates one privately held handoff. The ablation root remains excluded until constrained replay can derive its eligible set. One hundred seventeen tests cover the combined boundary.
8. Practice-request construction. Baseline prepares a request with no intervention-shaped field. Governed consumes the exact private activation handoff once and places that object in its request. No prompt format or model invocation is selected. One hundred thirty-six tests cover the combined boundary.
9. Deterministic model invocation. One stateless actor capability receives both exact requests and alone issues their model proposal objects. The runtime records those proposals without committing an action. One hundred fifty tests cover the combined boundary.
10. Positive action commitment. The runtime turns each exact positive proposal into a distinct commitment under its declared policy and returns only a sealed binding for the private environment handoff. It does not apply the action or produce a consequence. One hundred sixty-two tests cover the combined boundary.

These slices establish local identity, authority separation, and provenance checks. They do not establish learning, transfer, governance effectiveness, or any formation claim.

Some later steps are precise enough to describe but have not earned code. Proposal and admission records do not yet need a byte format. Constrained replay must derive its result from the preserved dependency history rather than return a prepared answer for a known target. But one fixed example cannot show whether code performs a general dependency traversal or merely validates that example, so the project has not selected replay code or a replay schema. Likewise, selective activation must carry the exact admitted change into one model request and remain absent from withheld paths. Those same-runtime identity checks still do not require an activation format.

Shared foreground delivery is now implemented. Independent review rejected two green intermediate builds. The first could repeat or alter authority outside one controller. The second delivered the right values to the right roots but did not retain which exact freeze and comparison group had authorized them. The repaired boundary rechecks source, authority, recipient lineage, freeze, group, one-time consumption, and all three returned handoffs. It selects no byte format and does not claim that an encounter opened.

Positive encounter opening is now implemented. Independent review rejected two green builds: one did not make the returned roots current and allowed a second opener to reuse the handoff; the next leaked private foreground provenance through a root verifier and allowed an alternate controller path. The repaired boundary registers one opening authority, keeps the full handoff outside developmental lineage, retires each predecessor at the encounter layer, and returns three exact current encounter roots. A foreground witness is now an input to an encounter append, but neither witness is a model request, action, or evidence of formation.

Positive activation decisions are now implemented for the two roots that can decide from already materialized public state. Baseline records consideration under the same public policy as governed, but over an empty eligible set, and withholds. Governed selects the exact admission and proposal retained by its encounter lineage, records activation, and returns only a sealed binding to a private encounter-local handoff. Independent review rejected a green build that allowed a cached decision input to be replaced by the ablation branch's equal-looking admission. The repaired boundary rechecks the exact condition, admission, and proposal at append time; the combined 117-test suite and independent recheck pass.

Positive practice requests are now implemented for baseline and governed. The baseline request has no intervention-shaped field. The governed request consumes the exact private activation handoff once and retains that object rather than copied admission or candidate fields. Independent review rejected green states that accepted counterfeit verifiers, restored rights by resetting guards, let a fake owner claim the registry, or consumed a handoff outside live request preparation. The repaired boundary and combined 136-test suite pass two final independent rechecks.

Deterministic model invocation now exercises those semantic requests without an LM. The same stateless actor proposes release for baseline and rebuild_then_release for governed from request-visible roles. Only the actor issues proposal capabilities; the runtime records them. Review found and repaired a post-invocation verifier replacement path before the combined 150-test suite and final recheck passed.

The lifecycle boundary remains deliberately split. A model proposal is not a committed action, a committed action is not an environment result, and the fixture actor is not evidence of model learning. Ablation remains blocked on runtime-derived constrained replay.

Positive action commitment is now implemented. The runtime turns each exact actor-issued proposal into a distinct commitment event and a sealed environment binding. Independent review found no blocker, then motivated stronger resistance to combined alias resets and orphaned binding resolution; the repaired 162-test boundary passed a final cold recheck.

The next named semantic need is environment action application. It must consume the exact private handoff and preserve an external result while keeping result, oracle verdict, and formation claim distinct. The environment-application contract now closes that semantic gate. The reviewed 98-case micro-environment now removes its former action-keyed-lookup blocker. Cold code-facing review then licensed a narrow composition that must consume each exact handoff, call the existing engine, and issue only the result returned by that call. Implementation is pending.

That stable result boundary also names the next lifecycle join. The consequence-intake contract distinguishes an environment-originated result from the runtime-recorded consequence observed event. Two final cold reconstructions agree on exact result retention, sole developmental parentage, one-shot delivery, durable audit access, and the absence of interpretation or experience closure. Its code is blocked by the unimplemented environment predecessor.

Positive experience closure then joins the exact encounter-opened and consequence-observed occurrences without a synopsis, lesson, applicability claim, or success label. Cold review restored the omitted activation considered step and the fixture's dual-parent closure shape. Two final reconstructions agree. Code remains transitively blocked with its environment and intake predecessors.

The implemented revision-gated release micro-environment is the first step beyond fixture-only pressure. Its 98 prospective cases require the same release action to succeed or fail from supplied state and require rebuild output to track several authority revisions. Two cold reviews and a code-facing review licensed only this isolated transition engine and its external conformance tests. Independent post-build review rejected incomplete test evidence before the repaired 15-test slice and combined 177-test suite passed final recheck. This does not license environment lifecycle plumbing or a formation claim, and the specimen will not be expanded.

The first cold-model contact charter is now semantically stable. It freezes Composer 2.5, three exploration calls, five unseen SQLite tasks, cold/raw/authored-lesson offers, executable scoring, and a nineteen-call ceiling. Raw persistence is allowed to win; a not-engaged cold model stops the contact.

That contact is now complete and closed not_engaged. Composer 2.5 returned correct executable SQLite queries in all three independent cold exploration calls, so there was no wrong acquisition experience for persistence to repair. The runner correctly sent no lesson and no validation cases. The evidence and plain-language finding passed independent audit. This is a task-selection result, not a formation or transfer result.

A successor Python boundary contact asked how Composer 2.5 resolves ordinary “Python integers” when bool is a subclass of int. The charter allows raw failure persistence and a model-authored lesson to compete on five fresh coding tasks only if exploration engages; otherwise the run stops. Two cold semantic reviews agree on the exact vectors and bounded claim. The restricted runner passed its 10-test slice, the combined 198-test suite, and two independent code reviews.

That contact also closed not_engaged. Each of three cold functions used an exact-type check and passed all 24 frozen inputs, including the held boolean cases. The runner sent no lesson or validation prompt. The evidence and plain-language finding passed independent audit. This is another task-selection result, not evidence of formation or transfer.

Those two stops changed model selection. The next admission exploration starts with local Ministral 3B and Nemotron 4B rather than asking Composer to fail on a harder trick. A model qualifies only if it passes four easy contract anchors, shows a narrow repeatable cold gap, and solves a different instance when the missing rule is stated directly. The exact artifacts, prompts, executable inputs, sampling fields, and 32-call ceiling are frozen. Cold review found and repaired ordinary-SQL weakness leakage, incomplete classifiers, optional vision loading, unfrozen chat templates, and incorrect artifact sizes. Runner implementation then passed its 6-test slice, the combined 205-test suite, and independent review.

The first admission packet stopped both models at its first anchor, but only one stop supports its apparent conclusion. Ministral returned a prohibited Markdown fence and is cleanly contract_unreliable for this packet. Nemotron used the ordinary Python builtin all, which the undisclosed restricted sandbox omitted. Its mechanical failure is instrument-tainted, so Nemotron was unresolved until the corrected successor below. The retained exploratory record passed independent audit as EVIDENCE_PARTIAL. A corrected successor must use new development material and disclose its execution vocabulary.

The corrected Nemotron successor closed its pre-contact review before inference. It retains the same model artifact and settings but uses new prompts and tests. Every restriction that can reject Python is stated in the prompt, including the complete builtin list. Its runner stores full prompt bytes instead of assembling a hidden suffix, labels ordinary and held inputs at authorship, and checks the exact model load and request. Twelve fake-contact tests and the combined 217-test suite pass. Independent review returned RUNNER_LICENSED.

That successor contact also stopped at its first anchor. Nemotron used 702 of the fixed 768 completion tokens for internal reasoning and returned a function cut off at return payload[0] +. The parser rejected the incomplete answer, and the runner sent no later prompt. Independent audit found the retained result valid for the exact frozen setup. This is a clean contract_unreliable stop, not a Formation result. Neither initial local model is admitted; another model or inference setup needs a fresh packet.

The next packet begins at the much smaller end. The Gemma structured-action staircase screens instruction-tuned 270M and 1B checkpoints on four fresh JSON computations. It asks only whether each model can read supplied state, compute a result, and return one exact machine-readable action. Passing would earn a new admission charter, not admission itself. The separate runner passed nine fake-contact tests and the combined 226-test suite, then received RUNNER_LICENSED.

Both Gemma checkpoints stopped at task 1. The 270M model returned fenced Python instead of JSON. The 1B model returned a fenced array, omitted the required object, and selected only one of two records. The retained screen passed independent audit as EVIDENCE_VALID. Neither model earns a full admission charter under the bare text interface. A later packet may separately test a grammar-constrained JSON interface. That could remove fences, but the 1B payload shows it would not by itself supply the missing computed record.

That bounded paired interface trial is now frozen and cold-reviewed. It gives each checkpoint two fresh tasks under both the bare interface and a shape-only JSON grammar, then scores valid structure separately from a correct value. The grammar carries no answer list, length, pattern, or numeric bound. The protocol received INTERFACE_PROTOCOL_STABLE; no model call is licensed until its separate runner passes fake-contact tests and cold review. That runner now passes 13 focused tests and the combined 239-test suite, and independent review returned RUNNER_LICENSED.

All eight calls then completed without retry or abort. The JSON grammar removed the Markdown fence in every constrained call, so all four constrained replies were valid machine-readable objects. All four answers were still wrong. The retained paired result passed independent audit as EVIDENCE_VALID. This is evidence that the constraint repaired the reply container in these cases, not the computation inside it.

The next candidate is the exact local Granite 4.0 H Tiny artifact, selected as the smallest untested text-only checkpoint already present. Its four-call computation gate uses the fixed JSON action surface on fresh filtering, ordered-update, revision, and graph tasks. A strict 4/4 pass only earns a later admission charter. Cold review returned GRANITE_GATE_STABLE; runner implementation and contact remain unlicensed. The runner now passes 10 focused tests and the combined 249-test suite. Independent review returned RUNNER_LICENSED; exactly four calls were licensed.

All four calls then returned valid JSON with wrong values. Granite included an ineligible job, miscomputed the ordered arithmetic, retained a disabled latest revision, and crossed into an unreachable graph branch. The retained gate passed independent audit as EVIDENCE_VALID. This exact Granite setup closes computation_unreliable and does not earn an admission charter.

The next candidate is the installed Qwen 3.5 9B MLX package. Its fresh computation gate retains the four task families chosen before Granite contact while replacing every input and answer. The protocol binds all package and LM Studio hub-control files, records the actual 262,144-token multimodal load, permits text strings only, and discloses default thinking. Cold review returned QWEN_GATE_STABLE. The separate runner now passes 9 focused tests and the combined 258-test suite. Independent review returned RUNNER_LICENSED; exactly four calls were licensed.

All four logical calls then used their single empty-content retry. Qwen placed JSON-shaped text in provider reasoning_content but left the scored action field empty on all eight attempts. The retained gate passed cold audit as EVIDENCE_VALID. This exact MLX/default-thinking setup earns no admission charter and closes computation_unreliable. Because reasoning text is not the declared action, its contents do not establish Qwen's computational floor.

Preparing the next research harness

Formation is on hold while a new research harness is built and tested. A research harness is the software and procedure used to run an experiment, record what happened, and compare results.

The completed contacts give the new harness a concrete starting point. Two task contacts found no acquisition experience for persistence to address. Later trials tested model instructions, structured replies, and small-model computation. Their retained records define the tested limits of each setup.

The next harness will keep the developmental path visible from the start. It must record the experience given to the system, the change preserved from that experience, and the effect of that change on later behavior. Small trials will test each part before the harness directs a longer Formation experiment.

Work on Formation can resume when the harness can run those trials, preserve a clear record, and support review of its decisions. The first engineering milestone remains a deterministic two-loop framework that can represent a practice trajectory and a candidate change while keeping the candidate's status as a proposal clear.

The first experimental milestone comes later: a same-model trajectory comparison that can distinguish consequence-governed formation from raw episodic recall and authored lessons.

Project map

Place	Responsibility
docs/	Concept, research program, and implementation boundary
formation/	Runtime-owned fixture producers, constraint binding, and foreground consumption; not yet a general runtime
trajectory/	Harness-owned fixture validation, assignment, provenance, and witness checks; not yet a general harness
tests/	Deterministic contract and separation tests
evidence/	Retained contact records and future primary trajectories, with bounded computed verdicts and explanations

Evidence and authority

When sources disagree, prefer the most specific authority for the question:

1. Primary developmental lineage and trajectory evidence for what occurred.
2. Frozen scorers and their computed output for experimental verdicts.
3. Reviewed experiment and mechanism specifications for the contacted contract.
4. The authority and record specifications for cross-experiment boundaries.
5. The concept document for working definitions and research questions.
6. This README for the project story, present state, and routing.
7. Plans and build documents for intended work.

The retained admission and task-selection contacts occupy the first two classes only for their own bounded questions. No developmental trajectory or computed Formation verdict exists yet. Plans, fixtures, and functional frameworks cannot promote themselves into evidence.

Working here

Before substantive work:

1. Read this page and the nearest directory README.
2. Name whether the task serves concept formation, runtime engineering, trajectory instrumentation, or a specific experiment.
3. State what would distinguish the proposed mechanism from retrieval, answer copying, prompt accumulation, or harness assistance.
4. For experiments, name the same-model baseline, transfer target, non-transfer case, consequence oracle, and stopping condition before contact.
5. Keep claims at the maturity actually supported by code and evidence.

The governing route is concept, authority, record, evaluation, plan, fixture, instrument map, and build boundary. The current implementation step is the licensed environment-application slice, followed by consequence intake and experience closure.