Glossary
Every project term in one sentence, alphabetical, each linking the concept page that defines it; generated from the pages' defines lists
What you'll learn
You met a word in the docs that carries a fixed meaning here and want that meaning and the page that explains it.
- what each project term means, in one sentence
- which page owns each term
The 73 words the docs use with one fixed meaning, one sentence each. Every entry links the concept page that defines it, and that page is where the meaning is explained with an example.
| Term | Means | Defined on |
|---|---|---|
| adapter | Whatever a step's use line names, a binding or a process adapter, that reads and writes records in one role. | Two adapter tiers |
| answer | gtme answer, the one write path for a participant's judgment on a pending record, checked against the step's declared outputs on the spot. | Participants |
| armed | gtme run with no flag, the run that spends and sends. | The gate ladder |
| binding | A vendor adapter written as a YAML file the runner interprets, with a request template and an extract map and no code. | Two adapter tiers |
| bindings registry | The public index of bindings on GitHub that gtme adapters search reads and gtme adapters add installs from at a pinned commit. | Two adapter tiers |
| bundle | A folder holding a run's exact configuration as text, with a manifest of hashes, which gtme run accepts anywhere it accepts a pipeline file. | A campaign is a folder |
| bundle manifest | The manifest.json in a bundle that lists every frozen file with its SHA-256 hash, which gtme run verifies before it reads a record. | A campaign is a folder |
| cache window | The cache duration on a step, within which a value the step already wrote counts as fresh and the step is skipped for that record. | Facts have provenance |
| canonical field | A field name with one meaning across every adapter, listed in the registry for its record type with a type and a normalization rule. | Canonical fields |
| coalesce | What a sourced or traversed row does when it resolves to an identity already in the ledger or the run, so it stays one record. | Types and traverse |
| collect | What the next gtme run does with a pending run: read the recorded answers and move the answered records on. | Participants |
| compose | The role that reads the uses fields and writes new field values, such as an opening line. | Steps and roles |
| confidence | A number from 0 to 1 a source attaches to each field it writes, 1 unless it says otherwise, which ranks ahead of recency when values conflict. | Facts have provenance |
| current value | The row that wins for a field, the highest confidence and then the newest, computed by a view whenever something asks. | The ledger |
| deliver | The role that reads the values named in variables and sends them to a target, writing a delivery row; the one step the gate ladder holds back. | Steps and roles |
| delivery | The row a deliver step writes when a record is sent or handed off, carrying its target, scope, idempotency key, and status. | Runs and receipts |
| dry-run | gtme run --dry-run, a real run with every deliver step held back, so it spends and writes facts and sends nothing. | The gate ladder |
| enrich | The role that reads the fields its manifest requires and writes new fields, skipping a record whose values are still fresher than its cache window. | Steps and roles |
| exit code | The number a gtme command ends with, one per kind of failure: 0 ok, 2 a refused file or value, 3 a missing credential, 4 rate-limited, 5 network, 1 anything else. | Agent-operable by design |
| fact | One row in field_values saying who wrote what value for which field of which identity, how sure it was, and when. | Facts have provenance |
| field registry | The file per record type under spec/fields that lists its canonical fields with their tier, type, and normalization rule. | Canonical fields |
| filter | The role that reads the uses fields and writes a verdict, pass or fail with a reason, the only role that can stop a record. | Steps and roles |
| fixture | A recorded vendor response shipped beside a binding, which verification and simulate run offline instead of calling the vendor. | Two adapter tiers |
| floor | The adapter families built into the binary, csv, http, sql, ai, and group, the crudest working version of any integration. | Two adapter tiers |
| freeze | gtme freeze, which prints the pipeline a run stored or, with --bundle, writes the whole campaign bundle. | A campaign is a folder |
| gate ladder | The four ways to run a pipeline, simulate, plan, dry-run, and armed, each spending, writing, or sending more than the one before. | The gate ladder |
| group | A named set of identities stored in the ledger, which a pipeline adds to at its end, gates on, or sources from. | Groups and segments |
| handoff | A group/deliver step or a top-level group key that adds finished records to a group, the write that lets a second pipeline pick them up. | Groups and segments |
| idempotency | The rule that a delivery with the same key, target, and scope as an existing row is not made again. | Runs and receipts |
| identity key | The one normalized string, an email, a public LinkedIn URL, a domain, or a name hash, that says which record a row is about. | Identity keys |
| key tier | The order the identity fields are tried in, email first, so a record carrying two keys is named by the stronger one. | Identity keys |
| key upgrade | What happens when a later row matches a record by a weak key and carries a stronger one: the record keeps its id and facts and takes the stronger key. | Identity keys |
| ledger | The one append-only SQLite file where every fact gtme learns lives, which steps read from and write to instead of passing records to each other. | The ledger |
| leg | The stretch of a run between type changes, where every record is of one type. | Types and traverse |
| manifest | An adapter's declaration of its id, version, role, entity type, needs, provides, with keys, and credentials, the one surface plan reads. | Two adapter tiers |
| mint | To create a new identity in the ledger, which a source or a vendor traverse does and sql/traverse never does. | Types and traverse |
| name hash | The weakest identity key, a SHA-256 of a person's name and company domain prefixed nh:, used when a row carries no stronger key. | Identity keys |
| namespaced field | A field whose name carries a prefix and a dot, a vendor's like apollo.id or a pipeline's like cache.first_line, for a fact only that vendor or that campaign has. | Canonical fields |
| NDJSON | Newline-delimited JSON, one object per line, the format a process adapter reads and writes. | Two adapter tiers |
| normalization | The rule that puts a value in its stored form before it is compared or keyed, such as lowercasing an email or reducing a domain to its registrable part. | Canonical fields |
| participant | Whoever answers a filter, compose, or review step: a model under ai/, a person under human/, or an agent under agent/. | Participants |
| payload | A raw vendor response kept as a purgeable cache beside the facts, which no step reads and gtme vacuum evicts. | The ledger |
| pending | The status of a run that ended with records waiting on a participant or an in-flight batch, which the next gtme run resumes instead of sourcing anew. | Participants |
| pipeline | A YAML file with a source that brings records in and a list of steps the runner executes in order, each naming an adapter. | A pipeline is a YAML file |
| plan | gtme plan, which checks every field and credential a pipeline needs and prices each step, with no network and no spend. | The gate ladder |
| preflight | A deliver adapter's read-only check of its live target before anything sends, which a dry-run prints and an armed run enforces. | The gate ladder |
| process adapter | An adapter that is a program in any language, exchanging records as NDJSON over stdin and stdout, for anything a binding cannot express. | Two adapter tiers |
| projection | The current value of each field a step declared it reads, and nothing else; what a step sees. | The ledger |
| provenance | The source, run, confidence, and time recorded on every fact, so any value can be traced to what wrote it. | Facts have provenance |
| receipt | The table a run ends with, one row per step, counting records in, out, empty, cached, filtered, and failed, with the dollars each step spent and avoided. | Runs and receipts |
| referent | The value a review or an edit is about, named by of, whose current value joins the cache key and whose row becomes the output's provenance. | Steps and roles |
| relation | A typed link between two identities the ledger holds as a fact, like works_at from a person to a company. | Types and traverse |
| resume | gtme run --resume, which continues a stopped run under the same id from each record's last completed step. | Runs and receipts |
| review | The role that reads one value named by of, with the uses fields as context, and writes labels about it as fields without ever gating. | Steps and roles |
| role | What a step's adapter declares it does, one of source, enrich, verify, filter, compose, review, deliver, or traverse, which decides what the step reads, writes, and whether a record can stop there. | Steps and roles |
| run | One execution of a pipeline, identified by a ULID, plus every ledger row written under that id. | Runs and receipts |
| segment | A saved read-only query over the ledger that runs fresh every time it is used. | Groups and segments |
| send surface | The list plan prints of every deliver step in a pipeline, the steps that send. | Steps and roles |
| signal | A type a pipeline finds and traverses from and can never deliver to, like post, marked kind signal in its file. | Types and traverse |
| simulate | gtme run --simulate, which runs the whole pipeline offline from fixtures, spends nothing, sends nothing, and keeps nothing. | The gate ladder |
| source | The top of a pipeline file, which brings records in from a file, an API, or a group before any step runs. | A pipeline is a YAML file |
| stderr | The output stream gtme writes everything meant for a person to, such as plans, progress, receipts, and errors. | Agent-operable by design |
| stdout | The output stream gtme reserves for data, such as query rows, record JSON, and frozen YAML, so a program can read it without cleanup. | Agent-operable by design |
| step | One entry in a pipeline's steps list, named by its id, that runs one adapter in one role and reads and writes the ledger. | A pipeline is a YAML file |
| subject | A type a pipeline delivers to, like person or company, marked kind subject in its file. | Types and traverse |
| suppression group | A group named by a suppress rule on a deliver step, which withholds a send from anyone touched in that group within a window. | Groups and segments |
| touch | A touched event recorded in a group per successful delivery, which counts contact history without changing membership. | Groups and segments |
| traverse | The step role that takes records of one type in and emits related records of another type, after which only the children move forward. | Types and traverse |
| type | A file that says what kind of record something is, how it is keyed, and which fields it has; person, company, and post ship built in. | Types and traverse |
| ULID | An id that sorts by the time it was made; every run and most ledger rows have one. | Runs and receipts |
| verdict | The pass or fail a filter writes for a record, with a reason, which the ledger keeps and a when gate reads. | Steps and roles |
| verify | The role that checks a field and writes fields, cached like enrich; it is in the manifest schema and no shipped adapter uses it. | Steps and roles |
| wire protocol | The NDJSON message contract between the runner and a process adapter. | Two adapter tiers |