Platforms

ArcFlow is a native graph engine. It runs at full speed on your machine, auto-detects GPU hardware, and scales from a single process to an autonomous mesh of nodes. Every deployment — desktop, server, mobile, edge — runs the same engine with the same WorldCypher query language and the same algorithms.

As agentic systems grow from one agent to agent swarms, the world model layer scales with them. A single agent starts with openInMemory(). A team of agents shares a persistent graph via filesystem. A distributed swarm syncs across nodes via CDC. You don't rearchitect. You don't swap tools. The world model that works in a single process works for a hundred agents querying and mutating shared state at the edge of a mesh.

Native Engine#

The core product. Full-speed native binary with automatic hardware detection.

# macOS / Linux / Windows
curl -fsSL https://staging.oz.com/install/arcflow | sh
arcflow --data-dir ./my-graph

ArcFlow auto-detects available hardware and adapts. Same query, different execution paths:

• CPU only — full algorithm suite
• CUDA GPU detected — large workloads route to GPU automatically
• Metal GPU detected — Apple Silicon UMA zero-copy acceleration
• Multiple cores — thread-safe via ConcurrentStore, parallel reads

Scaling: Single Node → Autonomous Mesh#

ArcFlow starts as a single process. When you outgrow one machine, it scales to a mesh of nodes that coordinate via CDC (change data capture) and WAL streaming.

    ┌─────────────────────────────────────────────┐
    │              ArcFlow Mesh                    │
    │                                              │
    │   ┌──────────┐  ┌──────────┐  ┌──────────┐ │
    │   │  Node A   │  │  Node B   │  │  Node C   │ │
    │   │  (GPU)    │  │  (CPU)    │  │  (GPU)    │ │
    │   │  Origin   │  │  Replica  │  │  Replica  │ │
    │   └─────┬────┘  └─────┬────┘  └─────┬────┘ │
    │         │              │              │      │
    │         └──────── CDC sync ──────────┘      │
    │                        │                     │
    │              ┌─────────┴─────────┐          │
    │              │  WAL → Object     │          │
    │              │  Storage (S3/R2)  │          │
    │              └───────────────────┘          │
    └─────────────────────────────────────────────┘

Each node runs the full ArcFlow engine. Writes go to the origin. Reads scale horizontally across replicas. CDC keeps replicas consistent. The mesh is self-organizing — add a node, it discovers peers and syncs.

Server Deployment#

Same engine, exposed over network protocols for multi-client access.

HTTP API#

arcflow --data-dir ./graph --http 8080

• POST /query — execute WorldCypher queries
• GET /status — engine metadata
• GET /health — readiness probe

TCP Server#

arcflow --data-dir ./graph --serve 7687

Line-delimited JSON protocol. For SDK drivers and lightweight clients.

MCP Server (Cloud Chat Interfaces)#

arcflow-mcp --data-dir ./graph

5 tools via stdio JSON-RPC: get_schema, get_capabilities, read_query, write_query, graph_rag. Read/write safety built in.

The Fragment Model#

A fragment is any lightweight ArcFlow instance that operates independently and syncs to ArcFlow World when connected. Browsers, mobile devices, and PanoNodes are all fragments.

Every fragment:

• Runs the full WorldCypher engine with local storage
• Works offline — no connectivity required to query or mutate
• Syncs delta to oz.com/world when a connection is available (CDC streaming)
• Never needs the full graph — it operates on its slice

The sync target is your OZ account at oz.com/world. Fragments from different devices merge automatically via CDC with LWW conflict resolution. A fragment that never connects still works — it's a fully functional local graph engine.

    ┌──────────┐   ┌──────────┐   ┌──────────┐
    │ Browser  │   │  Mobile  │   │ PanoNode │
    │ fragment │   │ fragment │   │ fragment │
    └────┬─────┘   └────┬─────┘   └────┬─────┘
         │              │              │
         └──── CDC delta sync ─────────┘
                        │
               ┌────────▼────────┐
               │  oz.com/world   │
               │  (full engine)  │
               └─────────────────┘

Mobile Fragments#

Mobile devices run ArcFlow as a fragment — a local instance that syncs to oz.com/world when connected.

iOS (Swift)#

import ArcFlow
 
let db = ArcFlow.open(dataDir: documentsPath)
db.execute("CREATE (n:Location {lat: 37.7749, lng: -122.4194})")

Static library (libarcflow.a). Metal GPU acceleration on A-series and M-series chips. Syncs upstream via CDC when connectivity is available.

Android (Kotlin)#

val db = ArcFlow.open(context.filesDir.absolutePath)
db.execute("CREATE (n:Sensor {type: 'accelerometer', x: 0.1, y: 9.8})")

JNI library (libarcflow.so). Runs on-device, offline-capable. Syncs when connected.

A mobile fragment captures data locally (sensor readings, locations, user actions). The local ArcFlow instance stores and queries it in real-time. When the device connects, CDC streams changes to oz.com/world — which has the full graph, GPU acceleration, and the complete algorithm suite.

Edge: Distributed Instances#

The same engine deploys to edge compute platforms for low-latency global access.

Cloudflare Workers#

import init, { execute } from './arcflow.js';
await init();
 
export default {
  async fetch(request) {
    const query = await request.text();
    return new Response(execute(query));
  }
};

Deno Deploy / Vercel Edge#

Same WASM binary, same API. Deploy ArcFlow at 300+ PoPs worldwide. Each edge instance handles reads locally and streams writes to the origin via CDC.

Browser Fragment#

Open ArcFlow Engine in your browser. No installation. Persistent storage. Works offline. Syncs to ArcFlow Cloud when you're ready.

The browser engine runs the same codebase compiled to WebAssembly. It's the fastest way to start. Open a URL and build your graph. Your data stays local until you create an account, at which point it syncs automatically.

When you need full native performance, export your graph and load it on native:

# Export from browser (JSON snapshot from IndexedDB)
# Import to native
arcflow --data-dir ./my-graph
> :restore browser-export.json
> CALL algo.pageRank()
# Now runs at native speed with GPU acceleration

What's the Same Everywhere#

What Varies#

See Also#

• Installation — install for your platform
• Language Bindings — Node.js, Python, Rust, Go, WASM, CLI
• Cloud Architecture — edge mesh, WAL segment shipping, CDC sync
• Agent-Native Database — integration surfaces: napi-rs, CLI, MCP