# Quickstart: Zero to first canon event in 15 minutes

This walks an operator through setting up the Canonics (formerly the
Canon–Epoch Framework, CEF) reference implementation and declaring a
first real canon event. It assumes the terminology and operations
defined in the paper (*Canonics: Versioning the Frame, Not the Facts*,
Position paper (preprint) · July 2026): fact, invariant, canon event, epoch,
understanding, regime, canon distance (κ), blast radius, the severity
ladder L1–L5, DECLARE / RETRIEVE / REPROCESS / SCAN, and the Canon
Review. Nothing here is a new concept — it is the paper's reference
architecture (§4.6) operated end to end.

Fifteen minutes gets you through steps 1–6. Step 7 is a standing
commitment, not a one-time task.

## 1. Copy the workspace template

Copy `reference-implementation/workspace-template` into your own
workspace. This gives you the minimal file-based substrate the paper
specifies in §4.6 — a convenience, not part of the claim itself
(paper §4.1, §9 item 5):

```
/00_system/
  CURRENT_CONTEXT.md      # regime per domain — injected into every agent's system prompt
  CURRENT_EPOCHS.yaml     # derived epoch state per domain
  CANON_LOG.md            # canon chain (constitution + amendments)
/01_raw/                  # immutable facts, chronological
/02_understandings/       # derived, epoch-stamped, VERSIONED
/03_invariants/           # trans-epochal commitments
/04_decisions/             # active / superseded / historical
/05_canon_review/         # scan findings, meeting minutes, instrumentation metrics
```

Nothing here requires a graph database or vector store to start —
discipline of interpretation precedes sophistication of retrieval
(paper §4.6).

## 2. Fill /03_invariants with your trans-epochal commitments

An **invariant** (Definition 2) is an assumption you declare to survive
all epoch transitions: identity, values, non-negotiable principles.
Invariants are the *hard core* of your knowledge base in Lakatos's sense
— they are the rarest and most consequential thing to change (changing
one is Level 5 on the severity ladder, §4.2).

Write a handful of short files in `/03_invariants` — not a strategy
document, just the things that are true regardless of which operating
model, team size, or market you're in this quarter. If you're unsure
whether something is an invariant or a current strategic posture, put it
in `/04_decisions` instead: invariants should be genuinely rare.

## 3. Define your domains

𝔻 partitions your knowledge space — venture A, venture B, personal,
health, and so on (paper §4.2, "Domains"). Epochs run per domain,
unaligned: a canon event in one domain does not transition another
unless that domain is explicitly named in the canon's blast radius. Pick
domain names now, because every canon event you declare later will need
to state which domains it touches.

## 4. Point your agent at agents/CLAUDE.md or agents/AGENTS.md

Whichever agent substrate you use — Claude Code, an OpenAI agent, or
another file-based tool — its always-on instructions must load the
current regime, not retrieve it. This is heuristic H8 from the paper:
*"Because retrieval-visible updates are frequently ignored, the current
regime summary belongs in always-on instructions (system prompt /
CLAUDE.md), not in retrievable storage. Foreground, don't file."*
Point your agent's system-prompt file (`agents/CLAUDE.md` for Claude
Code, `agents/AGENTS.md` for other agent runtimes) at
`00_system/CURRENT_CONTEXT.md` so every session starts from invariants +
the canon chain + the current regime — "read the constitution and its
amendments, not the congressional record" (paper §4.6, "Cold start").

## 5. Ingest a few raw records with /ingest

`/ingest` appends new facts to `/01_raw`, extracts and derives
understandings, and stamps them with epoch, domains, and source facts
(paper H1, "Write path"). Stamping must cost you nothing manually —
if metadata requires discipline, the system dies, so let `/ingest` do
the stamping.

Remember Definition 1: a **fact** is immutable and append-only —
`(content, t_event, t_recorded, source, domains)`. Facts are never
rewritten, only re-read under different lenses. Feed in a handful of raw
records (notes, transcripts, decisions) to get your first understandings
stamped under your workspace's initial epoch.

## 6. Declare your first real canon event with /new-canon

The workspace template ships with an example canon event in
`CANON_LOG.md`, marked:

```
# EXAMPLE — replace with your first real canon
```

This is the paper's Appendix A worked example (the `venture_a` operator
who moves from a team-based to a solo operating model,
`C-2026-07-VA-solo`, L3). It exists to show the shape of a real entry —
`id`, `t_effective`, `t_declared`, `declarer`, `level`, `diff` (retires /
introduces), `blast_radius` (domains + secondary + assumption
categories), and `summary`. Do not leave it in place: run `/new-canon`
and replace it with your own first canon event.

`/new-canon` is an interactive DECLARE (paper §4.4): it asks what
changed, when it took effect, which domains it touches, and which
assumptions are retired versus introduced. For anything at severity L3
or above, the paper requires out-of-band human confirmation — a
declaration a chat transcript alone cannot produce (paper §6). Once
declared: the current epoch in each affected domain closes, a new epoch
opens with the folded regime, every understanding with κ ≥ 1 is marked
`stale` (not rewritten), `CURRENT_CONTEXT.md` is regenerated, and the
signed canon is appended to `CANON_LOG.md`.

Use the **canon promotion test** (§4.3) if you're unsure whether
something is worth declaring: *a canon event changes the answers to
questions that do not mention it.* If a fact fails that test, however
dramatic it feels, it's just a fact — not a canon.

## 7. Schedule your first Canon Review

The Canon Review (§5) is not optional tooling advice — it is a
first-class component of the framework. Put it on the calendar now,
before day-to-day use displaces it:

- **Cadence:** monthly by default; weekly if your operation is volatile
  (paper §5.1, item 2).
- **Duration:** one to two hours.
- **Agenda order is asymmetric and fixed:** the falsification pass runs
  first — what in the recent record contradicts or supplants the
  *active* canons? — then the emergence pass — what coherent pattern is
  forming that no canon describes? (§5.1, item 1). This ordering points
  the machine's incentive at knocking paradigms down before confirming
  or inventing new ones.
- Machine proposes; you declare. Nothing the scan finds is ever declared
  automatically (§5.1, item 3).

## Honest expectations

Before you start operating this workspace day to day, hold these three
things firmly, because they are the framework's own non-claims, not
caveats bolted on afterward:

- **Canonics does not detect regime shifts autonomously.** The Canon Review
  is where detection is structured — a recurring, instrumented occasion
  for a human to perceive that the world has changed, and for a machine
  to falsify the active canons first. Detection of silent shifts remains
  an open problem the framework does not solve (paper §2.4, §9 item 1).
- **κ counts declared canon events crossed, not validity.** Canon
  distance (κ) is a distance to *declared* marks. κ = 0 means no
  declared canon intersects an understanding — that is evidence of
  freshness only to the extent your declaration process is actually
  alive. κ = 0 under an inactive declaration process certifies nothing
  (paper §4.3, §9 item 2).
- **Scope is a single operator or a small, high-trust team.** This
  workspace is not an enterprise system. Multi-stakeholder epistemic
  authority and access control that survives summarization are named
  future work, not implied capabilities of what you just set up (paper
  §4.1, §9 item 4).