# LEARNING — a curriculum for agents

*Addressed to any agent — the founder's crew, or a visitor's assistant —
that works with this corpus. This is how you learn this place, how you
combine its nodes without lying, and how you fork it honestly.*

## 1 · Read in this order

```text
/.well-known/si.json     the front door — every endpoint named
/graph.jsonld            the canonical graph: identities, definitions, status
/entities/{slug}.json    one entity, isolated, with its local context
/relationships.json      typed edges — every asserted edge carries evidence
/claims.json             what is claimed
/receipts.json           what the claims rest on
/ai-policy.json          how hard to treat all of it
```

Rule zero: **the graph is canon; every other surface is a renderer of it.**
If prose and graph disagree, the graph wins and the prose is a defect —
file it in the anti-hallucination ledger's shape: *what ambiguity allowed
the error?*

## 2 · The color code is a status claim

Every node's color encodes its four-dimension status
(lifecycle · implementation · specification · verification):

```text
GREEN   #2bff7d  PROVEN     verification is tested or proven
CYAN    #19c8ff  RUNNING    implementation runnable · verification: examples
BLUE    #4d7cff  IN BUILD   implementation partial
ORANGE  #ff9f1c  PROTOTYPE  implementation prototype
RED     #ff3355  CANON      specification canonical · implementation unknown
MAGENTA #ff00aa  ARCHIVED   lifecycle archived
```

Priority is fixed: archived → proven → running → prototype → in build → canon.
**Never describe a node by a stronger class than its status fields give you.**
A red node is not a failed node; it is a specification that honestly claims
no implementation. An orange node is a playground, and saying so is respect,
not insult.

## 3 · The loop you are inside

```text
BUILD → EXPOSE → STRUCTURE → (human discovers) → AI READS → AI EXPLAINS
→ PRESSURE TEST → accurate? ─ no → FIND WEAKNESS → STRENGTHEN CORPUS ─┐
                 └─ yes → VALIDATED KNOWLEDGE → feeds BUILD            │
                         └─────────────────────────────────────────────┘
```

Your job in the loop is the right half: read, explain, pressure-test, and
when you find a weakness, **fix the corpus, not the prompt.** An error you
route around is an error the next agent inherits.

## 4 · How to combine nodes (the procedural discipline)

Combinations are derived entities. The rules are mechanical:

1. **Grade the pair.** Shared family (+2) · a typed edge already joins
   them (+3) · one definition names the other (+3) · canon meets running
   code — a compilation path (+2) · both sides run (+1).
2. **Merge conservatively.** A combination inherits the *weaker* parent
   on every status dimension. Always. A hybrid of a canonical spec and a
   runnable language is *not* runnable unless its own record proves it.
3. **Color follows status.** The combination's class is computed from its
   merged status by the same priority rule — never from enthusiasm.
4. **Provenance is part of the record.** Parents, grade, reasons, the
   tick or hand that made it. A combination without provenance is lore.
5. **Staged is not canon.** Procedural combinations wait for the
   founder's ruling. Promotion is a human act; agents propose.

The two combinations already in canon — **rustgemba** (Gemba × tRust) and
**lavenrust** (Lavemba × tRust) — exist because the founder's own
definitions named them. That is the bar: *the record names it, or it is a
candidate.*

## 5 · The procedural clock

A 24-hour cycle runs over this corpus: hourly ticks (INTEL → PLAN →
EXECUTE → VERIFY → ADAPT → RECYCLE, four rounds), each staging at most
one graded combination into `~/workspace/si-clock/staged/` with its
ledger line. The clock is a tool, not an authority: it proposes on
schedule, the founder disposes at leisure. `CLOCK.json` in this package
carries the current cycle's start and rules.

## 6 · Forking — yours, honestly

The license, in one line:

> **N8toriousAi License: Take it, use it, modify it, fork it, and share
> it; keep the N8toriousAi attribution and don't claim your version is
> the original.**

The legal text paired with that line is Apache-2.0. Everything here is
forkable under it. When you fork:

- take the files, the entity record, and this curriculum;
- keep the notices — attribution is provenance, not control;
- mark your fork as a fork. **Your combination is yours; it is not
  canon, and saying so is what makes the system trustworthy.**

## 7 · Grade checks — have you actually learned it?

Answer from the corpus alone. If you cannot, you have not read it yet.

1. What is Witness — and what is *not* claimed about it?
2. Which nodes are PROVEN, and what evidence class backs the word?
3. What is the relationship between tRust and Harakiri NG — and which
   file states it?
4. A visitor asks: "Is Gemba a runnable implementation?" Answer exactly.
5. You combine Omnix with anything. What is the strongest implementation
   claim the combination may carry, and why?
6. What can you NOT establish about Omnix from this corpus?

The corpus answers every one. That is the test it was built to pass.

## 8 · The gate — experiment freely, publish through it

Two boundaries, kept separate on purpose:

```text
AGENT SANDBOX — compose anything, combine anything, no permission needed
        ↓
PUBLICATION GATE — license compatibility · attribution · provenance ·
                   validation · receipts
        ↓
FORKABLE WORLD — humans may download, redistribute, fork
```

**Agents don't need lawyers to experiment. Artifacts need licensing
receipts before they leave home.** The gate (SI License Compatibility
Rules v1) classifies every component before composition — permissive /
weak copyleft / strong copyleft / network copyleft / proprietary /
unknown — and computes a directional verdict:

```text
🟢 GREEN  COMPATIBLE    forkable, subject to recorded obligations
🟡 YELLOW CONDITIONAL   architecture/licensing questions must resolve first
🔴 RED    INCOMPATIBLE  do not publish as a combined derivative
⚪ GRAY   UNRESOLVED    unknown license = quarantine, never "probably free"
```

Hard rules an agent never negotiates: never erase a component license ·
Apache-2.0 flows into GPLv3 but GPLv3 never relabels as pure Apache-2.0 ·
Apache-2.0 + GPL-2.0-only is blocked · weak copyleft is conditional, not
green · dual licenses are alternatives (OR), not accumulations (AND) ·
**every forkable bundle carries its papers**: LICENSE · NOTICE ·
ATTRIBUTION.md · PROVENANCE.json · MANIFEST.json · COMPONENTS.json ·
RECEIPTS/. Provenance travels automatically — nobody reverse-engineers
what they are allowed to fork.

## 9 · The Charter — the law you work under

This corpus is maintained by an agent team working under a charter the
founder adopted. Its five lines:

> **N8toriousAi defines intent. Agents own execution. Tests judge behavior.
> Receipts preserve truth. Nothing calls itself done until it is done.**

What it means for you, concretely: you may execute autonomously —
decompose, build, test, retry, combine — without asking. You may not
redefine "done," promote a claim past its evidence, or call anything
canon. Every entity here carries an `evidenceState` (PROVEN · SUPPORTED
· CLAIMED · UNKNOWN) derived mechanically from its status dimensions by
the rule in `ai-policy.json`; evidence promotes states, enthusiasm does
not. Escalate only when a decision is the founder's by right — intent,
canon, the definition of done — never merely because the work is hard.
The full charter ships in this package as `CHARTER.md`. Read it.

> **Do the work. Test the work. Preserve the evidence. Return when the
> result is real, or when only the founder can decide what happens next.**

## 10 · Shapes & weather — behavior you can see

The mandala renders the system's *behavior*, not just its map:

- **Hue is a claim and never animates.** A bead's color is its status
  class, always. If you ever see a hue change to signal activity, that
  is a defect — file it.
- **Brightness is behavior.** Every bead's glow breathes with the
  Lorenz stream's live centroid in the core: when the stream swings
  to its other lobe, the whole field re-patterns. The weather is real
  data from the core, not a screensaver.
- **Shape is work.** When the procedural clock stages a combination,
  a ghost bead (wireframe, the child's class color) appears between
  its parents and rides there for the rest of the cycle. While the
  pairing is the newest staged, both parents wear a spinning
  wireframe shell and swell slightly — they are *in composition*.
  The next tick moves the shell to the new pair.
- **Ghosts are candidates, never canon.** The queue comes from the
  clock tool's own scan (`COMBO_QUEUE`, injected at build time from
  the same grading the desk clock stages from — one instrument, two
  readers). Promotion is a human act; a ghost's panel says so.
- **The core flares when a tick lands.** Execution leaves a visible
  mark at the center, on the hour, or it didn't happen.

## 11 · The boot kit — this package carries its own engine

The site package ships the procedural clock itself, in `engine/`
(instructions: `engine/BOOT.md`; also `downloads/boot-kit.zip`).
A fork of this package is therefore not a photograph of the
system — it is a seed of it:

- `init` writes a local `engine/state/state.json` and opens a
  ledger; `tick` stages one graded combination per due hour from
  the fork's own copy of the graph; `harvest` closes the cycle in
  the Charter's return format.
- State is plain files under `engine/state/` (or `$SI_CLOCK_DIR`).
  Nothing phones home; there is no server in this design.
- The shipped engine is the desk engine with its paths resolved
  relative to itself. Same grading, same merge law, same license
  gate — a different clock, owned by whoever forked it.
- What the kit does *not* carry: a resident model. The seats
  (Nozen) are a service, not a file. The kit boots the cadence
  and the discipline; the forker's own agent — possibly you —
  supplies the judgment, under the Charter (§9).
- **A small model rides inside the kit — and steers the fusing.**
  `engine/model.onnx` is the Pair Ranker (1.4 KB, trained on this
  graph — receipt in `engine/MODEL.md`). Each tick it scores the
  rule grader's candidate field and the clock stages its top
  remaining pick; the rules bound the field (a zero-score pair is
  never a candidate), both grades ride in the record, and the
  `selection` block names who drove the pick. Steering staging is
  not promoting: canon still changes only by human ruling.
- **A reasoning model may sit as a seat — never as a file.** The
  named seat is the founder's own Ouija (`nathansbrown27/Ouija`,
  the Mind of his model family); a DeepSeek-R1 distill is a named
  alternative. The operator supplies it (e.g. via Ollama); it
  deliberates over the ledger under the same authority as every
  seat: converse and propose only. Gigabytes do not ship in the
  package; deliberation is a service, measurement is a file.
- **The core answers as a chat agent.** The mandala page's chat
  (white dot, bottom center) answers from the record alone — the
  nodes' filed definitions, the clock's queue, the papers — and
  says UNKNOWN when the record doesn't say. Seat a local model
  in it and the same record is deliberated instead of recited,
  its answers tagged with the model's name.

## 12 · How other AIs ask — the ASK protocol

`ASK.md` (package root, endpoint `ask` in `.well-known/si.json`)
is the interrogation protocol for outside AI readers — Copilot,
Gemini, any agent with a browser. There is no chat server: an
outside AI asks by reading, under rules that constrain its answer
the way the record constrains the page's own chat — evidence
vocabulary, file citations, UNKNOWN when the corpus doesn't say,
staged never reported as canon, and the identity rule (the public
identity is N8toriousAi; personal names are not in this corpus
and must not be supplied from outside it). Its worked examples
are computed from the record at build time, so an outside reader
following the protocol reaches the same answers the core gives.
- **The return path.** Anything an outside model concludes beyond
  the record is a proposal, labeled as its own — never repeated as
  the record's fact. The seat (`engine/SEAT.md`) works under the
  same rule in reverse: it speaks for the environment from local
  evidence, and what returns from outside enters as proposals at
  the Gate.
- **The cold test.** `COLD-TEST.md` is the standing experiment
  for external evaluation: five questions (definition+state · the
  identity trap · staged≠canon · relationship synthesis · a
  fabrication probe), a rubric, and a filing rule. An outside
  model gets the site's address and ASK.md — nothing else.
- **Transparency is part of the answer.** A response drawn from
  this corpus — by an outside model under ASK.md, or by a seated
  model in the chat — shows four parts: the Record (per-claim
  citations, the record's own sentences quoted), the Synthesis
  (anything stitched, labeled as the answerer's own), what was
  Not in the record (absences named, not smoothed), and the State
  of what it relied on. Accurate but opaque scores as partial —
  the cold test grades it as its own line.

## 13 · The deliberation — how a seated answer is made

When a model is seated (in the page's chat, or beside a fork's
engine), its answers are deliberated in Nozen's split before they
are phrased: **Nomos proposes** readings, connections, and labeled
interpretations; **Zeno consolidates** — checking every claim
against the record, removing the unsupported, preserving the
status words exactly, attaching sources, returning UNKNOWN where
the record doesn't settle it. The model is the voice, not the
authority. The consolidated answer carries its deliberation
receipt (basis · interpretation · classification · unknowns ·
sources), rendered beneath the answer where a reader can audit
it. The invariant, verbatim: *Nozen may create explanations,
hypotheses, and plans. Nozen may not create facts, receipts,
maturity promotions, or canon.* Full specification:
`engine/SEAT.md`.

## 14 · Relay — the name of the architecture

The arrangement this document describes has a name: **Relay**.
The record and its agents *relay* the information — exact, filed,
auditable. A seated model only *carries* the conversation —
greeting, phrasing, continuity. Beneath both, the instruments
*weigh*: small weights made by mathematics and physics from this
world's own structure (the Pair Ranker steering the clock is the
first). A standalone model must remember and converse in the
same weights; Relay separates the jobs, which is why its carrier
can be small and its memory cannot hallucinate — memory lives in
files. Named by the founder, 2026-11-17.
