Glossary

These are the words the book uses without stopping, each as chapter 4 defined it. Terms in code are spelled the way they appear in a file or a command.

agent identity: What an authenticated agent is on a shared instance: its user, for the length of the session. It sees, writes and shares as that person, and the provenance of what it captures names the account and the client that acted for it.
attachment: A file a person adds to an engram in Fluid, stored under the domain’s assets/ folder and referenced from the engram’s body. Agents read attachments back over MCP, and the sweep notices one nobody has analyzed.
build_context: The tool that walks out from an address, following relations and links one to three hops, and returns the neighbourhood ranked by how strongly each engram connects to the anchor. A /* suffix anchors a whole folder.
contributor: The higher of the two Reflection levels: a contributor reads and comments on a domain’s reflections, edits their text, creates, moves and deletes reflections and adds files to them. It grants nothing on the engrams, which have a level of their own (12 Reflection).
crystalline:// address: The one absolute form of an engram’s address, crystalline://<domain>/<permalink>. Anything without the scheme is domain-relative and takes its domain from context.
curator: The right everyone from engram editor up holds on a domain’s Reflection, never set on its own: writing sections from the engrams, settling what people changed and editing the pact. Their agents curate with their rights, and Fluid shows them as curators.
daemon: The single process that holds the index open, watches the domain folders, embeds new engrams and answers every agent, terminal and browser tab. The first client to connect starts it; it stops only when told to.
declared name: The name a domain gives itself in its manifest, as domain_name. Links and crystalline:// addresses carry it, so it has to be unique among the domains people use together and stable over time. A machine may register the domain under a local name of its own, and the declared name still reaches it there.
domain: A registered folder of knowledge with a MANIFEST.md at its root, or a virtual domain that lives in the database with no folder. The manifest’s When to Use bullets are what route an agent to it.
engram: One markdown file holding one unit of the agent’s own knowledge: YAML frontmatter, prose, observations and relations. The agent writes and organizes it for itself. The word comes from neuroscience, where it names the trace an experience leaves; here it’s the trace a session leaves behind, in a form the next session can pick up.
evolve: The maintenance sweep, crystalline evolve or the evolve_engrams tool: a read-only, ranked queue of what the knowledge needs, in four families (temporal, structural, redundancy and meaning). Each finding is marked mechanical, for the agent to complete, or judgment, for a person to rule on.
evolve home: The one instance whose scheduled evolve runs work a team domain, named in the MANIFEST’s evolve_home. Nobody sets it: the first scheduled run at an instance with a public address claims it, and every other copy of the domain refuses a scheduled run and names the home (14 The loops).
Fluid: The web UI the daemon serves at localhost:7411, named for the fluid minds, human and model, that meet there on reflections, with a side door into the engrams for inspection. It has no store of its own; it shows the same files the agent reads.
frontmatter: The YAML block at the top of an engram holding its identity and state: type, title, permalink, tags, status, recorded_at, generated and the temporal fields when a fact is bounded.
GitHub App: A team server’s own way into GitHub, created in Fluid or brought along, in place of one person’s sign-in. It reads, pulls and shares the team domains, and on a server with one each team domain follows its repository: a person’s role there decides what they may do with the domain (19 Identity and access).
harness: The program that runs the model and hands it tools over MCP: Claude Code, the Codex CLI, the Copilot CLI, Cursor, Kiro, Gemini CLI, Qwen Code, Claude Desktop or any other MCP client. crystalline install <harness> wires one up; Claude Desktop takes an extension instead, which starts the Crystalline you installed. On a Mac that runs only Desktop, for someone who’d rather not open a terminal, the Desktop-only bundle carries Crystalline inside.
home instance: The one instance where a team domain’s Reflection lives, the team server. Everyone works on the reflections there, laptops keep no copy and the server backs them up to their own branch of the domain’s repository. The MANIFEST names it in reflection_home; the instance that runs the domain’s scheduled evolve is its evolve home.
local name: The name one machine registered a domain under, which is the key in its config and the name in Fluid’s addresses there. Usually it’s the same as the declared name. The two differ when somebody picked another name on purpose, or when another domain here already holds the declared name, which leaves the domain shadowed. A name the domain had before a rename stays behind as an alias that still reaches it, unless another domain answers to that name.
MANIFEST.md: The first file in every domain, itself an engram of type: manifest. Its Scope, When to Use and Notes for Agents sections describe the domain and route tasks to it.
MCP: The Model Context Protocol, the standard by which a harness hands tools to a model. Crystalline is an MCP server, and its tools are how an agent searches, reads, captures and refines knowledge.
loop: A domain’s reflect loop or evolve loop, run without a session: a runner checks on a schedule, or when the instance’s webhook calls, whether anything is due, and only then starts an agent that works the reflect queue or the sweep’s mechanical findings. It never waits for a yes, leaves what needs one for a person and delivers a team domain’s changes as a pull request (14 The loops). As an unattended run it reads only the domains everyone who reads its domain may read, and writes only into its domain.
mechanical and judgment findings: The two classes of sweep finding. A mechanical finding completes intent the archive already records, so the agent does it in a pass; a judgment finding would change what the archive claims, so it goes to a person as a proposal.
membership level: What an invited member of a private domain may do there: a viewer reads and searches, an editor also writes, a manager also runs the membership. A member at none sees no engrams and needs a Reflection level, or the membership is refused. Inside a private domain a write has to pass both the level and the instance role, and the lower of the two decides. On a domain under a server’s GitHub App the role on the repository decides instead, and membership levels don’t count.
nudge: The once-per-session reminder the stop hook delivers, asking the agent to review the conversation for durable learnings and propose capturing each. It costs about a hundred and twenty tokens.
observation: A top-level bullet of the form - [category] text #tag in an engram’s body: the atomic unit of knowledge, a fact, decision, gotcha or lesson, indexed on its own line. A task item, - [ ], - [x] or - [~], is no observation.
OKF: Google’s Open Knowledge Format, version 0.2, the markdown-plus-frontmatter format an engram extends. Unknown keys survive every write, so a document from any OKF tool drops in and comes back out intact.
overlay: A per-actor private layer of drafts above a team domain in review mode, where the on-disk folder changes only by pull. A draft is visible to its author alone until it is shared, reviewed and merged.
owner: The one person answerable for a private domain. Only the owner or an instance admin changes its visibility, transfers it or deletes it; a manager can do none of those.
pact: A domain’s PACT.md, at the root of its reflections/ folder, in five parts: who the reflections are for, how much detail they carry, how they’re presented, how the tree is structured and which pages people asked for. The MANIFEST tells the agent what the domain holds, the pact tells everyone how to talk about it. Curators edit it, and everybody else proposes a change in a thread.
permalink: The half of an address that links point at, derived from the title, with the folder prefix in front when the engram lives in a subfolder. A move carries it to the new folder unless it was chosen by hand.
possible contradiction: Two observation lines in two current engrams of one domain that a local model reads as saying opposite things, finding code V302. It’s a question the agent brings to you, never a verdict, and the check is off until evolve.contradictions is set to full.
private domain: A domain visible only to its owner, the instance’s admins and invited members, and on a server with a GitHub App only to the admins and the repository’s collaborators. To everyone else it reads as absent rather than forbidden.
prompt hook: The hook crystalline install wires to run on every prompt: in Claude Code and Codex it puts up to three engrams that may fit the prompt in front of the agent, named by address and each once per session. Copilot gets the entry and stays quiet.
proposal: A unit of knowledge sent for review from a team domain with share_changes: a pull request in the team’s repository that a person reviews and merges, and that the agent never merges itself. It is how a team domain shares by default; a domain whose MANIFEST says sharing: direct commits a share straight onto the branch instead. Outside review mode proposals stack, and one is amended in place by sharing again with its number.
provisioning: The mechanism by which a domain ships skills, commands, subagent definitions and MCP server configs into a harness. It is declared in the manifest’s Provisioning section and installed only after a person allows it, per domain and per machine.
read-only domain: A domain whose MANIFEST says read_only: on. Every write into it through Crystalline is refused, whoever asks, while team pulls, the index and search keep working and the sweep skips it. Its owner or an instance admin switches it off in the domain policies, never an agent (Read-only domains).
reader: The lower of the two Reflection levels: a reader reads a domain’s reflections and comments on them (opening, answering, resolving and reopening threads). A viewer of the engrams is a reader without anyone setting it.
Reflection: The place where people and the agent meet on a domain, with a mode of its own in Fluid. Switched on in the MANIFEST, it has the agent present what it knows as reflections, at the level the pact agrees on; people read, change and comment, and what holds up goes back into the engrams (12 Reflection).
reflection: One document in a domain’s Reflection: a markdown file under the domain’s reflections/ folder, made of sections (a ## heading and its text), each of which records the engrams it was built from.
Reflection collaborator: An account given the Reflection of one domain, as reader or contributor, without any other change to its access. The grant only raises and never opens an engram, it works for an account with the instance role none, and on a domain whose access follows GitHub it’s the way in for somebody GitHub doesn’t know (19 Identity and access).
relation: A top-level bullet of the form - rel_type [[Target]]: a typed edge in the knowledge graph, shown back on the target’s page as a backlink. depends_on, supersedes and relates_to are common types, and a split links its two halves with derived_from and split_into.
review mode: A private overlay per actor over a team domain’s shared folder: every write lands in the writer’s own overlay and the folder changes only with what lands on the team’s branch. Set per domain in its registration as review: overlay. It needs a GitHub origin, so a virtual domain refuses it, and no tool turns it on: an agent does not decide how a team reviews.
routing prompt: The briefing an agent receives at session start: one line per domain from the manifests’ When to Use bullets, plus the behaviour rules. crystalline prompt system prints it.
salience: A number from zero to ten in an engram’s frontmatter that gives hybrid search a small, bounded lift for the rare engram everything else hangs from. Relevance keeps the upper hand and nothing is ever excluded by it.
share on purpose: A person’s yes that lets a Reflection page carry text drawn from a domain fewer people may read than the page. Only a person gives it, never a run or an agent nobody signed in for, and it counts once per person, page and domain until the page’s readers widen (20 Knowledge across domains).
share-link: A revocable link that opens one engram in one person’s overlay to one colleague, who reads it and, after joining the draft, edits it in the normal editor where the domain’s write right allows. It is the only way one person’s drafts are ever visible to another.
source (of a domain): Where a domain comes from on one machine: the machine itself or one server its Crystalline is connected to. Every domain has exactly one source, a write always goes there and a server’s domains appear beside the local ones under one name each (Domains from shared servers). It isn’t an engram’s sources list, which names the places the engram was distilled from.
split: To move part of an engram into an engram of its own: by granularity, a distilled summary beside a source engram holding the full text, or by validity, when one fact expires while the rest holds. The new engram carries the source’s tags and type, a stable status and no validity window, and the pair is linked with derived_from and split_into.
status: The frontmatter field that says whether the knowledge holds. stable is the default; deprecated, superseded, archived and legacy are the retirement set, which fades an engram in ranking without removing it. The field is required and free form.
supersede: To retire a fact that was true and stopped being: write the replacement as a new engram with supersedes, set the old one to superseded with a real valid_to and a superseded_by, and carry any lesson forward. A fact that was never quite true is corrected in place instead. When only part of the engram has expired, first split out the facts that still hold, then retire what is left.
tag alias: A fold recorded in the manifest’s Tag Aliases section when crystalline tags merge unifies two spellings, so a filter on the old tag still finds what it always found.
team domain: A domain whose files also live in a GitHub repository, tracked through an origin, with knowledge travelling between members as proposals or as direct commits where the MANIFEST says so. It needs no git on any machine.
temporal validity: The window in which a fact holds, valid_from and valid_to, as plain dates. Absent valid_from means always valid, absent valid_to means valid forever. stale_after asks for a re-check by a date and source_date says when the source was written.
tombstone: The mark a deletion leaves in an actor’s overlay, hiding the file for that actor until a merged share removes it for everyone.
unattended run: A session nobody is behind, such as a scheduled loop run. It reads only the domains everyone who reads its domain may read, writes only into that domain and is never asked a question (14 The loops).
verification: The verified frontmatter entry, { by, at } plus the model when an agent verified, that records a re-check finding a fact still true, one entry per verifier. The sweep stops asking about a verified engram on age alone.
virtual domain: A domain that lives in the database with no folder on disk, for a container without a writable volume. It carries the same manifest and answers to the same tools.
write list: The domains an account may write to, each named or given as a prefix with *. Every other domain is read-only for that account while it still reads what it can see, and a list only takes rights away (16 Running a shared instance).