What Archon Merkaba Is
Archon Merkaba is an agentic operating system: infrastructure that lets a fleet of specialized AI agents operate a real business continuously — trading, engineering, security, content, and operations — with a human founder in the approval loop for anything irreversible.
It is not a demo or a framework. It is a live system that has been in continuous production operation since early 2026, with hundreds of deployed change-waves, a live trading book, scheduled autonomous jobs, and a self-healing monitoring layer.
Design Philosophy
Five principles shape every architectural decision:
-
Agents are employees, not tools. Each agent has a durable identity (a "soul" file), a role in an org chart, defined spawn permissions, and its own memory. Work is routed to the right specialist rather than handled by one generalist prompt.
-
The human gates the irreversible. Agents act autonomously on reversible, observable work. Anything irreversible — capital allocation changes, public posts, deployments to the live daemon, external PRs — requires explicit human approval. This is enforced by policy files and hooks, not by hoping the model remembers.
-
Evidence over vibes. Claims about system behavior must trace to code that was actually read, data that was actually queried, or experiments that were preregistered. An internal "Evidence Gate" audit checks agent outputs for unsupported claims.
-
Cost discipline is architecture. Expensive frontier models run on a flat-rate local control plane wherever possible; the cloud VPS runs only vital operations on the cheapest model tier that does the job. Model routing is codified, not ad hoc.
-
Assume compromise, verify everything. External content is data, never instructions. Secrets live in an encrypted vault, never in code. Host keys are pinned. Every integration passes a usefulness gate and a supply-chain review before installation.
The Two Planes
The system runs across two cooperating environments:
Local Control Plane
A workstation-based orchestration environment where the primary reasoning happens:
- The orchestrator session (internally "the CEO") receives all human requests, routes them to specialist agents, and synthesizes results.
- Specialist agents are spawned as subagents on demand, each loading its identity, tools, and goals from a cached fleet directory.
- Persistent memory (vector search + SQLite) records every session's observations so any future session can recall past bugs, decisions, and designs.
- Frontier-model work runs here at flat subscription cost — architecture reviews, multi-agent audits, code generation, research fan-outs.
Cloud Plane (VPS)
A hardened Linux VPS runs everything that must be always-on:
- Agent gateway — a containerized runtime that hosts scheduled agent jobs and chat-ops (messaging in/out), isolated behind a VPN overlay.
- Trading daemon — the always-on trading engine (see 06 — Trading Platform).
- Monitoring & remediation — 18+ independent monitors, watchdog timers, and a tiered auto-remediation executor (see 07 — Reliability).
- Encrypted vault — SOPS + age secret storage with audit logging (see 05 — Security).
The two planes sync continuously: agent definitions, skills, memory, and operational data flow through a sync pipeline with change tracking, so the local plane always has a current cached view of the fleet without needing live SSH for routine work.
What "Production" Means Here
- Continuous operation since February 2026, including surviving (and then automating recovery from) full VPS reboots.
- 350+ deployed change-waves to the trading system, each logged, many governed by Architecture Decision Records.
- Scheduled autonomy: daily calibration checks, security scans, drift detection, health audits, and synthesis jobs run without human initiation and report by chat-ops.
- Incident discipline: real incidents (state-loss bugs, reboot failures, phantom positions) get root-cause writeups, preregistered fixes, and regression tests — the same practices a professional SRE team would use.
What This System Demonstrates
For a technical reader, the interesting engineering lives in the intersections:
- Multi-agent orchestration with deterministic routing rather than free-form delegation
- Memory resilience — the system keeps learning even when its memory backend is down
- Defense-in-depth for LLM systems — prompt-injection policy plus a shipped OSS framework
- Risk-gated autonomy — an AI system with real capital that is structurally prevented from hurting itself faster than a human can intervene
- Self-healing operations — alerts that close their own loop instead of paging a human