Concepts

Sessions are driven by a handful of commands — and where one must be aimed, it takes a target (command <target>), so a few words serve a growing project. Each command is a small markdown file the agent reads: the procedure written in plain language, shipped in the baseline’s .claude/commands/ folder and stamped like everything else. The words themselves are the commands. In Claude Code they also surface with a slash (/welcome) and autocomplete — that spelling is one client’s convenience, and it can rise or fall with vendor decisions; say the word in any agent and it works.

Every entry opens its own page; the verbatim shipped file rides beside it — read one to see exactly what a session is told, or drop it into your own instance’s folder and adapt it.

• welcomefirst contact — what FRACTAL is, where you’re standing, the paths outsource: welcome.md ↓
• beginthe onboarding interview — five real questions, then the birth of your own instancesource: begin.md ↓
• <yourproject>your instance’s opener, carrying its own name — loads the memory, reports where things stand, waits for directionspecimen: fractal.md ↓ — the baseline’s own
• closeends a working cycle — the handover written, the checkers run, the memory savedsource: close.md ↓
• fieldnotean off-topic thought captured mid-work — read back, ratified into the buffer, then straight back to the tasksource: fieldnote.md ↓
• looka read-only window into another of your instances — observation, never interferencesource: look.md ↓

Entry declares the project (each instance’s opener is its own name); closing is universal. One conversation, one open loop.

Hardwired and taught

The commands above ship in the public baseline — hardwired in the mirror, born into every new instance. Beyond them, an instance can grow its own: a custom command is a small stamped file teaching the session a procedure in your project’s own words. How to teach a command — the recipe and its rules — lands here in the content pass.

Beside the commands stands a second callable tier: behaviour conventions — rule-sets that shape how one class of output is represented, summoned into a scope rather than standing always-on. Call one by name onto a document or task and its rules bind there completely; it composes with the project’s standing conduct, never overrides it, and releases when the work that called it ends. Each entry opens its own page; the verbatim standard and its command file ride beside it.

• MRCthe Mathematical Representation Convention — five rules that make every equation self-carrying: symbols defined, types stated, operations explicit, ranges given, derivation before codesource: the convention ↓ · command: mrc.md ↓

The shelf grows the way everything here grows: a convention is minted when a real friction demands one — this first entry came from a model description whose equations arrived unexplained — and an instance adopts it by its own recorded decision. The scholarly-source rules in the bibliography are the class’s older sibling.

Everything FRACTAL does builds from the concepts below. Each entry is the short form; where an entry carries a link, the deeper description is behind it — a section on this page, a command’s own page, or the chapter of the story where it happened. Where a paragraph is enough, the paragraph is all there is.

• The canonical record

  every fact lives in exactly one governed document; boards, indexes, and this site are projections that cite it and never become a second source
• The knowledge store

  the project’s memory substrate — one append-only log under a dependency-free verifier; how it is built, and why it can be replayed, is its own story chapter
• The rule register

  the numbered ledger of every decision the project has made, each with its reasoning — rules are made by talking, kept by the record
• The close ritual

  a session ends by writing its own record — checklist walked, checkers green, one commit; the next session opens where it left off
• The context spine

  how a session orients: a stable pole (vision and mode) and a dynamic pole (where the work stands) — read in one pass, never scanned
• User documents

  the owner’s windows into the project — roadmap, agenda board, fieldnote handout — the same spine the AI reads, reader-matched
• The fieldnote buffer

  the project’s deliberate RAM: the one document human and AI both write — captures ratified in, worked off soon, gauged for pressure
• The kernel and genesis

  what every project is born with — constitution, formats, procedures, tools — and the executable birth that copies it in one sitting
• Releases and provenance

  a release is a signed tag with an independent timestamp receipt committed beside it — priority is mathematics, not testimony
• Working standards

  every procedure the system runs on is a written, versioned, ratified standard — distilled from executed history, never designed in the abstract
• Integration categories

  everything the system produces belongs to one category — shipped at birth, grown by you, or installed by decision — so the offer stays honest
• The interface place

  how instances talk: each keeps one deliberately readable place; counterparts pull, nobody writes into a foreign tree
• The observation window

  a read-only look into another of your instances — boundaries first, report and withdraw; children stay sovereign
• The sandbox shelf

  concepts proven here become things you can take — standards, command files, procedures — versioned and signed with their release

Every FRACTAL project carries a rule register — a numbered ledger of every rule and decision the project has ever made, each row carrying its reasoning. It is one of FRACTAL’s backbones: nothing governs because the AI happens to remember it. A thing governs because it stands in the register — and every session reads the register.

You make a rule by saying it. “From now on, we do X” — the session records it as a numbered decision with its why, and every session after honors it. Change your mind later and the register records that too: decisions supersede one another on the record, nothing is overwritten — the same never-lose-anything mechanic as the canonical documents.

This is also how you tune the language itself: if your agent ever misreads a command, or you simply want your own words for things, establish the rule once — “in this project, wrap up means close” — and it is law from then on, in every session, whichever agent drives. Your project is born with its register seeded; by tradition its first entry is your first real decision.

AI sessions move faster than human tracking — so a FRACTAL project keeps living documents that exist purely for the owner’s eyes. They are not an extra invention: they mirror the AI’s own navigation, pole for pole. The agent orients by a stable document (the vision and current mode) and a dynamic one (where the work stands right now); the owner gets the same pair, reader-matched — all of them projections of the record: readable without any AI, refreshed by it, never a second source.

The roadmap is the stable pole — where this is going: the big moves in order, each waiting on its named trigger, none built before it fires. It moves when the path changes, not when work queues up.

The agenda board is the dynamic pole — the state of the work at a glance: what’s done, what’s queued, what stands open, each chip pointing at its record. It refreshes at every close, so the picture is never stale by more than one working cycle. A project adopts it by its own decision; the format it follows is the board standard below.

The fieldnote buffer sits between the two spines — the one document both the human and the AI write: the project’s temporary memory, RAM, deliberately. Anything that pops up mid-work goes in through fieldnote as a normal message, no interrupt: the agent reads its structured understanding back, your ratification writes it, and the session returns to the task. The buffer is a growing list meant to shrink: entries are worked off soon — each dissolves into the project as a rule, a document update, or its own undertaking — and a pressure gauge warns when the list runs full, without ever blocking a capture. A one-page handout ships beside the pair, so the whole mechanic can be learned in a minute.

The sorting rule falls out of the shape: a change to the path lands on the roadmap, work lands on the board, and what surfaced along the way lands in the buffer. Between them, nothing a session produces or a human notices depends on anyone’s memory.

Under the hood, each window is one half of a document pair: a governance original the AI maintains, and the reader-matched face you actually open — when the two disagree, the original is right, and the stamp on the user half says so. Three pairs are fixed in the kernel — every FRACTAL project has them from birth: vision ↔ roadmap, working state ↔ board, buffer ↔ handout. Everything beyond those three is an extension, added only when a project feels the need, by a five-step standard (the pair procedure). FRACTAL’s own first extension is an update plan — the forming release’s collected to-do path, one home for the whole slate, which lets the board say just update open and link. A project that never ships releases simply never adds that pair — and can add ones this project never imagined. All the user halves live together in one User Documents/ folder at the repository root — the owner’s own place in the file system, openable without asking the AI.

Everything a FRACTAL system produces — concepts and tools alike — belongs to exactly one integration category, defined by how deep it reaches into your instance. The separation keeps the offer honest: you always know whether something arrives at birth, is yours to grow, or is yours to install.

Kernel concepts ship with every birth — the constitution, the formats, the procedures on the genesis shelf. Kernel tools ship the same way: the store’s verifier, the genesis executor, the close mechanics — copied at birth, yours from day one.

Custom concepts are the organs an instance grows for itself, on felt need — FRACTAL’s own update plan is one. These are deliberately never part of a release: every fractal project develops its own, so what you meet here is the class and the standard process for growing your own — never this project’s copy imposed on yours.

Installable tools are the category now forming: instruments a project installs by its own recorded decision, running in its own sessions, pinned to a release, removable without residue. forming The first member is the Mining Tool — a measurement instrument for the network: scaling proxies instead of raw counts, a per-release manifest, consent asked at genesis, dormant by default, data leaving only by the owner’s push. The standard is written here; the tool is built in the network’s research instance. A fifth category — plug-ins that need no installation at all — is named but deliberately not designed: nothing here is built ahead of need.

Every procedure FRACTAL runs on is a written, versioned, ratified standard — distilled from executed history, never designed in the abstract. This section catalogs them the way a paper cites its sources: identity, version, status, claim — dated by ratification, full texts verbatim from the shipped baseline. The commands above are their compressed spoken forms; together they grow toward a shared working language for AI agents — naturally born from use.

Three of these already have their stories told in the procedures section — Concepts’ story-form annex — plus the close ritual’s own story, and the first measurement of what governance costs.

The catalog’s substrate is the Registry that ships in the baseline — honest statuses, provenance attached. As standards mature they gain their entry here; nothing is listed before it is ratified in the record.

Concepts proven here become things you can take: a standard’s full text, a command file to teach your instance, a procedure to adopt — fractal sandbox extensions, downloadable, versioned, signed with the release they ship in.

The shelf opens with the content pass — its first stock is the standards above, each as an adoptable file. Until then, everything listed ships inside the public baseline itself.