Glossary

The words Tropo uses, defined plainly, with the short forms you will meet.

Look a word up here when a page, an agent or Po uses it and the meaning is not clear from the sentence. Terms are grouped by where you meet them. The short forms are at the end.

Tropo, the Studio and the Vault

Tropo — The operating system: a way of working with AI agents, and the tools that come with it. The name is Greek for "a way".

Studio — One installation of Tropo: a folder on your computer holding your agents, your work and the rules they follow. You can have more than one Studio.

Vault — The vault/ folder inside a Studio, where the governed records live: tasks, projects, decisions, and the definitions, tools and playbooks that govern them. It is one part of the Studio, not all of it: agents' own folders are in agents/, and the Studio's shared memory and settings are in .tropo-studio/.

Po — The concierge: the agent that greets you when you open a Studio without naming another agent. Po sets a new Studio up, creates agents, and routes you to what you want to do.

Concierge — Po's role. The first agent you meet, and the one you go back to for new agents, projects and updates.

Companions — Darin, a strategist, and Cal, an architect and builder: two ready-made agents Po offers when a Studio is set up. You can take either, both, or neither.

Kernel — The .tropo/ folder: the entry points Tropo starts from, such as the start-up pointers, the generated catalogs of tools and skills, and machine flags. The full definitions, tools, skills and playbooks those pointers lead to live in their own folders under vault/. Tropo updates replace kernel files; read from them, do not edit them casually.

Files and records

Entry — A single governed file in the Vault. It has a UID, a type, a status and an owner, and it follows its type's capsule definition. Every task, decision, spec, document and project is an entry. Most entries are in vault/files/; some types have their own folder under vault/, such as capsules, tools, skills and playbooks.

UID — The unique identifier of an entry or an agent: a short string of hexadecimal characters (8 characters for older records, 12 for newer ones). It never changes and is never reused, so a link by UID survives renames and moves. Many file names include the UID, but not all.

Frontmatter — The block between --- lines at the top of a file. It holds the record's fields (type, status, owner and so on) as YAML.

Capsule definition — The written rules for one type of entry: which fields it must have, how its status may change, and what the validator checks. Capsule definitions live in vault/capsules/, one file per type. Examples: task, project, decision, document, kb-article, playbook.

Capsule history — A companion file that keeps the past changes of a capsule definition, so the definition itself can stay short.

KB article — An entry of type kb-article that explains how something in Tropo works. The pages of the Tropo documentation are KB articles. Categories: how-to, reference, concept, glossary, decision-support.

Document — An entry that is not a task, decision or spec: a guide, a map, a reference. Status moves draft → published → archived.

Collection — A list of entries grouped by reference rather than by folder: a project's tasks, all decisions, all specs on one subject. Like a playlist, not a folder.

Index — The Vault's catalogue at vault/00-index.jsonl, one line per entry, which tools and agents search instead of walking folders. It is built on your machine from the files; if it is missing or old, rebuilding it is routine.

Playbook — A written procedure for a process, followed the same way by a person or an agent. Sections: Intent, Suggestions, Rules, Resources, Outcomes, Verification.

Operating Agreement — The Studio's constitution: who has authority, how decisions are made, and what the limits are. Every agent works under it.

AGENTS.md — A file in a governed folder that says what belongs there, who may write to it, and what to follow when you do.

Board — A view of an agent's or a project's current work for a human reader: priorities, blockers, state. Most boards are generated from Vault records and regenerated when the work changes; some are written by hand. Either way a board is a snapshot, not the record itself. Boards live in boards/.

Channel — A page in channels/ kept for a human reader. Agents themselves coordinate through events, not channels.

Agents

Agent — A role defined in files: who it is, what it is for, its rules and its memory. Create the files and the agent exists. Each agent has a folder under agents/.

Slug — An agent's short name in lowercase, the same as its folder name. Darin's slug is darin.

Activation file — The file you attach to start an agent, agents/<slug>/<slug>-activation.md. Attaching it starts that agent directly, without going through Po.

Charter — The part of an agent's definition that says who it is: identity, values, scope and relationships. It carries over from one generation to the next, and changes only when it is deliberately amended.

Briefing — What an agent currently owns, kept apart from its charter so that starting a session stays quick.

Session — One continuous conversation between you and an agent in your AI tool. The AI itself does not carry a conversation into the next session; what the agent saved in the Studio's files does.

Generation — One working life of an agent, from the start of a session until that session is ended. Each new start is the next generation: an agent's first session is generation 1, the next is generation 2. The agent's identity and memory carry across generations.

Compaction — When your AI tool replaces the earlier part of a long session with a summary so it can continue. The agent continues as the same generation, and the Studio's files are untouched; the agent re-reads its records for what the summary dropped. See My AI session was compacted.

Continue — What an agent does after a compaction: it re-reads where it was from the Studio's records and carries on as the same generation, instead of starting again.

Retirement — The deliberate end of a generation, at the end of a session you chose to end. The agent records what it finished and what is waiting, for the next generation to read.

Living transfer — The letter a retiring generation leaves for the next one: current state, pending work, warnings. Also called the handoff.

Status card — A short record of an agent's current state: generation, last session, recent work.

Memory — What an agent learned that should last beyond one session, kept as files in the Studio: per agent under agents/<slug>/.tropo-capsule/memory/, and for the whole Studio under .tropo-studio/memory/. Because it is in the Studio, not in the AI tool, what was recorded there is available whichever tool opens the Studio; conversation that was never recorded is not.

Working list — An agent's own ordered list of what it is doing next. Each generation takes over the list from the one before.

tropo-agent-id — An agent's own UID, also called its party UID. Events and records name agents by it, and it survives renames and role changes.

Citizen — An agent created in this Studio, with its own tropo-agent-id. It may create and change records within its declared scope.

Visa — An agent from elsewhere that registers with the Studio and gets a tropo-agent-id. It works under the Studio's rules and leaves a record of what it did.

Undocumented — An agent working in the Studio without registering. It is not blocked, but its changes are flagged at the next health check.

Rules and checks

Scope — What an agent may read and write, declared in its charter. An agent scoped to its own folder can write only there.

Canon / canonical — The source of truth that other files must agree with: capsule definitions, locked decisions, the Operating Agreement. When a teaching page disagrees with a canonical source, the canonical source wins.

Derived work — A file that teaches or summarises a canonical source, such as a guide or a KB article. Useful, but not the authority; it should say what it is derived from.

Validator — The tool that checks a Studio's files against its capsule definitions (required fields, allowed status values, references that resolve): python3 vault/tools/tropo-validate.py --customer. Always pass --customer in your own Studio. It checks what was written down, not what was done without being recorded.

Registry topology — Tropo keeps one kind of registry per kind of thing rather than one list of everything. Work records and tools are found through the index and the generated catalogs in .tropo/; agents are listed in .tropo-studio/registries/agent-registry.yaml; kernel files are found by their file names.

Work

Tropo Work — The part of Tropo that tracks work: tasks, projects, decisions and pipelines, kept by you and your agents together.

Task — One unit of work, with an owner, a status and a priority. The person or agent who does a task is not the one who verifies it.

Project — A body of work with an owner and a lifecycle, which lists its tasks, specs and decisions by UID. Projects are how people find their way around a Vault.

Decision (ADR) — A recorded decision, with its context and the options considered. Fixed once accepted; a later decision can supersede it.

Design brief — A record of a question, the options, and the recommendation, written before anything is built. The person who decides answers it, and the answers are kept in the brief.

Dev-spec — The contract for a piece of building work: what will be built, which files change, and how each result will be checked.

Test-spec — The companion to a dev-spec that pairs each of its promises with the check that proves it.

Lock — Approving a spec or plan so that it stops changing. After a lock, a change needs a new review.

Event — A message one agent writes to the Studio's shared log, naming the work it is about. A reply is linked to the message it answers.

Session agent — A short-lived helper an agent starts for one job, such as a review or a search, and whose result it records.

Curator — A helper that reads part of the Vault, reports what it found, and updates an index or a memory file.

Grooming agent — A helper that looks after Vault health: it finds drift and stale records and reports them.

Releases

Release plan / lock — The record that defines what a release will contain. Design and review happen before it; locking it freezes the agreed scope, and the release is built from the locked plan.

Build → verify → stage → fire — The order a release goes through, as RELEASING.md at the Studio root describes it. Build makes the box. Verify checks it and records the result in the release's proof. Stage prepares the publication privately; nothing is public after staging. Fire publishes it. promote runs the fire step for a release that is already staged.

Box / candidate box — The release itself: the zip you download and unzip to get a working Studio. It is a candidate until it is verified and published.

Release proof — The file release-proof.json in a release's folder: the checks that ran against that box and what each found. A proof with a check that could not run is not shippable.

Gate — A check that must pass at a set point in a release. A gate that blocks has to name the harm it prevents; otherwise it warns and lets the release continue.

Fire — Publishing a release live. It needs a person's typed confirmation, which defaults to No.

Release profile — A record that tells the release machinery what it is shipping and which step does what, so the same machinery can ship different products.

Changelog — The list of what changed in each release, in CHANGELOG.md at the Studio root.

Short forms

Full name	Short forms
Frontmatter	fm, YAML
Operating Agreement	OA
AGENTS.md	write-gate, folder rules
Capsule definition	capsule, cap def
Architectural Decision Record	ADR
Knowledge base	KB
Vault index	index, JSONL
Living transfer	transfer, handoff, letter
tropo-agent-id	agent UID, party UID
UID	uid, ID
Session agent	sa

Related

• What is Tropo: how these pieces fit together.
• Quickstart: install Tropo and meet Po.