Glossary
A quick-lookup companion for invisible-string's vocabulary — one line per term, with a link to the page that covers it in depth. It's a lookup table, not a tutorial: read the Concepts pages first if you're new to the platform, and come back here when you need a fast reminder of what a term means.
| Term | Meaning |
|---|---|
| Agent | The product entity you build: a persona, a model, and the context it's equipped with. |
| agent editor | The UI surface for building an Agent — its Persona, Model, Context, and Access sections. |
| agent step | A pipeline step that delegates to a published Agent, dispatched as a child run. |
| agent version | An immutable published snapshot of an Agent, identified by a content hash. |
| allowlist | The workspace's list of provider-and-model pairs Agents are permitted to use. |
| artifact | The compiled build output (a tarball) of a published agent version — also called a compiled agent. |
| catalog | The curated, checked-in list of one-click connectors offered in the Add connection dialog. |
| child run | The agent run an agent step dispatches — a real session, linked from its parent pipeline run's step. |
| compiled agent | See artifact. |
| connection | A configured link to an MCP server, at workspace or personal scope. |
| content hash | The digest of an Agent's identity and definition — persona, resolved model and effort, context, compiler and eve versions, build environment — that identifies its published artifact. An unchanged definition never rebuilds, and two Agents never share an artifact, however alike they look. |
| context | What an Agent is equipped with: MCP connections and skills. |
| copilot | The AI assistant in both editors that proposes edits as typed, reviewable mutations. |
| cron expression | The five-field, UTC-evaluated schedule string that drives a Schedule trigger. |
| draft | The editable, autosaving version of an Agent or Workflow before it's published. |
| eve | The open-source agent runtime invisible-string compiles Agents into and runs on. |
| form trigger | A Workflow trigger that renders a shareable field-schema form. |
| infer step | A pipeline step that makes one direct model call on a workspace preset — text or declared structured output. |
| ingress token | The per-Workflow secret its webhook URL — and its form's submit URL — is authenticated by, shown once at generation. |
| MCP | Model Context Protocol — the standard invisible-string's connections speak to reach external tools. |
| model preset | A workspace-level pointer — provider, model, and reasoning effort — that Agents and infer steps select by name (powerful, balanced, quick). |
onComplete reply | A Workflow's declared end-of-run Slack reply template — rendered against the final run scope; nothing posts when none is declared. |
| overlap policy | Whether a trigger firing mid-run starts a second run. The default, skip, refuses it — protecting cursor state. |
| persona | The durable, natural-language description of an Agent's role and working style. |
| personal scope | A connection or skill visible only to the member who added it, across every workspace they belong to. |
| pipeline | A Workflow's step tree, interpreted by the platform when its trigger fires — no build, no compilation. |
| probe | The platform's automated health check of an MCP connection. |
| publish | For an Agent, compiling and building a new immutable version; for a Workflow, validating and snapshotting its pipeline — no build. |
| reasoning effort | How much a model reasons before answering, from provider-default/none through max. |
| reference | An @ token in a step's prompt, arguments, or conditions — @trigger.*, @steps.<slug>.*, @state.*, @item, @now — resolved against the run scope at run time. |
| registry | The official MCP server registry that invisible-string's community search mirrors and install-time verification checks against. |
| run | One execution: an agent run within a session, or a pipeline run of a Workflow. |
| run-as user | The workspace member whose credentials an Agent uses on every dispatch. |
| session | A conversation with a published Agent. |
| skill | Authored markdown-plus-attachments knowledge equipped onto an Agent. |
| Slack trigger | A Workflow trigger fired by mentions or messages in a connected Slack workspace. |
| step | One node of a pipeline: tool, infer, or agent does work; for_each, branch, filter, and state control the flow. |
| step slug | A step's handle — the name @steps.<slug> references its output by, unique across the pipeline. |
| step timeline | A pipeline run's record: one entry per executed step instance, with status, attempts, timing, and rendered input/output. |
| tool step | A pipeline step that makes one deterministic MCP tool call on a workspace connection — no model involved. |
| tool filter | A connection's allow- or block-list narrowing which of its tools an equipped Agent can call. |
| trigger | What starts a Workflow: manual, webhook, form, Slack, or schedule. |
| waiting | A run parked on a tool approval, a question, or a session-limit prompt — it still holds the session. |
| worker | The stateless process pool that boots and runs compiled agents. |
| Workflow | A standing delegation: a trigger and a pipeline of steps the platform interprets. |
| workflow state | A Workflow's durable key-value store — written by state steps, read as @state.*, surviving across runs. |
| workspace | The multi-tenant boundary every Agent, Workflow, connection, and session belongs to. |
| world database | The per-agent-version Postgres database holding that version's durable execution state. |
Easily confused
Agent vs. agent version vs. compiled agent. An Agent is the thing you build and edit — persona, model, and context, changing continuously as a draft. An agent version is one immutable published snapshot of it, identified by a content hash. A compiled agent (or artifact) is the actual eve build output that snapshot produced. You edit the first, runs are pinned to the second, and workers run the third.
A session vs. a run. A session is the whole conversation with a published Agent; an agent run is one execution within it. A session can contain many runs over its life — one per message you send, roughly — and a run finishing doesn't end the session it happened in.
A pipeline run vs. its child runs. A Workflow firing produces one
pipeline run — the step timeline. Each agent step inside it produces a
child run of its own — a real agent run with a session. The parent holds the
ledger; the children hold the transcripts.
A connection vs. the tools it exposes. A connection is the MCP server itself — its URL, its credentials, its health. The tools are what that server advertises once connected, narrowed further by the connection's own tool filter for equipped Agents — while a Workflow's tool step names exactly one of them per call.
Publishing an Agent (which builds) vs. publishing a Workflow (which doesn't). An Agent publish compiles its definition into a real eve project, builds it, and uploads the resulting artifact — a real build pipeline with real failure modes. A Workflow publish only validates the pipeline and snapshots it — it never builds anything, so it's effectively instant.