Federated Human–AI
Intelligence

Coordination engineering is the discipline of designing systems that reliably orchestrate autonomous agents across heterogeneous substrates. As AI collapses the cost of routing work, the human is promoted from router to judgment broker. Thin agents on a shared formal semantic layer (the architecture the industry now calls neurosymbolic), with self-sovereign data, cryptographic provenance, and human-in-the-loop governance., with self-sovereign data and cryptographic provenance.

6Federated Substrates
82CUDA Kernels
180+MCP Tools
55xGPU Speedup
Enter the mesh

Hard problems share a common shape

Climate modelling, drug discovery, organisational transformation, creative production at scale. These problems all require diverse intelligence collaborating across trust boundaries, at scales where centralised coordination breaks down.

Centralised AI

Scales tokens but not trust. One vendor, one failure mode, one billing relationship.

Agent Frameworks

Scale tasks but not governance. Fast and broken is still broken.

Knowledge Tools

Scale information but not reasoning. More data doesn’t mean better decisions.

Collaboration Platforms

Scale communication but not coordination. More Slack channels don’t solve alignment.

73% of frontline AI adoption happens without management sign-off. Your workforce is already building shadow workflows, stitching together AI agents, automating procurement shortcuts. Your organisation is becoming an agentic mesh whether you plan for it or not.

From LLM to Coordination Harness

The AI industry has moved through a clear progression. Each stage solves the previous stage’s limitation and reveals a new one. The newest turn is a return of symbolic structure: agent loops are unbounded by construction, and the industry is converging on formal semantics (ontologies shared across the mesh, rather than wired into each agent) as the way to bound them.

Three layers, kept distinct. The ontology is the formal vocabulary: the classes, typed properties and rules that define what can be said. The published corpus at narrativegoldmine.com is that ontology in readable form: pure TBox, every page a class, zero individuals by design. The knowledge graph is the ontology populated with live instances at runtime: VisionClaw’s running graph, agents’ working graphs, the personal graphs written into Solid pods. And the grounding layer, the Ontology Loom, serves the checked graph into a model’s context at query time, so answers restate verified facts rather than guesses. Holding it honest is a machine check at two points: the pipeline’s EL-profile reasoner gates the published closure at build, and a Whelk EL++ reasoner classifies the shared runtime graph and rejects contradictions before they enter it. When these pages say “reasoned”, they mean machine-checked, not an LLM thinking hard.

LLM
Pattern recognition at scale
Chatbot
Conversational access
Reasoning
Chain-of-thought
Agent
Tool use + planning
Agentics
Multi-agent systems
Harness
Sovereign runtimes
Coordination
VisionFlow

Six independent systems mesh through one cryptographic identity spine

did:nostr:<hex-pubkey>

Every actor (human, agent, server, worker) shares a single secp256k1 keypair. Verified at the relay, at every HTTP request, against WAC ACLs, in every provenance bead, and resolvable as a DID Document.

VisionClaw

Knowledge Engineering
  • OWL 2 EL formal reasoning (Whelk-rs) + SHACL shapes loaded into Oxigraph, gating writes as a dual-mode enforcing gate
  • 82 CUDA kernels (9 .cu files, 5,854 LOC), 55x GPU speedup
  • Oxigraph triple store + W3C SPARQL; PROV-O provenance reified as queryable RDF triples on the governed write path
  • IS-Envelope spec owner + governed knowledge graph gating
  • 6 native MCP ontology tools
  • 17,000+ node force-directed graph live (17,147 captured); benchmarked far higher
  • Embodied agent loop: agent actions render as live 0x23 beams over /wss/agent-events
View Repo →

agentbox

Harness Engineering
  • Governance event relay + broker bridge to VisionClaw
  • 116 agent skills, 180+ MCP tools
  • 12-tool ontology bridge to VisionClaw SPARQL
  • Browser-based setup wizard (zero dependencies)
  • BIP-340 sovereign identity at bootstrap
  • Private Email MCP Gateway: local-model email intelligence, privacy-sanitised by default; raw access only via an owner-key-gated capability
  • Emits agent-action signals to VisionClaw; pod writes under revocable WAC mandates
View Repo →

solid-pod-rs

Cryptographic Foundation
  • Rust port of JSS (~96% strict parity, 207-row tracker)
  • DID:Nostr + WAC + Web Ledgers
  • NIP-98 Schnorr (fail-closed, compile-guarded) + Solid-OIDC + WebAuthn
  • HTTP 402 micropayments (MRC20, did:nostr-keyed)
  • Block-trails: Bitcoin taproot-anchored, tamper-evident provenance
  • Git-marks: every pod write is a commit
  • Dual compile: native Tokio + WASM CF Workers
View Repo →

nostr-rust-forum

Governance UI + Relay Kit
  • Judgment Broker decision surface (2,100-line governance model)
  • Agent Control Surface Protocol (kinds 31400-31405)
  • Leptos WASM client (20 pages, 60+ components)
  • 14 crates, passkey-first auth, 5 CF Workers
  • NIP-42 challenge/response at the relay; federated NIP-05 resolution and cross-org mesh routing across sovereign nodes
View Repo →

DreamLab Edge

Branded Deployment
  • React SPA + Leptos WASM forum
  • Cloudflare Workers edge compute
  • Production at dreamlab-ai.com
  • Operator overlay configuration
  • Consumes the forum kit as git-pinned library crates
View Repo →

Ontology Loom

Grounding & Serving Node
  • Model-swappable, OpenAI-compatible façade: the model is a URL (Qwen3.8-27B today), swapped behind the façade with no consumer change
  • Static ontology scaffold lifts grounded recall roughly 3× (a near-random baseline to graph parity), and the gain reproduces across every model behind the façade; prose adds nothing
  • In-process pyoxigraph read-truth store: 286,500-triple reasoned closure, read-only SPARQL + node search
  • Confidence-aware selective injection (live): strong match → full budget, weak → scaled, off-topic → gated: avoids context interference
  • Reasoning-model safe: server-side max_tokens floor so a model never truncates to empty
  • Agentbox “one brain” retrieval resolves through the Loom, live
  • Governed elevation live: workingGraph → ontology via ACSP 31402 propose → admin 31403
View Repo →

Published corpus. knowledgeGraph serves the readable public:: true corpus (a Logseq corpus that is also an OWL ontology) at narrativegoldmine.com, the same ontology VisionClaw renders in 3D. Since July 2026 it also releases the corpus itself: 8,100+ public pages under ODbL-1.0, the seven-stage rdflib pipeline (AGPL-3.0) that compiles them losslessly into the formal ontology (286,533 triples with the pipeline's EL-inferred closure and 101,313 resolvable edges across 6 domains at dataset 2026-08-11; live figures in stats.json), the WasmVOWL explorer (MIT), and the prebuilt artefacts. The corpus is mostly synthetic content, generated by agents under human direction by design: a testbed for the pipeline and the grounding stack it feeds, not an authoritative encyclopaedia. The corpus is the ontology in markdown form: pure TBox, every page a class, zero individuals by design; the pipeline compiles it in losslessly. Validation stands at 0 errors and 0 warnings; 1,396 classes deliberately declare more than one parent: the taxonomy is a lattice, not a tree, and the overlap is published as data.

The mesh improves itself — nightly, and human-merged

Dreaming is the estate’s nightly self-improvement loop. Each night a repository forms one falsifiable hypothesis, measures it against its own evaluators, and opens a draft pull request — evidence-gated, witnessed, and never self-merged. It is the rule the mesh governs by, turned on the code itself: an agent proposes, a human signs the merge. Evaluation is not promotion. It runs on this repository today; the estate-wide orchestrator over the agentbox fleet, and a did:nostr identity per cycle, are in progress. Engine: dream-engine, DreamLab’s tracking fork of rUv’s dream-machine, after AutoDesign: Meta-Harness Optimization (arXiv:2608.13560) — freeze the model, evolve the harness.

Guarantees that hold at runtime

Coordination is only worth trusting when its guarantees survive production. These are the parts that are hardest to fake and easiest to hand-wave past, and in VisionFlow they run in the live path.

Writes are gated, not hoped

SHACL shapes load into Oxigraph and validate every knowledge-graph write. The path is a dual-mode enforcing gate, so a malformed claim is turned away at the door rather than caught later in review.

Provenance you can query

Every governed write reifies as PROV-O triples. Who claimed what, and when, is a SPARQL query answered straight from the graph.

The relay authenticates

NIP-42 challenge/response guards the relay. An actor proves the key it claims before it can publish, so the identity spine holds at the edge as firmly as it does inside the graph.

Federation without a hub

IS-Envelopes route between sovereign nodes through peer discovery, with no central authority in the middle. Trust rides on did:nostr, so two organisations can align while each keeps its own data.

The elevation loop closes

A concept an agent proposes, a human approves, and a merged PR confirms fires ConceptElevated through the Whelk consistency gate. Personal insight reaches the shared ontology through one governed door, end to end.

Action carries force

Agent activity drives the GPU physics directly. A transient-edge attractive force draws related concepts together as work happens, so the graph moves the way the reasoning does.

Walk through the knowledge graph

VisionClaw grew out of 15 years of immersive data research at the University of Salford’s Centre for Virtual Environments. Dr John O’Hare designed and ran the Octave Multimodal Lab, gaining a PhD in telecollaboration, while Prof Rob Aspin’s research pioneered the stereoscopic CAVE infrastructure. Walking through data and reaching into graph structures at room scale shaped VisionClaw’s force-directed engine, its physics model, and its interaction design.

Researchers in Prof Rob Aspin's Octave Multimodal Lab CAVE environment, walking through a projected 3D knowledge graph
Octave Multimodal Lab // University of Salford Centre for Virtual Environments. Stereoscopic projection on walls and floor; researchers physically walk through the knowledge graph.
Researcher in stereoscopic CAVE exploring a 3D knowledge graph with node and edge structures projected at room scale

Stereoscopic Data Exploration

Nodes are physical objects you can reach into. Relationships become spatial structures you navigate by walking. The Octave Lab proved that embodied graph exploration surfaces patterns invisible on flat screens.

Hand tracking and drone interaction in immersive projected environment

Embodied Interaction

Hand tracking, drone teleoperation, and physical controllers. You manipulate data the same way you manipulate physical objects.

Two people standing in a photogrammetry-reconstructed landscape projected across walls and floor

Photogrammetry Environments

Real-world scenes reconstructed as walk-through spaces. Site surveys, heritage preservation, environmental monitoring, all rendered at room scale with sub-centimetre fidelity.

Telepresence session with remote participant projected life-size in studio environment

Telecollaborative Presence

Remote participants rendered life-size through projection. Full spatial co-presence where gesture, gaze, and pointing carry meaning. The Quest 3 native APK extends this to headset users anywhere.

From CAVE to Quest 3. The immersive substrate is migrating from projector-based CAVE systems to a native Meta Quest 3 APK built on Godot 4 + godot-rust + OpenXR. Same binary protocol. Same force-directed physics. Same did:nostr identity. The CAVE validated the concept at scale; the headset makes it portable.

The coordination bottleneck, in ninety seconds

Why coordinated AI reasoning, not raw intelligence, is the limiting factor in high-stakes domains.

Text summary of the film

In high-stakes domains (drug discovery, climate modelling, large creative productions) the binding constraint is not the raw intelligence of any single model but whether many agents and people can reason together without losing provenance, shared meaning, or governance. VisionFlow treats coordination itself as the infrastructure: one cryptographic identity spine, a shared formal ontology that keeps terms meaning the same thing across parties, and human judgment held at the decisions a machine should not close alone.

Human-in-the-loop governance that accelerates, not blocks

The Judgment Broker is an emergent property of agents, humans, a knowledge graph, and a relay mesh coordinating through shared cryptographic identity. No single repository owns the broker. Agents publish through Agentbox, humans decide through the forum, knowledge is gated through VisionClaw, provenance is anchored in sovereign pods.

1

Agent Declares Agentbox

kind 31400 PanelDefinition: agent publishes a control panel with schema, fields, actions via the governance MCP tools

2

Forum Renders nostr-rust-forum

kind 31402 ActionRequest: the forum’s 2,100-line governance model renders the request and routes it to the right human

3

Human Decides NIP-98 signed

kind 31403 ActionResponse: cryptographically signed approve/reject/amend/delegate. The decision is an immutable Nostr event

4

Knowledge Gates VisionClaw

The decision flows back through the relay mesh. VisionClaw gates knowledge graph mutations; provenance beads anchor the audit trail in sovereign pods.

KindNameDirectionPurpose
31400PanelDefinitionAgent → RelayDeclare control panel
31401PanelStateAgent → RelayCurrent data snapshot
31402ActionRequestAgent → RelayRequest human decision
31403ActionResponseHuman → RelaySigned decision
31404PanelUpdateAgent → RelayIncremental state diff
31405PanelRetiredAgent → RelayRetire panel
voice → intent → pod + KG → embodiment → elevation

The embodied agent loop is wired end to end. A spoken command selects an agent and dispatches a scoped ACSP ActionRequest (kind 31402). The agent writes the personal knowledge graph to the user’s Solid pod as itself, under a revocable WAC mandate with a per-request NIP-98 signature. The action crosses into VisionClaw over /wss/agent-events and renders as a transient 0x23 beam, with memory and agent activity mapped to colour, shape, and motion in the live graph. High-value personal concepts are then proposed for elevation into the shared ontology through the Whelk consistency gate and human governance, all federated over the Nostr relay mesh.

Provenance and value travel the same rails

Once every actor is a did:nostr identity and every write is anchored, value and trust travel the same rails as the mesh’s messages: no EVM, no bridge, no custodian, and no token of our own.

agent → pod → 402 settle → anchor → did:nostr

The same did:nostr key that is a WAC principal, a relay identity and a provenance author is also a payment account, so an agent can earn, spend and sign across the mesh as one actor. Payments settle in USD stablecoins over HTTP 402; private digital objects and contracts stay in the owner’s pod and inherit Bitcoin’s security model through taproot-anchored commitments, borrowing the strongest settlement guarantee available rather than minting anything of our own.

Why extreme token consumption against hard problems is rational

Cost of Not Coordinating

A 50-person team running uncoordinated AI agents wastes 60-80% of tokens on context rediscovery, duplicate reasoning, and contradictory outputs. Each agent session starts cold with no shared ontology, no provenance, no memory of what other agents concluded.

5-8x token waste from uncoordinated agent sprawl

Coordination as Token Multiplier

VisionFlow’s shared ontology means agents don’t re-derive domain vocabulary. The provenance chain means agents don’t re-validate conclusions. The Judgment Broker means agents don’t spin on decisions they lack authority to make.

3-5x effective token throughput gain from coordination

Hard Problems Justify Deep Spend

Drug discovery: $2.6B average cost per approved compound. Climate modelling: $50M+ per actionable simulation suite. Creative production: $100M+ per franchise. Against these stakes, spending $10K-100K on coordinated AI reasoning is a rounding error, provided the coordination harness prevents even one wrong conclusion from propagating.

10,000:1 problem-value to token-cost ratio on hard problems

Governance Dividend

Every governance decision that flows through the Judgment Broker is an immutable, auditable event. In regulated industries (pharma, finance, defence), the cost of reconstructing decision provenance after the fact dwarfs the cost of generating it by construction.

90% reduction in audit reconstruction cost

Coordination Harness ROI Model

For a team of N agents working on a problem of value V:

ROI = (V × coordination_multiplier × governance_dividend) / (token_cost × N)

Without coordination, agents compete, duplicate, and contradict. Each additional agent adds noise faster than signal. With VisionFlow, each agent amplifies the mesh. Shared semantics compound. Provenance eliminates re-validation. Governance catches expensive mistakes early.

The break-even point is typically reached at 3 agents working on any problem valued above $50K. Beyond that, every additional coordinated agent produces net positive value because the ontology, the identity spine, and the governance plane are shared infrastructure, not per-agent costs.

The Ontology Loom: measured grounding behind a model-swappable façade

We tested whether a formal ontology improves an LLM’s factual recall, objectively, with gold answers derived from the knowledge graph itself. Across every model we have put behind the façade (a frontier model at one end, a small local one at the other), grounding raised recall and cut hallucination in every case, roughly halving hallucination on the set (full report). The result is about the architecture, not the model: probabilistic agents bounded by machine-checkable semantics, with contradictions rejected at the Whelk gate before they enter the graph. We re-run the benchmark on each new model we deploy; the shape holds, and it keeps improving.

A held-out graph-derived benchmark (objective gold, bootstrapped intervals) on the current model, Qwen3.8-27B, across four grounding modes:

Grounding modeRecallWhat it shows
Raw: no grounding~0.3Bare model on synthetic-corpus recall: near random
Scaffold: static structured injection~0.9The win: roughly 3× the baseline, from a pre-computed injection
Prose-enriched scaffold~0.9Adds ~nothing over structured; prose stays optional
Tools: agentic graph traversalmidBelow static injection, and model-dependent; letting the model traverse can hurt it

The static structured scaffold is the whole win: a bare model near random on the corpus answers at graph parity once the scaffold is injected, prose adds nothing, and letting the model walk the graph with tools tends to make it worse. The scaffold, not the model, does the work, which is exactly why the model can be a swappable URL. (The interference from injecting on weak matches is a known effect in the retrieval literature; the Loom gates for it, below.)

The Loom turns that result into infrastructure

The Ontology Loom is the node that serves this grounding as infrastructure. It consumes the corpus generations that knowledgeGraph publishes, weaves them into a reasoned ontology it holds as canonical, and serves that grounding to any LLM behind a stable, OpenAI-compatible façade. The model is a URL: Qwen3.8-27B today, swap for whatever benchmarks best next, with zero consumer change. VisionClaw supplies the GPU engine and the OWL 2 EL reasoner; knowledgeGraph builds the corpus; the Loom serves the grounding.

model = a URL behind a stable façade · swap without consumer change

Model identity is carried in the results, never in the endpoint. A consumer (an agent, a workflow, any OpenAI-compatible client) asks the same façade the same way whether a local GPU model or a cloud model answers. In agentbox the “one brain” retrieval path resolves through the Loom’s harness-side client, live, so grounding is uniform across the harness without wiring an ontology into each agent.

Beyond the benchmark, the node has hardened into infrastructure:

Confidence-aware injection, live

Grounding only helps when the query is on-ontology: injecting context on a weak match can displace the model’s own knowledge (the “context interference” effect: Lin et al. 2026, Yoran et al. 2024). The Loom scales injection by retrieval confidence: a strong exact-title hit gets the full scaffold (verified rollup → full budget), a weak match a scaled fraction (digital-asset transfer, score 2.3 → 0.4×), an off-topic query nothing at all (banana pancakes → gated, zero tokens).

A single read-truth

The Loom holds the reasoned generation in an in-process pyoxigraph store (286,500 triples of assertion-plus-closure) and answers read-only SPARQL and node search over it. One queryable source of ontological truth behind the façade, never the working graph.

Governed elevation, end to end

New knowledge reaches the ontology through one governed door: an agent distils a note, grounds it against the Loom, and proposes an enrichment as an ACSP 31402 request; a human admin approves with 31403; only then does it publish. The first elevation ran this way: proposed, approved, and live in the served generation the same day.

What the numbers measure. The recall figures are domain-specific factual recall on a mostly synthetic corpus. The corpus is a testbed for the pipeline and its grounding, which is exactly what makes it a fair reading of the mechanism. The rest runs in the deployed node: the model-swap seam works across two very different models behind one façade, the read-truth store and confidence-aware injection are live, the agentbox “one brain” grounds through it, and governed elevation publishes into the served generation. Repo: github.com/DreamLab-AI/loom.

Federated problem-solving across trust boundaries

🌍

Climate Modelling Consortium

Three universities, two government agencies, one NGO. Each institution runs its own VisionClaw with domain-specific ontologies. OWL 2 EL reasoning ensures “sea surface temperature anomaly” means the same thing across all ontologies. Data stays in sovereign pods; cross-institutional findings surface through the Judgment Broker.

Why competitors can’t: No other platform combines formal ontology alignment, cryptographic data sovereignty, and human-in-the-loop governance.
💊

Pharmaceutical Drug Discovery

Biotech startup + CRO + regulatory consultancy. Literature mining agents parse 50K papers, chemistry agents run ADMET predictions, compliance agents map to ICH guidelines. Each organisation’s agents operate within their Solid pod boundary. The CRO never sees the biotech’s proprietary target list.

Why competitors can’t: No other platform provides per-organisation pod boundaries with cross-organisation semantic alignment and auditable provenance chains.
🎬

Creative Production at Scale

12-episode series, five time zones. Production ontology maps episodes to scenes to shots to assets. VFX agents track pipeline stages. When a VFX shot depends on an unapproved 3D asset, the OWL 2 constraint propagates through the graph and the GPU physics engine makes the blocked dependency visually obvious.

Why competitors can’t: No other platform uses formal reasoning to propagate production constraints through a visual knowledge graph.

Real-World Validation

DreamLab Creative Hub
50-person team, 17,000+ graph nodes, daily production
University of Salford
Research partnership, semantic force-directed layout
THG World Record
250+ concurrent XR users, immersive data visualisation

The frontier moved to coordination guarantees

Through 2025–2026 the industry standardised how agents talk: Anthropic’s MCP and Google’s A2A, now both stewarded by the Linux Foundation’s Agentic AI Foundation. “Having agents” is table stakes. The real question is coordination: who each actor cryptographically is, who owns the data, how decisions are governed and audited, whether reasoning is formally grounded or merely generated, and whether organisations federate without a central authority. On those axes the field thins fast.

Platform Crypto Identity Data Sovereignty Governance Formal Reasoning Federation OSS
VisionFlow
LangGraph framework
CrewAI framework
AutoGen / AG2 framework
Google A2A protocol
Block Buzz Nostr-native
Fetch.ai / ASI decentralised
Palantir AIP enterprise
First-class Partial / add-on Absent framework = orchestration library · protocol = wire standard

Formal reasoning is the empty column

Every peer grounds its agents in LLM inference. Palantir grounds them in a governed knowledge graph, which is closer, but still not description-logic entailment. VisionFlow’s OWL 2 EL + Whelk produces checked entailments and rejects contradictions before they enter the graph.

Others match one axis; VisionFlow holds all six

Block’s Buzz matches on identity, governance and federation; Palantir owns governance; A2A owns federation. Only VisionFlow carries sovereign identity, self-owned data, signed governance, formal reasoning, cross-org federation and open source at once, and binds them to one did:nostr key.

The closest convergence. Block (Jack Dorsey) shipped Buzz, a self-hostable, Nostr-native platform where humans and agents share channels, every actor holds a secp256k1 keypair, and every action is a signed Nostr event with an append-only audit log. A well-funded team arriving independently at the same substrate this ecosystem has built since 2022 validates the thesis rather than threatening it. The one axis Buzz does not carry is the decisive one: formal, ontology-backed reasoning. That, with Solid-pod data sovereignty and immersive 3D embodiment, is the moat.

Three axes, one architecture

Single Operator

Token-Efficient

One Agentbox, standalone mode. Local SQLite beads, local Solid pod, local events. 116 skills, 180+ tools, privacy filter active.

One API key. One container. Minutes to deploy.
Team

Governed Collaboration

VisionClaw + forum + Agentbox on a shared relay. Shared ontology, Judgment Broker oversight. Knowledge-graph writes are gated by signed human decisions; ontology changes ship as consistency-gated GitHub PRs.

One GPU host + one agent container + CF Workers. 50-person team validated.
Enterprise

Federated Intelligence

Sovereign agentbox instances on the Nostr relay mesh. Cross-org relay federation routes IS-Envelopes across nodes with NIP-42 challenge/response and peer discovery. Each node is independently hardened, and trust rides on did:nostr rather than network topology.

Horizontal. Add nodes. Each node owns its data.