Quickstart

ArcFlow is the blazing-fast graph engine for modeling the real world — the persistence layer that stores, queries, and remembers actual world state. Spatial-temporal, confidence-scored, in-process. No server. No round-trip. One call to open a workspace, one query language for spatial proximity, temporal replay, graph traversal, and real-time algorithms.

Install#

curl -fsSL https://staging.oz.com/install/arcflow | sh

Or upgrade:

arcflow upgrade

Verify:

arcflow --version
arcflow gpu status    # shows CUDA/Metal acceleration if available

1. Interactive REPL — First World Model#

arcflow --playground

The playground opens with a pre-loaded world model scene. Try the queries that show what ArcFlow is:

-- Entities in the scene with their observation classes
MATCH (e:Entity) RETURN e.name, e.type, e._observation_class, e._confidence
 
-- Spatial: k-nearest entities to a point (ArcFlow Spatial Index backed)
CALL algo.nearestNodes(point({x: 0.0, y: 0.0}), 'Entity', 5)
YIELD node, distance
RETURN node.name, distance
 
-- Temporal: where were entities at a recent checkpoint?
MATCH (e:Entity) AS OF seq 500
RETURN e.name, e.x, e.y
 
-- Trusted entities only: observed, high confidence
MATCH (e:Entity)
WHERE e._observation_class = 'observed'
  AND e._confidence > 0.85
RETURN e.name, e.type
 
-- Graph algorithm: which entities are most central?
CALL algo.pageRank()

These five queries cover what distinguishes a world model from a database: spatial indexing, temporal memory, epistemic state, confidence filtering, and graph structure — composable in one query language.

2. Load Your Own Data — CSV Import#

arcflow

In the REPL:

:import csv /path/to/your/data.csv MyLabel

All rows become graph nodes with label MyLabel. Properties are auto-detected from CSV headers (strings, integers, floats).

Then query:

MATCH (n:MyLabel) RETURN count(*)
MATCH (n:MyLabel) RETURN n.column1, n.column2 ORDER BY n.column1 LIMIT 10

3. Real-World Example: Live Entity Tracking#

ArcFlow's core capability is incremental computation on a spatial-temporal world model — entities that move, relationships that change, and queries that stay current without re-running. Here is the pattern from a validated tracking pipeline:

Create a world model with positions and confidence#

CREATE (e1:Entity {
  name: 'Unit-01', type: 'ground',
  x: 12.4, y: 8.7, z: 0.0,
  vx: 0.5, vy: 0.0, vz: 0.0,
  _observation_class: 'observed',
  _confidence: 0.97
})
 
CREATE (e2:Entity {
  name: 'Unit-02', type: 'aerial',
  x: 34.2, y: 67.1, z: 12.0,
  vx: 2.1, vy: -0.8, vz: 0.0,
  _observation_class: 'observed',
  _confidence: 0.94
})
 
CREATE (e3:Entity {
  name: 'Contact-X', type: 'unknown',
  x: 80.0, y: 90.0, z: 5.0,
  _observation_class: 'predicted',
  _confidence: 0.38
})

Spatial proximity query (ArcFlow Spatial Index)#

CALL algo.nearestNodes(point({x: 0.0, y: 0.0}), 'Entity', 10)
  YIELD node AS e, distance
WHERE distance < 50.0
  AND e._observation_class = 'observed'
  AND e._confidence > 0.85
RETURN e.name, e.type, distance
ORDER BY distance

Live view — maintained incrementally, zero-cost reads#

-- Define once
CREATE LIVE VIEW trusted_entities AS
  MATCH (e:Entity)
  WHERE e._observation_class = 'observed'
    AND e._confidence > 0.85
  RETURN e.name, e.type, e.x, e.y, e._confidence
 
-- New data arrives → view updates automatically (not full recompute)
MATCH (e:Entity {name: 'Contact-X'})
SET e._observation_class = 'observed', e._confidence = 0.92
 
-- Read the current state (negligible overhead)
MATCH (row) FROM VIEW trusted_entities RETURN row

Temporal replay — query any past state#

-- Where were all entities at a previous checkpoint?
MATCH (e:Entity) AS OF seq 100
RETURN e.name, e.x, e.y, e._observation_class

4. SDK — Embed in Your Application#

TypeScript#

import { open, openInMemory } from '@ozinc/arcflow'
 
// Persistent (production)
const db = open('./data/world-model')
 
// In-memory (testing — fresh graph per test, no cleanup)
const testDb = openInMemory()
 
db.mutate(`
  CREATE (e:Entity {
    name: 'Scout-01',
    x: 12.4, y: 8.7,
    _observation_class: 'observed',
    _confidence: 0.97
  })
`)
 
const nearby = db.query(`
  CALL algo.nearestNodes(point({x: 0, y: 0}), 'Entity', 5)
  YIELD node, distance
  RETURN node.name, distance
`)

Python#

from arcflow import ArcFlow
 
db = ArcFlow(data_dir='./data/world-model')
db.execute("CREATE (e:Entity {name: 'Scout-01', x: 12.4, y: 8.7, _confidence: 0.97})")
result = db.execute("CALL algo.nearestNodes(point({x: 0, y: 0}), 'Entity', 5) YIELD node, distance")

Rust#

use arcflow::GraphStore;
 
let store = GraphStore::open_concurrent()?;
store.execute("CREATE (e:Entity {name: 'Scout-01', x: 12.4, y: 8.7})")?;
let result = store.execute(
  "CALL algo.nearestNodes(point({x: 0, y: 0}), 'Entity', 5) YIELD node, distance"
)?;

5. HTTP API — Connect From Anywhere#

arcflow --http 8080

curl -X POST http://localhost:8080/query \
  -H "Content-Type: application/json" \
  -d '{"query": "MATCH (e:Entity) WHERE e._confidence > 0.85 RETURN e.name, e.type"}'

6. Agent Integration#

Coding agents (Claude Code, Cursor, Codex, Gemini CLI) use the CLI binary — composable like grep, no protocol layer:

arcflow query 'MATCH (e:Entity) WHERE e._observation_class = "observed" RETURN e.name'
arcflow query 'CALL algo.nearestNodes(point({x: 0, y: 0}), "Entity", 5) YIELD node, distance'

Cloud chat interfaces (ChatGPT, Claude.ai, Gemini web) use the MCP server:

arcflow-mcp

7. What ArcFlow Replaces#

Traditional Stack	ArcFlow Equivalent
Graph database	Built-in graph store
In-memory cache	In-memory, zero-copy
Columnar analytics engine	Columnar scans, window functions
Streaming broker	CDC + standing queries
Vector database	vector index
Workflow orchestrator	Graph-native durable workflows
Separate spatial database	spatially indexed, composable with graph traversal

All share one GraphStore in unified memory. No serialization. No network hops.

Next#

Building a World Model — step-by-step with 20 entities, spatial queries, temporal replay, live monitoring
GQL / WorldCypher — the query language (ISO/IEC 39075, Cypher-compatible)
Autonomous Systems — robot fleets and UAV coordination
Digital Twins — live replica of physical systems

Reference#

Data Quality Guide — batch==delta equivalence, live DQ, pipeline integrity
Code Intelligence — queryable codebase graph for coding agents
From SQL to GQL — connect psql/DBeaver/Grafana via PostgreSQL wire protocol

Try it

Open ↗⌘↵ to run

Loading engine…