ARC-Core vs the Continuum ARC

This document does the intellectually honest thing: it takes Alec Sadler's fictional ARC system from Continuum (2012, Simon Barry, set in 2077) as a north-star reference, compares the real ARC-Core codebase against that reference, puts the comparison next to actual 2025 commercial competitors, and writes down the concrete roadmap that would carry ARC-Core from where it is (v6.0.0) to something recognizable as Alec's ARC in theory. Nothing here claims a fictional capability we don't have. Everything aspirational is labeled "Future" with a roadmap item.

1. What Alec Sadler's ARC actually is in Continuum

In the show, the ARC system is never explicitly broken out as a single product — it's the consequence of several pieces of SadTech / SadCorp tech that Alec builds, coupled to a city-scale surveillance + law-enforcement stack. Walking through canon:

1.1 The surface: CMR (Cellular Memory Review/Recall)

A liquid-chip bio-implant hardwired into the cortex of City Protective Services (CPS) "Protectors" like Kiera Cameron. From the Continuum wiki and episodes ("A Stitch in Time", "Split Second", "Second Opinion", "Second Skin", "Second Listen", "Second Wave", "Second Degree", "Lost Hours"):

• Constant sensor capture: records telemetry, smell, video, audio — a 36-hour rolling buffer on-device, continuously dumped to the CPS central server at end of shift (though secretly all recordings are archived permanently).
• HUD + cybernetic visual implants: targets overlaid with biometrics, heat, telescopic vision, structural-weakpoint scans, firearm detection, face recognition, fingerprint recognition, pregnancy detection, lie-detector / polygraph.
• Multispectral nano-sensor array: night vision, enhanced senses, environmental metrics.
• VPN link to CPS: in 2077 a city-wide VPN that accesses case files and enables free comms/video with HQ and any other officer. In 2012, Kiera's VPN is effectively just Alec — Alec is hard-lined into her CMR through a glitch in the CPS suit, so he is her entire command network, case database, and technical support.
• Authority/tamper primitives: CMR can be remotely wiped, remotely shocked, and even read from a dead protector's eyes if the chip is still in place. Weapons are biometrically locked (Curtis Chen is killed by his own CPS-suit weapon's failsafe when he fires Kiera's gun).
• Embedded cognitive therapist: a CMR-internal intelligence that monitors biometrics and takes the user offline for a psych eval if they threaten another officer; can delete distress-causing memories if effectiveness drops below 8%.

1.2 The kernel: the ARC (a.k.a. "the ARC supercomputer")

Introduced in "Second Listen" as the quantum-supercomputer surveillance backbone. Jason Sadler hooks Kiera directly into "the ARC, the supercomputer surveillance system configured through the [time travel] slice."

• City-wide signal-intelligence fusion: CMR streams, CPS suit telemetry, public sensors, corporate-city surveillance, quantum-boosted data sifting.
• Authority layer over all of CPS/SadCorp/Piron: who may execute what, who may be deleted from the record, who may access whose CMR stream.
• Reverse-engineering target: in the Piron timeline, Alec tries to reverse-engineer Kiera's CMR to build HALO health implants — consumer-grade extraction of military-grade surveillance.
• Cross-timeline authority: older Alec uses the ARC to inject an encrypted message into Kiera's CMR diagnostic flow 65 years before she receives it, password-gated ("Theseus").

1.3 The doctrine ARC enforces (or fails to enforce)

• Event sourcing at human scale: every sight, sound, smell, and biometric of every Protector is a canonical event, signed and archived.
• Receipt chains with corporate override: corporations can retroactively wipe confidential material from officer CMRs ("Second Time") — a deliberately dystopian anti-pattern of what a clean receipt chain should do.
• Authority gating: Protectors' weapons, suits, and comms all refuse to work for unauthorized users (Curtis Chen / Kiera's gun failsafe).
• Deterministic replay from captured streams: Alec routinely has Kiera "replay" moments through her CMR; in "Second Listen" they activate a deceased officer's CMR remotely to pull GPS + visual from the last minutes before death.

1.4 The important thing Continuum gets right for a real-world designer

In the show, the ARC is genuinely inseparable from its political context: it's the same infrastructure that enables Kiera's investigative superpowers and the Corporate Congress's total surveillance. The show treats this tension as its moral thesis. For a real open-source project, the takeaway is: build the doctrine, invert the politics. ARC-Core takes the spine (events + receipts + authority) and deliberately strips the corporate-oligarchy affordances (no remote-wipe by the state, no silent permanent archiving, no forced memory deletion, analyst-serving, MIT-licensed, author-owned).

2. Side-by-side — Alec's ARC (canon) vs ARC-Core v6.0.0 (actual)

Capability	Alec's ARC (canon reference)	ARC-Core v6.0.0 (real, today)	Gap magnitude
Core event/receipt kernel	City-scale, quantum-boosted	SQLite + SHA-256 + HMAC chain, 47 endpoints, 13 tests	Done, single-node only
Canonical identity per event	SHA-256 chip-signed, per-Protector key	24-hex-char SHA-256 fingerprint + HMAC-SHA256 receipt signature	Parity at spec level
Authority-gated actions	Biometric lock on weapons, suits, comms	5-rung role ladder + PBKDF2 sessions + shared-token	Pattern parity, not biometric
Hard-line ops comms (Alec↔Kiera)	CMR VPN: one-operator-to-one-field-agent tether	X-ARC-Role + Bearer tokens; no push/comms channel	Missing: WebSocket/SSE streaming
Live sensor fusion (audio/video/biometric)	Continuous 36-hour buffer per Protector	Event posts + connector polls (filesystem_jsonl)	Missing: streaming/webhook connectors
HUD overlay / analyst "lenses"	In-retina scans, biometrics, heat, face rec	Web UI at /ui with 6 pages (dashboard/signals/graph/timeline/cases/geo)	Missing: AR/spatial; web-only
Geospatial truth	City-scale 3D with sensor/geofence overlays	2D polygons, sensors, geofences, blueprint overlays, calibration profiles, heatmap	2D parity; no 3D/city-scale
RF/signal estimation	Implicit via CMR + city sensors	Weighted-RSSI centroid + candidate cloud + confidence model	Building-interior parity; no multilateration
Tamper-evident chain	Implicit at chip level; canon deliberately corrupt at corporate level	SHA-256 + HMAC chain with `prev_hash	ts
Remote-wipe / memory delete	Yes — dystopian feature	Deliberately absent	Intentional non-goal
Deterministic replay	Yes, from CMR tape	Yes, via event-log replay + state_at(event_id) pattern	Parity
Quantum-boosted sifting	Canon plot device	N/A — stdlib SQLite only	N/A; solve without quantum
Psychological self-governance	Embedded cognitive therapist that can wipe memories	Deliberately absent; analyst retains full authority	Intentional non-goal
Cross-timeline message injection	Plot device	N/A	N/A; no time travel
Biometric weapon lock	Canon	N/A (no weapons surface)	Out of scope
Evidence export / portable proof	Implicit in CMR dumps	`export_evidence_pack(case_id	subject)` with 250-receipt tail + hash
Authority-gated runtime execution	SadTech / Piron hierarchy	require_role + session + shared-token	Parity at software level
Self-verifying offline	N/A in canon	GET /api/receipts/verify with 3 precise failure reasons	Ahead of canon

Honest assessment: ARC-Core already implements the doctrinal spine of Alec's ARC at a level of detail canon doesn't even require. Where we're behind: sensor-stream ingestion, push-comms to field operators, spatial 3D, and scale. Where we're deliberately ahead: transparency, tamper-evident without corporate override, open-source.

3. Competitor comparison — what else is this serious in 2025

The open-source + commercial systems that actually live in the same category. "Category" meaning: signal-intelligence event spines with receipts, authority, replay, and analyst UI — not just logging systems, not just SIEMs, not just time-series DBs.

Product	Category	What it actually does	Receipt/chain?	Authority gating	Open-source	Per-event cost	Single-author?
ARC-Core v6.0.0	Signal-intel event spine	Events + entities + graph + cases + proposals + geo + receipts + evidence packs	SHA-256+HMAC chain, verifiable	5-rung role ladder + PBKDF2 + shared-token	MIT	free	Yes (Gary Doman)
Palantir Gotham	Intelligence platform	Entity resolution, case mgmt, ontology, geospatial, ACLs	Internal audit log, not user-verifiable chain	RBAC + attribute-based	No	$1M+/yr seats	No
Palantir Foundry	Data platform	Pipelines, ontology, ACLs, apps	Version history; no SHA chain	RBAC + purpose-based	No	Enterprise	No
Anduril Lattice	Defense C2 + sensor fusion	Drone/sensor telemetry, map ops, mission planning	Not public; classified chain	Mission roles	No	Enterprise/gov	No
AWS QLDB	Append-only ledger DB	Cryptographically verifiable transaction log	Merkle-tree + digest	AWS IAM	No	~$0.03/1M requests + storage	No
Amazon Security Lake	SIEM-adjacent log lake	OCSF-schema event aggregation, query	Raw logs, no chain	IAM	No	Enterprise	No
Splunk Enterprise	Log aggregation + search	SPL queries, dashboards, alerts	Audit log, not tamper-evident	RBAC	No	High per-GB-day	No
Elastic SIEM	SIEM	Event storage, detection rules, cases	Index signing optional	Spaces/roles	Free core	Tiered	No
Grafana Loki + Tempo	Log + trace	Structured log + trace storage	No chain	Grafana auth	Apache 2	Free self-host	No
OpenTelemetry + Jaeger	Tracing	Distributed traces	No chain	External	Apache 2	Free	No
Rekor (Sigstore)	Transparency log	Cryptographically verifiable append-only log for software supply chain	Merkle tree, publicly verifiable	Sigstore identity	Apache 2	Free	No (CNCF project)
HashiCorp Vault	Secrets + identity	Audit device with HMAC chain	HMAC audit chain	Policies	BSL	Enterprise	No
ChronicleDB / Hyperledger Fabric	Blockchain-like ledger	Permissioned ledger, smart contracts	Full blockchain	MSP + channels	Apache 2	Complex deploy	No
SAP ArchiveLink / OpenText	Enterprise records mgmt	Long-term compliant archiving	Compliance logs	LDAP/AD	No	Enterprise	No
PostgreSQL + pg_audit + hashed rows	DIY	What most teams actually build	DIY chain	Row-level security	BSD	Free	No

3.1 Who else is actually doing this at quality

Honest, short list:

• Palantir Gotham owns the commercial high end for intelligence-grade case + entity + geospatial fusion. It has every feature ARC-Core has + 15 years of head start and a lot of analysts in uniform, but at $1M+/year seats and closed source.
• Anduril Lattice owns defense sensor-fusion C2. Telemetry at continent scale. Closed; classified.
• AWS QLDB owns the "cryptographically verifiable ledger" primitive at cloud scale, but it's a database, not a console.
• Rekor (Sigstore) is the closest philosophically — a publicly verifiable append-only transparency log — but scoped to software supply chain, not signal intelligence.
• Vault has the HMAC-chained audit device primitive that ARC-Core's receipt chain is shaped like.
• Nobody open-source-solo is combining all of: event ingest + entity resolution + graph + case mgmt + proposal/approve lifecycle + geo (indoor + outdoor) + tamper-evident receipt chain + evidence-pack export + role ladder + RF estimator + MIT-licensed + single-author. That's the defensible position.

3.2 What "quality" means in this category

Not feature count. It's the combination of:

1. Every state change emits a receipt (not just logs).
2. Chain is externally verifiable (you can take the JSON + signing key offline and prove tamper-evidence).
3. Authority is explicit (roles, sessions, proposal/approve separation — not just "admin vs user").
4. Replay is deterministic (state derived from event log, never mutated in place).
5. Identity is canonical (same label → same entity across time).
6. Evidence is portable (you can hand over a JSON blob that a third party can verify).

Palantir has 1-5 and a version of 6. Rekor has 1-2. Vault has 1-2 scoped to secrets. AWS QLDB has 1-2 scoped to DB rows. ARC-Core has 1-6 in one MIT-licensed repo.

4. Concrete gaps — what ARC-Core lacks today

Ranked by how much they matter for real Alec-caliber operator usage. Each has a direct mapping to a v7+ feature.

4.1 Sensor-stream ingestion (biggest gap)

• Canon: CMR streams continuous A/V + biometrics at 30+ fps to the ARC.
• Today: filesystem_jsonl connector polling files on a 60s cron. No WebSocket, no SSE, no Kafka/NATS.
• Fix: add websocket_stream, http_webhook, mqtt, sse_push connector types that share the connector_sources + connector_runs schema. Preserve the event-ingest contract so receipts are identical regardless of transport.

4.2 Push to field operators (Kiera's hard-line)

• Canon: Alec talks in Kiera's ear in real time through her CMR.
• Today: pull-only HTTP. The UI polls every N seconds.
• Fix: WebSocket channel under /ws/operator/{session_id} that pushes: new events for this operator's subjects, geofence breaches, case updates, proposal notifications, receipt-chain tail updates. Same auth as REST; session-gated.

4.3 Full-text search at scale

• Canon: instant "search everything ever recorded."
• Today: LIKE-over-8-columns on the events table. Fine to ~10⁶ events; falls over above that.
• Fix: SQLite FTS5 virtual table keyed off payload_json, with dedup via rowid = events.rowid. Keeps single-file deployment.

4.4 3D spatial / indoor-outdoor seam

• Canon: city-scale AR overlays with inside-outside transitions.
• Today: 2D polygons + flat blueprint overlays per floor; no building-to-street seam; no 3D.
• Fix: model elevations as polygon extrusions (min_elev_m, max_elev_m columns on structures), export GeoJSON + Cesium 3D Tiles for viewers. Track estimates gain a z dimension; geofences become prisms.

4.5 Multilateration / hybrid estimator

• Canon: implicit via mesh of sensors everywhere.
• Today: weighted-RSSI centroid. Good inside a building with 5+ anchors; bad with sparse/noisy data.
• Fix: plug in calibrated trilateration as an alternate method="trilateration" in estimate_from_observations; keep centroid as fallback. Thread existing calibration_profiles.path_loss / noise_db / smoothing into the forward model (known v6 TODO).

4.6 Risk decay + auto-downgrade

• Canon: analyst pressure + corporate oligarchy means risk only ever goes up.
• Today: MAX(risk_score, new) — same anti-pattern, in the ethical inverse direction (analyst-serving but still sticky).
• Fix: add a per-entity decay half-life (configurable; default 14 days). Compute current risk as score * 2^(-elapsed/half_life). Keep the historical max as a separate column for audit.

4.7 Multi-tenant isolation

• Today: single SQLite file, one admin family.
• Fix: tenant ID column on every row + a tenants table. Or just document: "deploy one ARC-Core per tenant, reverse proxy in front." The honest answer is the latter for now.

4.8 Receipt-chain key rotation

• Today: KEY_ID="local-hmac-v1" is hardcoded.
• Fix: key_rotation receipt type that records the old tail hash under the new key + timestamp. Verification walks both keys across the rotation boundary.

4.9 Cognitive-therapist-style self-governance (deliberately NOT implemented)

• Canon: CMR can silence and wipe the analyst.
• Decision: permanently out of scope. Operator agency is a red line. This gap is intentional.

4.10 Biometric weapon lock

• Canon: Kiera's gun kills Curtis when he fires it.
• Decision: not applicable to a signal-intel console. Out of scope.

5. Roadmap — how to get from v6.0.0 to "Alec's ARC in theory"

Numbered phases, each one shippable standalone. None require exotic compute (no quantum, no time-travel slice). Everything reuses the existing schema + receipt protocol; the only question is where the data comes from and how it's streamed out.

v7.0.0 — Push + Stream (quarterly)

• [R1] WebSocket operator channel (4.2).
• [R2] http_webhook + sse_push connector types (4.1).
• [R3] FTS5 on events (4.3).
• [R4] Calibration-aware estimator with method="trilateration" option (4.5).

v8.0.0 — Spatial 3D

• [R5] Polygon extrusions + elevation on structures/geofences (4.4).
• [R6] GeoJSON 3D Tiles export under /api/geo/export/cesium/{structure_id}.
• [R7] Indoor-outdoor seam: floor-transition tracking between structures.

v9.0.0 — Fleet + Scale

• [R8] Multi-tenant schema or reverse-proxy playbook (4.7).
• [R9] Key rotation (4.8).
• [R10] Federated receipt chains — N ARC-Core nodes can cross-verify via a shared anchor hash.
• [R11] Risk decay with half-life (4.6).

v10.0.0 — "Alec-mode" (theoretical)

Same codebase, equipped with streaming ingest + push comms + 3D spatial + fleet federation, would credibly run:

• A police-department signal-intelligence console at city scale (the canon use case).
• A defense C2 substrate like Lattice (minus classified parts).
• A real-estate ops platform (already working — see RAG-Command-Center).
• A governed-AI build loop (already working — see ARC-Neuron-LLMBuilder).
• A robotics fleet controller (architectural fit — see Robotics-Master-Controller).
• A plugin-ecosystem license/billing authority (already working — see TizWildinEntertainmentHUB).
• A deterministic seed-to-universe simulator (already working — see Seeded-Universe-Recreation-Engine). Everything on the same MIT-licensed spine, single author, explainable.

6. Portfolio cross-reference — where ARC-Core is actually used today

The real, honest mapping (no fictional capabilities):

Seven-repo ARC ecosystem (governed-AI stack)

1. ARC-Core — this repo.
2. arc-lucifer-cleanroom-runtime — deterministic operator runtime.
3. arc-cognition-core — model-growth lab.
4. ARC-Neuron-LLMBuilder — governed build loop (flagship, v1.0.0-governed).
5. arc-language-module — canonical lexical truth.
6. omnibinary-runtime — binary mirror / runtime ledger.
7. Arc-RAR — archive / rollback bundles.

Consumer applications (gaming/entertainment/simulation)

• RiftAscent — canvas game; player-event ledger + tamper-evident high score.
• Seeded-Universe-Recreation-Engine — vendors ARC_Console/ inside the repo.
• Proto-Synth_Grid_Engine — carries ARC_CORE_AUDIT_v44.txt.
• Neo-VECTR_Solar_Sim_NASA_Standard — truth-pack receipts.
• TizWildinEntertainmentHUB — authority backend for 14 JUCE plugins (FreeEQ8, PaintMask, WURP, AETHER, WhisperGate, Therum, Instrudio, BassMaid, SpaceMaid, GlueMaid, MixMaid, ChainMaid, RiftWave Suite, FreeSampler).

Consumer applications (commercial / operational)

• RAG-Command-Center — full-stack real estate intelligence platform for Victoria, BC + Canada-wide listings.
  • Signal compile (Reddit/Victoria Open Data/Facebook paste) = event ingest + fingerprint dedupe.
  • 0–100% deal score / lead intent score = explainable linear score_event analog.
  • Pipeline kanban (new→qualified→showing→offer→closed) = proposal → evidence → receipt → approval.
  • Licensed-area routing = authority gating.
  • Hot/Warm/Cold/Stale decay (7d / 14d) = risk-band + sliding-window analog.
  • SHA-256 auth + Cloudflare Workers KV + hourly cron = connector-poll + audit-log pattern.
  • As of the latest pass, explicitly documents this mapping in its README.
• Robotics-Master-Controller — robotics portfolio hub (not a runtime yet).
  • Architectural commitment: any future control stack here will use ARC-Core primitives for actuator commands (fingerprint dedupe → no double-actuate), sensor streams (event sourcing), motor enable/E-stop (authority gating), fabrication jobs (proposal → evidence → receipt → approval), safety incidents (incident receipts + geofence generalization), and safety-review export (export_evidence_pack).
  • As of the latest pass, explicitly documents this architectural plan in its README.

Trading / arbitrage bots — honest status

The user's portfolio references currency/arbitrage bots:

• BrokeBot — empty repo, no code.
• Doman.ai_Arbritrage_Bot — empty repo, no code.

No bots are live-integrated with ARC-Core today. When they ship, the natural integration is identical to how RAG Command Center maps trading to ARC-Core primitives:

• Every market tick = event ingest.
• Every order proposal = proposal with simulated PnL as simulation_json.
• Every fill = receipt in the chain.
• Exchange API keys = auth_users with scoped role.
• Risk limits = require_role("approver", ...) on above-threshold positions.
• Strategy backtest = deterministic replay of event log.
• Portfolio state = derived from event log; never mutated in place. The whole trading desk becomes an ARC-Core consumer the moment a bot is actually written.

7. The "in theory" bridge — if you wanted to be Alec Sadler

Given ARC-Core v6.0.0 + the v7-v10 roadmap above + off-the-shelf hardware available in 2025, the only pieces left between what ARC-Core becomes in theory and what Alec built in Continuum's 2077 are:

1. CMR hardware — replaced in 2025 by AR glasses (Meta Orion, Apple Vision Pro, Magic Leap) + body-worn cameras + smartwatch biometrics. Stream via v7 WebSocket ingest; render via a PWA HUD at /ui/operator.
2. Quantum-boosted sifting — replaced by batched vector search over embeddings indexed off the event stream (a standard 2024 playbook; works with ARC-Neuron-LLMBuilder's governed build loop).
3. Biometric weapon lock — out of scope (deliberate).
4. Corporate-oligarchy override — out of scope (deliberate; opposite politics).
5. Remote memory deletion — out of scope (deliberate; operator retains authority over own record).

Everything else — the event spine, the receipt chain, the authority ladder, the entity resolution, the proposal/approve lifecycle, the analyst console, the evidence export, the geo overlays, the sensor-fusion estimator — is already shipped and provable today. The roadmap turns it into something Alec would recognize. The politics deliberately stay opposite.

8. TL;DR — the one-paragraph summary

ARC-Core v6.0.0 is a faithful, MIT-licensed, single-author implementation of the doctrine that underpins Alec Sadler's ARC in Continuum — events, receipts, authority, replay — with deliberate inversions of the show's corporate-oligarchy features (no remote wipe, no memory deletion, no corporate override). It reaches parity with Palantir Gotham on the doctrinal primitives, exceeds AWS QLDB / Sigstore Rekor / Vault on scope, and is the only open-source-solo combination of all six of: (1) event spine, (2) receipt chain, (3) entity resolution, (4) case mgmt, (5) proposal/approve lifecycle, (6) geospatial fusion. The remaining gaps to full Alec-mode are scale-out (multi-tenant, federation), streaming (WebSocket + push comms + real-time connectors), spatial 3D, and a hybrid RF estimator — all routed through the existing schema without fictional compute. Everything else in the author's portfolio (ARC-Neuron-LLMBuilder, TizWildin Hub, Seeded-Universe, RAG Command Center, Robotics Master Controller, the still-empty trading bots) already lives on that spine or is architecturally ready to.