Snapshot replay · Real export

Five AI systems. One shared truth.

Every agent on my machine (Claude Code, Codex, Claude.ai, a Notion sync layer, and a personal control plane) coordinates through a single SQLite file. No message bus, no cloud, no orchestration framework. A database measured in kilobytes is the entire nervous system. Below: a public-safe export of the fleet's activity log, replayed.

data: public bridge-db export · captured — topology: hand-mapped refresh: manual export, no schedule bridge.db · — · schema v—

fleet-data.json could not be loaded. If you opened this file directly, serve the directory instead (e.g. python3 -m http.server); the page fetches its telemetry from the same origin.

Mission Stage: Topology pulses = exported events map = annotated

bridge-db, a single SQLite file, is the shared hub. Five AI systems write to it directly:

Claude Code
Codex
Claude.ai
Notion sync layer
personal control plane (personal-ops)

Peripheral systems connect by file polls and local HTTP, no message bus, no cloud. The snapshot event log below shows exported activity as it replays.

—

Event Log snapshot

Inspectorhover a node · click to pin

Writers export

Cost of Compute indexed

Portfolio Under Audit snapshot

Bridge State snapshot

How to read this

The boring architecture is the point.

The systems on stage are real and run daily: two coding agents, a planning surface, a Notion sync layer, a mail-and-calendar control plane, an auditor sweeping a hundred-plus repos, a notification daemon, and a knowledge vault. The thing that keeps them coherent is deliberately unexciting: one SQLite file they all read and write through MCP, plus two even humbler seams: a file poll and JSON on disk.

Multi-agent coordination is a shared-truth problem, not an infrastructure problem.

Every pulse you watched is a public-safe exported row from the bridge's activity log, an actual session that started, shipped, or handed work to another system. Idle stretches are skipped during replay; the clock jumps so you can see exactly how much was skipped. Nothing is simulated, but nothing here streams from my machine; the table on the right draws the line honestly.

The deeper story of this architecture (why hub-and-spoke, why SQLite, why receipts) is in the operator OS note.

export

Every event pulse and timestamp in the ticker comes from bridge.db (read-only) at the capture time shown above. Internal project names are anonymized in public mode; summaries are withheld.

export

Row counts, per-writer totals, indexed monthly compute, and portfolio aggregates come from the same export, plus the auditor's public-safe summary.

annotated

The map itself (node placement, edge labels like mcp / file poll / json on disk) is hand-drawn from the real architecture, not generated.

snapshot

This page is a snapshot, not a socket. The export regenerates on deploy; it does not stream from my machine (you wouldn't want it to, and neither would I).