Glossary

Core terms used across ArcFlow documentation. Terms marked ArcFlow are specific to ArcFlow's implementation or extensions beyond standard GQL.

Node#

The fundamental unit of a graph. Represents an entity — a person, a document, a sensor reading, a transaction. Nodes have zero or more labels and zero or more properties.

CREATE (n:Person {name: 'Alice', age: 30})
--      ^label    ^properties

Relationship (Edge)#

A typed, directed connection between two nodes. Relationships have a type, a direction, and zero or more properties. Unlike a JOIN in SQL, a relationship is a first-class object stored in the graph — not derived at query time.

CREATE (a:Person)-[:KNOWS {since: 2020}]->(b:Person)
--                 ^type   ^property

Label#

A category tag on a node. One node can have multiple labels. Labels are used in MATCH patterns to filter which nodes to traverse.

CREATE (n:Person:Admin {name: 'Alice'})  -- two labels
MATCH (n:Person) RETURN n               -- match by label

Property#

A key-value pair stored on a node or relationship. Property values are typed: string, integer, float, boolean, list, point, or date/time types.

Pattern#

A template describing a subgraph shape. The MATCH clause holds a pattern; the engine finds all subgraphs that fit it. This is the core mental model of GQL — you describe a shape, not a condition.

-- Pattern: a Person connected via WORKS_AT to a Company
MATCH (p:Person)-[:WORKS_AT]->(c:Company)

Traversal#

Following relationships from one node to the next. Unlike a SQL JOIN (which scans tables), traversal follows pointer chains directly — the cost is proportional to the number of hops, not the size of the dataset.

Hop#

One step along a relationship between two nodes. A two-hop path: (a)-[:R]->(b)-[:R]->(c).

Path#

A sequence of alternating nodes and relationships from a source to a destination. Paths are first-class in GQL — you can bind them to variables, measure their length, and return them.

MATCH p = (a:Person)-[:KNOWS*1..3]->(b:Person)
RETURN length(p), nodes(p)

Variable-length path#

A path where the number of relationship hops is a range, not a fixed value. Written as *min..max after the relationship type.

MATCH (a)-[:KNOWS*1..5]->(b)  -- 1 to 5 hops

Directed graph#

A graph where relationships have direction — (a)-[:R]->(b) is different from (b)-[:R]->(a). ArcFlow's graph is directed. You can query in either direction or both.

Property graph#

A graph model where both nodes and relationships can carry arbitrary key-value properties. GQL (ISO/IEC 39075) is the standard query language for property graphs.

GQL#

Graph Query Language. The ISO international standard (ISO/IEC 39075, published 2024) for querying property graphs. Derived substantially from openCypher. ArcFlow's implementation is called WorldCypher.

openCypher#

An open specification of the Cypher query language that became a key input to the ISO GQL standard. ArcFlow passes 100% of the openCypher TCK (3881/3881 scenarios).

WorldCypher#

ArcFlow. ArcFlow's implementation of ISO GQL, extended with temporal snapshots, live queries, confidence scoring, spatial predicates, skills, and graph algorithm procedures. All standard GQL syntax works; WorldCypher adds what the standard leaves to implementations.

MVCC (Multi-Version Concurrency Control)#

ArcFlow. The mechanism that allows reads and writes to proceed concurrently without blocking each other. Reads use atomic snapshot swaps — no read lock, no contention with writers. Each write creates a new version; readers always see a consistent snapshot.

WAL (Write-Ahead Log)#

ArcFlow. The durability mechanism. Every mutation is written to the WAL before it's applied to the in-memory graph. On crash, the WAL replays to restore the last committed state. ArcFlow's WAL is the replication source for SWMR setups.

Observation class#

ArcFlow. A built-in property on every node (_observation_class) that records how the node's data was acquired:

Observation class is the foundation for confidence filtering — queries can restrict to only observed facts to get the highest-trust results.

Confidence score#

ArcFlow. A float [0.0, 1.0] on nodes and relationships (_confidence) indicating how reliable the data is. Set by extraction models, sensors, or manual curation. Queries can filter by confidence:

MATCH (a)-[r:DETECTS]->(b)
WHERE r._confidence > 0.8
RETURN a.name, b.name

World Model#

Two definitions share the same name in AI today.

Neural world model (AI/ML research sense) — an action-conditioned learned simulator. Given an observation and an action, it predicts the next state. Architecture: Vision model → Memory model (RSSM/MDN-RNN) → Controller. Examples include leading neural World Foundation Models (WFMs). These simulate possible futures; they are not databases and do not store factual history.

Operational world model (ArcFlow sense) — a persistent, spatial-temporal knowledge graph representing the actual state of a real or simulated environment. Entities have position, velocity, and observation class. Relationships carry provenance and confidence. The entire history is queryable via AS OF seq N. Stores neural world model outputs as _observation_class: 'predicted' facts alongside sensor-confirmed observations.

These two layers are complementary: neural world models simulate → ArcFlow records. See World Model for the full architectural picture.

Skill#

ArcFlow. A named, versioned, graph-native relationship derivation program. You describe a rule in natural language; CREATE SKILL sends it to your configured LLM endpoint once, receives a compiled WorldCypher graph pattern, and stores both in the skill node. Every subsequent PROCESS NODE and REPROCESS EDGES executes the compiled pattern directly — no model calls, no token cost, sub-millisecond per node. The LLM is a compiler frontend; ArcFlow is the runtime. Each edge a skill produces carries the skill name, version, and a confidence score derived from the graph structure.

Live view#

ArcFlow. A named, incrementally maintained query result. Created with CREATE LIVE VIEW, updated automatically as the underlying graph changes. Zero-cost reads — the result is pre-computed. Equivalent to a materialized view in SQL, but live — always current.

CREATE LIVE VIEW active_users AS
MATCH (u:User) WHERE u.last_active > timestamp() - 3600000
RETURN u.id, u.name

Live query#

ArcFlow. A standing query that re-evaluates when the graph changes. Written as LIVE MATCH or registered via db.subscribe(). The engine pushes deltas (added/removed rows) to the subscriber rather than requiring polling.

Trigger#

ArcFlow. A fire-once event binding. Declared with CREATE TRIGGER name ON :Label WHEN CREATED | MODIFIED | DELETED RUN SKILL skill_name. Unlike a live query — which maintains a result set continuously — a trigger executes exactly once per matching graph event. Use triggers for side effects (run inference on a new frame, enrich a new node). Use live queries for always-current result sets.

Program#

ArcFlow. A declarative capability manifest. A CREATE PROGRAM statement bundles a skill set, trigger bindings, I/O schema, executor transport, and hardware requirements into a single installable unit. Hardware validation runs at install time — if the machine doesn't meet the REQUIRES GPU clause, the install fails immediately with an explicit error. The executor is a separate OS process; the engine dispatches inputs and ingests outputs as standard graph mutations. Programs have CARDINALITY (SINGLETON, PER_SENSOR, or SHARDED BY key) and declare PROVIDES tags for capability discovery.

Evidence tier#

ArcFlow. The epistemic class assigned to all nodes a Program produces. Set via the EVIDENCE clause in CREATE PROGRAM. Four tiers: SYMBOLIC (pure graph logic, deterministic), WASM (compiled sandboxed skill), LLM (language model output, probabilistic), NEURAL (neural network, sensor-grounded). Tier propagates through the ArcFlow Evidence Model — downstream live queries can filter on _evidence_tier.

TCK (Technology Compatibility Kit)#

A test suite for verifying query language conformance. The openCypher TCK contains 3881 scenarios. ArcFlow passes all of them.

SWMR (Single Writer, Multiple Readers)#

ArcFlow. ArcFlow's replication topology. One primary node writes; read replicas follow via ArcFlow WAL Stream. Reads on replicas are fully consistent with the primary's committed state.

ArcFlow Graph Kernel#

ArcFlow. The execution model for graph algorithms. Instead of walking the graph one edge at a time, the Graph Kernel processes every algorithm as a single parallel pass across all nodes simultaneously. Maps directly to GPU thread blocks, but also runs more efficiently than pointer-chasing traversal on CPU.

ArcFlow Adaptive Dispatch#

ArcFlow. The cost-model-driven hardware router. At query time, Adaptive Dispatch measures graph size, available hardware (CPU, Metal, CUDA), and transfer overhead — then routes each operation to the fastest available backend with zero configuration. The developer writes one query; Adaptive Dispatch decides where it runs.

ArcFlow GPU Index#

ArcFlow. A pointer-free spatial index built for direct GPU traversal. Traditional spatial indexes use pointer-based tree structures that contain virtual memory addresses meaningless to GPU threads. The ArcFlow GPU Index is built as a flat, parallel structure that transfers to GPU memory without transformation, enabling the GpuLocal and GpuMulti dispatch lanes.

ArcFlow Spatial Index#

ArcFlow. The exact spatial indexing system for world model data. Backs all CPU-path spatial queries — K-nearest-neighbor, radius, bounding-box, frustum, and raycast. Returns exact answers, never approximate. Optimized for dynamic data: entities that move, zones that change, and sensors that update at frame rate. At GPU dispatch thresholds, ArcFlow Adaptive Dispatch promotes the index to the ArcFlow GPU Index for hardware-accelerated traversal.

ArcFlow WAL Stream#

ArcFlow. The high-throughput replication transport. In SWMR topology, the primary node streams WAL entries to read replicas via ArcFlow WAL Stream; replicas apply them in order and maintain full query consistency with the primary. The same transport drives object-store fan-out for durable cross-region replication (S3/GCS/Azure).

ArcFlow Evidence Model#

ArcFlow. The system that makes every fact in the graph epistemically graded. Every node and relationship carries three pieces of context: an observation class (observed, inferred, or predicted), a confidence score (0.0–1.0), and a provenance chain (which source, skill, or model produced it). Together these let queries filter not just on what is known, but on how well it is known — the foundation for trusted RAG, confidence-gated decisions, and audit trails that survive scrutiny.

ArcFlow Clock Domains#

ArcFlow. The mechanism for managing multi-rate temporal data from heterogeneous sources. Real-world environments produce observations from sources running at different rates — sensors, cameras, RFID readers, and models each advance at their own frequency. ArcFlow Clock Domains let each source maintain its own independent temporal sequence. The world model merges them without external alignment preprocessing, and each observation retains its originating domain in provenance metadata, so a query can distinguish readings from a 25Hz camera and a 1Hz RFID reader even when both describe the same entity at the same wall-clock instant.

See Also#

• Graph Model — detailed node/relationship/property model
• Graph Patterns — how to write pattern queries
• SQL vs GQL — mental model shift from relational to graph
• GQL Conformance — standards coverage
• Observations & Evidence — ArcFlow Evidence Model in depth
• Confidence & Provenance — scoring and tracing facts
• Programs — CREATE PROGRAM capability manifests
• Triggers — CREATE TRIGGER fire-once event bindings
• Temporal — ArcFlow Clock Domains and AS OF queries
• GPU Acceleration — ArcFlow Graph Kernel, Adaptive Dispatch, and GPU Index in depth
• Sync — ArcFlow WAL Stream and SWMR replication