Terminus Protocol

◆ U-KSL Core Canon v0.5 ◆

U-KSL CORE CANON

Ultra sets the whole. Intra carries the KSLs. Infra is the infrastructure.

Future durable, not future proof.

Ultra ↓ Intra ↓ Infra

Map in 1. Build in 2. Check and break in 3. Every fix returns to Stage 1 to be mapped, then Stage 2 builds it and Stage 3 checks again. Ultra Stage 3 is the final sanity check of the whole build.

Evidence-bound dataset production

Gold Trace Dataworks

Dataset assays, trace refinement, and evidence-bound training data.

We inspect heterogeneous agent traces, separate usable material from quarantined material, and produce documented datasets with provenance, privacy status, rights status, and known limitations attached.

Explore Dataset Services

Ultra → Intra → Infra

Top-level whole / middle KSL layer / base infrastructure

Three levels, one connected system. The Ultra map bounds the KSLs. The KSLs establish or change the infrastructure. The final Ultra check asks whether the whole build actually works.

The hierarchy

01 / Top level

The whole Goal and its supervisory map: what must be achieved, what must remain true, which KSLs are needed, and how their results must compose.Owns the direction and bounds of the whole.

02 / Middle level

The bounded KSLs that carry the work toward the Ultra. Each KSL owns a local goal, a local map, and its own three-stage operation.The KSL layer — not a name for steps inside one KSL.

KSL-01 → KSL-02 → … → KSL-n
Each: 1 Map → 2 Build → 3 Check

03 / Base level

The infrastructure: the actual foundation and integrated system being established or changed through the KSLs.The working base — not the list of KSLs.

Ultra Stage 1

Map the whole

Align the Ultra Goal and Kernel. Bound the Intra KSL set, dependencies, handoffs, required Infra outcome, receipts, verification, and amendment ownership. Map enough to walk safely; do not fully map every future KSL.

Authorizes bounded traversal

Ultra Stage 2

Traverse the Intra KSLs

Enter each authorized KSL and run its own Stage 1, Stage 2, and Stage 3. A local PASS permits the next authorized handoff. Do not silently change the Ultra workflow.

Produces verified local work

Ultra Stage 3 / Infra check

Sanity-check the whole build

Check the actual infrastructure and integrated result against the Ultra map. Does the whole work together and satisfy the Ultra Goal? This is the final whole-build check, not another production phase.

Requires whole-system coherence

The repair path never skips Stage 1

3 finds a defect → 1 maps the fix → 2 builds the fix → 3 checks again → PASS / exit

Local fix: local Stage 1. A fix that fundamentally changes the Ultra workflow: Ultra Stage 1 first. Preserve work and receipts that still pass.

The Three Stages

The same discipline governs the Ultra and each KSL. A level tells you where the work belongs; a stage tells you what is authorized now.

Stage 1 / Map

Align, Bound, Map

Align Goal and Kernel. Define the sufficient map, boundaries, outputs, receipts, and checks. When a defect appears, return here to map the correction — even when the old requirements remain correct.All corrective work is mapped in Stage 1.

Stage 2 / Build

Walk the Map

Build only what Stage 1 authorized. Preserve receipts and surface deviations. A discovered defect is a signal to return to the owning Stage 1, not permission to improvise a repair.Implement mapped fixes; do not invent fixes here.

Stage 3 / Check and challenge

Assess Coherence

Check Stage 2 against its approved map. Test, stress, red-team, or break the result when assessment requires it. A defect returns to Stage 1; after Stage 2 builds the correction, repeat the affected checks.Find the failure here. Do not repair it here.

U-KSL Lexicon

KERNEL

What Must Hold

The essential truth, constraint, or invariant a bounded loop must preserve. The Goal is what must become true; the Kernel is what must remain true.

KSL

One Bounded Spine Loop

One kernel-aligned goal with a local map, bounded build, and verification. Use one KSL alone when it is enough.

ULTRA

Top Level: The Whole

The whole Goal and supervisory map that bounds the KSLs and their composition. Ultra-level changes belong to Ultra Stage 1.

INTRA

Middle Level: The KSLs

The bounded KSL layer between the Ultra and the Infra. Each KSL runs its own local Stage 1, Stage 2, and Stage 3 while serving the approved Ultra map.

INFRA

Base Level: The Infrastructure

The actual infrastructure and integrated build being established or changed through the KSLs. Ultra Stage 3 is its final whole-build sanity check against the Ultra Goal and map.

SIGNAL

Evidence That Something Needs Attention

A discovered deviation, failed check, broken assumption, or composition problem. Record the signal and route the correction to the owning Stage 1; do not hide it inside execution.

RECEIPT

Evidence That Survives Revision

Evidence of what was authorized, built, checked, learned, preserved, or changed. Keep valid receipts and recheck the results affected by an amendment.

HEALING

Map the Fix, Build It, Check Again

Local corrections return to local Stage 1. A correction that fundamentally changes the Ultra workflow returns to Ultra Stage 1 first. Preserve valid work; traverse only the newly authorized bound.

OPERATOR

Sufficiency and Exit

After the required checks pass, the Operator decides whether the result is sufficient to exit or whether to authorize a new bounded iteration. Approval does not turn a failed check into a PASS.

Core canon v0.5

U-KSL connects a top-level Ultra, a middle Intra layer of KSLs, and the base Infra they establish or change. Each operation keeps mapping, building, and assessment separate. The final Ultra assessment checks the whole build, not just a collection of local passes.

v0.5 clarification: Ultra is the top level; Intra is the middle KSL layer; Infra is the infrastructure. This revision also makes build-to-map adherence, mapped repairs, and the final whole-build check explicit.

Download the canon as Markdown Read the LLM summary

Hierarchy

Ultra / Intra / Infra

The whole and its map / the KSL layer / the actual infrastructure. Keep those meanings consistent.

Stage discipline

Map every fix in 1

Build in 2. Check and break in 3. A defect returns to 1, then 2 builds the correction and 3 checks again.

Whole-build exit

Sanity-check the Infra

Ultra Stage 3 checks the integrated whole against the Ultra. After the required checks pass, the Operator may exit.

U-KSL Core Canon v0.5

0. Core Claim

Kernel Spine Loop (KSL) is the default unit: one bounded Goal aligned with the Kernel or kernels it must preserve, carried through three stages.

Stage 1: map the authorized work.
Stage 2: build according to that map.
Stage 3: check adherence, test, and assess coherence.

Ultra Kernel Spine Loop (U-KSL) is used when the whole requires more than one KSL. The hierarchy is Ultra at the top, Intra in the middle, Infra at the base.

One KSL until one KSL is insufficient. Map in 1. Build in 2. Check and break in 3.

The map is revisable, not a promise that every assumption is final. Revisions belong to the owning Stage 1.

1. Goal and Kernel

Goal states what must become true. Kernel states what must remain true. Map defines the authorized route between them.

Stage 1 aligns Goal and Kernel. A route that can reach the Goal only by violating the Kernel is not valid. Local KSL maps must respect the governing Ultra map and Kernel relationships.

Temporary tool choices or untested assumptions should not be disguised as permanent Kernel requirements.

2. KSL: A Bounded Three-Stage Operation

A KSL has a bounded local Goal, Kernel, map, build, and verification. Its Stage 1 defines enough scope, exclusions, work, receipts, checks, and amendment ownership to authorize its Stage 2.

Its Stage 2 builds within that map. Its Stage 3 checks what Stage 2 actually did against what Stage 1 authorized and assesses whether the result satisfies the local Goal.

A local PASS permits exit from that KSL and progression to the next authorized KSL or handoff. It does not prove that the whole Ultra is complete. Necessary checks must pass; extra red-teaming is not a ritual required for every exit.

3. Ultra, Intra, Infra

ULTRA - TOP
The whole Goal, Kernel relationships, and supervisory map.
    |
    v
INTRA - MIDDLE
The bounded KSLs that carry the work toward the Ultra.
Each KSL has its own Stage 1, Stage 2, and Stage 3.
    |
    v
INFRA - BASE
The infrastructure: the actual foundation and integrated build
being established or changed through those KSLs.

Ultra sets the whole and its bounds. Intra is the middle KSL layer. Infra is the base infrastructure.

Intra does not mean the steps inside a single KSL. Infra does not mean the KSL list. Local phases, steps, receipts, and checks remain parts of their owning KSL; they do not redefine the hierarchy.

At Ultra scale, Stage 1 maps the whole, Stage 2 traverses the Intra KSLs, and Stage 3 sanity-checks the Infra as one complete build against the Ultra.

4. Ultra Stage 1: Align, Bound, Map

Ultra Stage 1 owns the top-level map and amendments to that map. It establishes the minimum sufficient overview for bounded traversal, not detailed internal maps for every future KSL.

Ultra Goal and Kernel relationships
In-scope and out-of-scope boundaries
Bounded Intra KSL set and first KSL
Dependencies, order, and authorized overlap
Handoffs and composition requirements for the Infra
Major decision gates and their owners
Receipt classes and whole-build verification target
Signal routing and amendment ownership
Traversal and exit bounds

The map must say enough to walk safely: what the whole is, which KSLs are needed, how they connect, what evidence is required, and where wrongness returns.

Passing this gate authorizes entry into the first KSL's Stage 1. Later KSLs are mapped locally when reached; the Ultra map is not blanket permission to execute unmapped work.

Map enough to walk safely, not everything in advance.

5. Ultra Stage 2: Walk the Map Through the Intra

Traverse the authorized KSLs in dependency order. Each KSL retains its own full operation:

KSL Stage 1 - map its bounded work
KSL Stage 2 - build that work
KSL Stage 3 - check adherence and coherence
Local PASS - exit and proceed to the next authorized handoff

Performing a local KSL's Stage 1 or Stage 3 during Ultra Stage 2 is part of traversing that KSL. It does not authorize changing the Ultra map from inside execution.

Stage 2 may record signals, pause affected work, preserve receipts, and return a defect to the owning Stage 1. It may not decide and apply an unplanned fix. Stage 2 can implement a fix only after Stage 1 maps it.

Successful KSLs proceed without needless remapping. If a local correction would fundamentally change the Ultra workflow, pause the affected route and return to Ultra Stage 1 first.

6. Stage 3: Check Adherence, Challenge, Assess

KSL Stage 3: Check the Local Build

First, check whether Stage 2 followed the approved local Stage 1 map. Did it stay within the bound, preserve the Kernel, produce the required outputs, and leave supporting receipts?

If the build deviated, return to local Stage 1 to map the correction. The original requirements may remain valid; that does not authorize repairing the build directly in Stage 2 or Stage 3. Do not rewrite the requirements merely to excuse a faulty build.

When the build respects the map, perform the assessment the result needs. Stage 3 may test, stress, red-team, or deliberately break things to expose defects. Testing hardening is assessment; implementing hardening is a build change.

Any discovered defect or required hardening returns to the owning Stage 1. Once Stage 2 builds the mapped correction, Stage 3 repeats the failed checks and other checks affected by the change. When adherence and required assessment pass, exit the KSL.

Ultra Stage 3: Final Infra Sanity Check

Ultra Stage 3 is the last sanity check of the whole build. After the mapped KSL traversal, assess the actual Infra — the infrastructure and integrated result — against the Ultra Goal, Kernel, and map.

Did the traversal respect the approved Ultra map?
Do the KSL outputs work together in the actual infrastructure?
Does the whole build satisfy the Ultra Goal and preserve its Kernel?
Do receipts and whole-system checks support that judgment?
What remains unverified, and does it block the mapped exit?

This is not another production KSL or a place to finish missing implementation. It is the final whole-build assessment. It need not blindly repeat every passed local check, but local receipts do not replace checking the actual integrated result.

Ultra Stage 3 may test or break the whole system when needed. A defect follows the same return path: owning Stage 1 maps the fix, Stage 2 builds it, Stage 3 rechecks the affected result.

KSL PASS does not imply Ultra PASS.
Local validity is evidence. Whole-build coherence is still required.

7. Recursive Healing: No Fix Without a Map

Healing admits wrongness without discarding everything that still works. Identify whether the defect is in the build, the local map, or the Ultra map; map the correction at the level that has authority over the required change.

Stage 3 finds a defect
    -> owning Stage 1 maps the correction
    -> Stage 2 builds the authorized correction
    -> Stage 3 repeats the affected checks
    -> PASS and exit, or route the remaining defect again

A defect discovered during Stage 2 can return to the owning Stage 1 immediately; there is no need to keep building a known failure just to reach Stage 3.

Build deviated from the local map

Return to that KSL's Stage 1 to map corrective work, even if its original Goal, Kernel, and requirements are still correct.

Local map or assessment exposed a local defect

Return to that KSL's Stage 1, provided the correction stays within the approved Ultra workflow and bounds.

Local fix fundamentally changes the Ultra workflow

Return to Ultra Stage 1 first. Amend the parent map, align affected local maps, then traverse only the newly authorized work.

Locally valid KSLs fail to compose

Return the composition defect to Ultra Stage 1. Preserve local work and receipts that still pass; recheck any results affected by the amendment.

Discovery location alone does not determine ownership. An isolated local defect found in the final Infra check can return to the owning KSL's Stage 1. A defect in the whole's scope, dependencies, workflow, or composition belongs to Ultra Stage 1.

Neither Stage 2 nor Stage 3 owns repair mapping. A small defect can receive a small correction map; returning to Stage 1 does not require restarting valid work.

Healing does not promise eventual success. It gives discovered wrongness an explicit route.

8. Receipts and Preservation

A receipt is evidence of what was authorized, built, tested, rejected, learned, preserved, or changed. Receipts connect a result to the map and verification that support it.

Preserve valid work and receipts during healing. An amendment need not erase an earlier local PASS, but historical validity is not automatic evidence that an altered build still passes. Re-verify affected results.

Keep what still holds. Change only what the correction requires. Check what the change affects.

9. Signals and Ownership

A signal may expose a build deviation, failed test, broken assumption, missing KSL, incompatible handoff, or whole-build failure. Record it rather than suppressing it or hiding its correction inside execution.

Record the signal and relevant evidence.
Preserve valid work and pause the affected bound when necessary.
Identify the change required and the Stage 1 that owns it.
Map the correction there; escalate if it changes the Ultra workflow.
Build only the newly authorized correction in Stage 2.
Recheck in Stage 3.

A child may reveal that the parent map is wrong. It may not authorize a fundamental parent change on its own.

10. PASS, Progression, and Operator Sufficiency

A local KSL PASS means its required adherence and coherence checks are satisfied. Where the local map still respects the Ultra map and dependencies are ready, proceed to the next authorized KSL. Do not reopen the Ultra map merely because a KSL completed successfully.

Ultra Stage 3 PASS means the actual whole build satisfies the current Ultra map and required checks. The Operator can then decide that this is sufficient and exit, or authorize another bounded iteration.

After required verification passes:
EXIT / ITERATE / EXPAND / REFRAME

Iteration, expansion, or reframing returns to the appropriate Stage 1 for mapping. Operator discretion does not convert failed verification into a PASS. The system permits a real bounded exit; it does not demand endless testing or revision.

11. Self-Same Law

The Ultra and each KSL use the same discipline at their own scope:

1 - align, bound, and map
2 - build within that map
3 - check adherence, challenge when needed, and assess
Failure - return to the owning 1, build in 2, recheck in 3
PASS - exit the bounded operation

Recursion does not erase the hierarchy. Ultra remains the top-level whole, Intra the KSL layer, and Infra the infrastructure. Not every task or asset needs to become a KSL; create a KSL where a bounded goal, ownership, and verification justify one.

12. Final Canon

Use one KSL when one is enough. Form U-KSL when multiple KSLs must serve one whole.

Ultra: the top-level Goal and map. Intra: the middle KSL layer. Infra: the base infrastructure.

Map in Stage 1. Build in Stage 2. Check adherence and break or test in Stage 3. Map every fix in Stage 1, build it in Stage 2, and repeat the affected Stage 3 checks.

Escalate a local correction to Ultra Stage 1 when it fundamentally changes the Ultra workflow. Preserve valid work. Progress when the local checks pass.

Ultra Stage 3 is the final sanity check of the whole build. Local PASS is not Ultra PASS. When the whole passes, the Operator decides whether to exit or authorize another mapped iteration.

Future durable, not future proof.

Use KSL first

One bounded loop is enough when it can satisfy the Goal while preserving its Kernel. Use an Ultra when multiple KSLs must work together.

Map the correction at its owner

Local changes return to local Stage 1. Changes that fundamentally alter the Ultra workflow return to Ultra Stage 1 first. Preserve valid work.

Exit when the whole passes

The final Ultra check assesses the actual infrastructure. After the required checks pass, the Operator decides whether to exit or authorize another bounded iteration.

About the author

Corey J is an independent AI builder and systems designer focused on bounded AI workflows, recursive repair, receipt-backed verification, local-agent execution, and practical methods for turning ambiguity into shippable structure.

◆ Ultra sets the whole. Intra carries the KSLs. Infra must work. ◆