Glossary
Every term in alphabetical order. Each entry links to the deep-dive page.
TIP
Read this page top-to-bottom for a 5-minute conceptual tour of the system.
add-dataset-case
One of the three operations oe evolve can propose. Adds an item to a list a tool seeds. See Evolution loop.
add-node
The most powerful evolution operation. Proposes adding a new node + edges to address a gap the advisor observed. See Evolution loop.
advisor
EvolutionAdvisor — the LLM-backed component that reads a run's events + state diff and proposes graph upgrades as git apply-ready diffs. See EvolutionAdvisor API.
agent
A node kind that calls an LLM with a prompt + inline JSON schema and validates the structured output via AJV. The most common LLM-touching node. See agent node deep dive.
AJV
The JSON-schema validator the runtime uses for agent structured outputs. Compiled once per node at resolve-time. See Code-as-Law.
args:
A YAML block on a node specifying literal arguments passed to the dispatcher. Tool nodes get them spread into the function call; agent nodes interpolate them into the prompt.
array_append
A state field merge strategy that concatenates arrays. Used heavily with for_each so iterations accumulate findings. See State.
blackboard
Synonym for the SQLite-backed state store. All nodes read/write fields against the same blackboard. Field schemas declared in state.schema enforce the contract. See State.
cache
Per-content-hash memoization of NodeOutput. Same inputs → cached result on re-run. Backs oe resume. See Cache.
cli-agent
A node kind that spawns a subprocess for claude / codex / gemini / your-own-CLI. The cross-vendor showcase. See cli-agent deep dive and tri-cli example.
Code-as-Law
Our central thesis: the graph is declared in version-controlled YAML and never changes at runtime. The LLM only fills in node bodies, not the flow. See Code-as-Law.
concurrency:
Two flavors. runtime.concurrency: N (top-level) — outer scheduler runs N independent nodes in parallel. for_each.concurrency: N (per-node) — inner fan-out runs N iterations in parallel. They compose.
conditional edge
An edge with a when: JSONPath-ish expression. If the expression is false, the target node is skipped. See Control flow.
dataset
A node kind that loads rows from a file / SQLite / HTTP / MCP resource. Typically the first node in an ETL-style flow. See dataset deep dive.
DAG
Directed acyclic graph. Edges express dependency, not data transport. Validated by oe validate before any run. See Control flow.
dispatcher
The component that knows how to execute one node kind. One dispatcher per kind. Pluggable via the DispatcherRegistry. See Dispatchers.
edge_output
The optional second return value from a tool: data passed to direct successors via _edge_inputs without committing to state. Use for transient values you don't want in your audit trail.
event
A single runtime moment — node.started, state.write, node.tokens, etc. Emitted by EventBus, persisted as one line per event in .openexpertise/runs/<run-id>.jsonl. See Events.
evolution
Author → run → evolve loop. The advisor proposes; you git apply. Closes the loop where the same LLM authored, ran, and now upgrades the graph. See Evolution loop.
experience
A single workflow — one experience.yaml + its tools/, prompts/, optional skills/. The unit of authoring, running, and evolving. See What is an experience?.
experience (node kind)
A node kind that nests another full experience inside the current one. Useful for composing reusable sub-workflows. See experience node deep dive.
for_each
Fan-out primitive: run the same node once per element in a JSONPath array source. With concurrency: N, iterations run in parallel. See Control flow.
JSONL
JSON-lines event log. One event per line, append-only, crash-safe via appendFileSync. Lives at .openexpertise/runs/<run-id>.jsonl. See Events.
JSONPath
The (tiny) DSL used in when: clauses and for_each.source. Supports $.field, $.field.subfield, length($.array), comparison + boolean operators. See Control flow.
last_wins
A state field merge strategy: each write overwrites the previous value. Default for scalar fields. See State.
LLMClient
The provider-agnostic facade for LLM calls. Wraps Anthropic + OpenAI SDKs behind one complete() method with tools, structured output, retries. See LLMClient API.
MCP server
oe-mcp — the Model Context Protocol server that exposes OE's primitives as tools any MCP-compatible client (Claude Desktop, Cursor, etc.) can call. The inbound bridge. See MCP server guide.
merge strategy
How a state field combines successive writes. Three options: set_once (first write wins), last_wins (each overwrites), array_append (concat). Required in state.schema. See State.
node
A vertex in the graph. Has a kind, an id, declares reads and writes against state. Dispatched by the kind-specific dispatcher. See Node kinds.
node kind
One of six: tool / agent / skill / dataset / experience / cli-agent. Each has its own dispatcher and its own YAML shape. See The 6 node kinds.
oe
The CLI binary. Aliases: npx @openexpertise/cli or node packages/cli/dist/bin.js while developing. Commands: init, validate, run, resume, inspect, state, reset-state, evolve, diff, ultra, doctor. See CLI reference.
on_error
Per-node failure policy: fail (default), skip (continue, cascade skip), retry (with max_attempts and backoff_ms). See Error policies.
parallel scheduler
The wave-based scheduler that runs all ready-at-the-same-wave nodes concurrently up to runtime.concurrency. The default when concurrency > 1. See Scheduler.
phase
A label on nodes / pipelines / loops grouping execution stages. Useful in the TUI for visual grouping and in events for filtering.
pipeline
A group of nodes that runs per-item end-to-end before the next item starts. Useful for ETL-style row processing. See Control flow.
prompt file
A .md file referenced by an agent or skill node. Plain markdown with {{var}} interpolation. Lives next to experience.yaml. See Prompt files.
provider
The LLM backend (anthropic / openai / claude-code / codex / gemini). Configured in env or runtime.providers. Different node kinds pick which to use. See Run with LLM.
reads: / writes:
Per-node lists declaring which state fields the node consumes / produces. Used by the scheduler to determine dependencies (combined with edges). Auto-validated against state.schema. See State.
resume
Re-run an experience from where a prior run failed or was interrupted. Cached steps skip; only dirty or downstream-of-dirty nodes execute. See Resume + cache.
runExperience
The programmatic API for executing an experience without the CLI. Used inside services, tests, custom UIs. See runExperience API.
run-id
A run's unique identifier (run-2026-05-26-a1b2c3 format). Used by oe inspect, oe state, oe diff, oe evolve. Lives in the events log filename and in every event payload.
SCHEMA.md (alternate spelling)
The published JSON schema for experience.yaml. Imported by IDEs for autocomplete. See YAML schema reference.
set_once
A merge strategy: only the first write to a field is accepted; subsequent writes error. Use for inputs that must not be re-derived. See State.
sequential scheduler
The simpler scheduler — runs ready nodes one at a time in topological order. Used when runtime.concurrency is 1 (the default). See Scheduler.
skill
A reusable LLM capability packaged as SKILL.md (frontmatter + body). Invoked by kind: skill nodes. Similar shape to Anthropic skills. See skill node deep dive.
SOP
Standard Operating Procedure. The kind of workflow OpenExpertise was designed for: same steps every time, leaves a trail, gets better at it.
state
The SQLite blackboard. Fields declared in state.schema, written by nodes, queryable via oe state. See State.
state.schema
The contract for what fields exist, what their type is, and how successive writes merge. Validated at oe validate time. See State.
structured output
The pattern where the LLM is forced to call a specific tool (structured_output) whose argument schema is the agent's inline AJV schema. Guarantees shape. See agent node deep dive.
subagent
In OpenExpertise's docs this term is reserved for Claude Code's Agent tool — not OE itself. We don't have a "subagent" primitive.
tool
A node kind that runs a JS function. Deterministic, no LLM. The most common node. See tool node deep dive.
TUI
Terminal UI dashboard, rendered with Ink/React. Shows live node status, current activity, tokens. Enabled with --tui. See TUI dashboard.
tune-param
One of three evolution operations. Tunes an existing node's parameter (timeout, concurrency, on_error policy, etc.). See Evolution loop.
ultra
The CLI subcommand oe ultra "<task>" that asks an LLM to author a complete experience (YAML + tools + prompts) for a task. The single-keyword authoring shortcut. See oe ultra command and UltraExpertise API.
v-pre
VitePress directive for "don't parse Vue syntax". Used in Prompt files docs where literal {{ is needed.
wave
The unit of parallel-scheduler execution. All ready-at-the-same-wave nodes run concurrently; the next wave begins when the current one's nodes are done or in flight up to concurrency limit. See Scheduler.
when:
A JSONPath-ish boolean expression on an edge. If false, the target node is skipped. The conditional control-flow primitive. See Control flow.
workflow
A synonym for "experience" — what OpenExpertise codifies. Anytime your team does the same multi-step thing repeatedly with some LLM judgment in the middle.
YAML schema
The single source of truth for experience.yaml shape. Validated by oe validate. Drives editor autocomplete. Published as JSON Schema at /reference/schema.