Seven governed pillars, then the surfaces that run the compute and the configuration around them. These are direct captures from the desktop client and the local orchestration engine — no mockups, no composites, and nothing rendered for this page.
Seven pillars carry the trust fabric; the last three screens are the compute, the model fleet and the settings that run around them. Each names what it does and shows the surface an operator works in.
CAIRN is the default-deny security boundary. Every incoming prompt instruction and proposed tool call is intercepted and evaluated against strict cryptographic policies prior to execution.
By separating cloud reasoning models from direct OS tool access, CAIRN removes the path by which an injected instruction reaches a tool unreviewed: every proposed call is graded and must clear its assurance bar first.
Emits a contract evaluation event for every decision, recorded in the hash-chained ledger.
PATH is the intent classification and task orchestration layer. It inspects user prompts alongside institutional context to decompose complex goals into multi-step execution plans.
Maintains model-agnostic routing, dynamically selecting local Ollama workers or cloud backbones based on hardware availability and security clearance.
Because routing is model-agnostic, a cloud outage falls back to a local model rather than stopping the node.
BEACON streams live progress from active agent daemons over WebSocket to the local UI.
It relays intermediate execution updates without the payloads, so a watcher can follow a background task without its contents crossing the wire.
It is the event bus between the local workers and the UI. There is no connector to an external monitoring product; what it emits is the same JSONL the audit trail records.
COMPASS records a hash-chained evidence log of every session trace, tool call and model response, with signed checkpoints over the chain.
Provides audit provenance detailing exactly which institutional knowledge notes were referenced, which models executed the plan, and whether code execution was container-verified.
Exports the evidence a risk function or an external auditor asks for, in a bundle they can verify without CAIRN.
ATLAS synthesizes unstructured enterprise data into a 4-layer memory fabric combining Episodic SQLite Event Ledgers, Knowledge Notes, Entity-Relationship Graphs, and Semantic Vector FTS.
Checks document freshness and provenance before context reaches the model, and records which fragments were supplied. Grounding reduces unsupported output; it does not eliminate it, and no retrieval layer can.
Indexes saved automation scripts to prevent re-inventing institutional workflows.
FORGE synthesizes candidate scripts and automation workflows using specialized local code models. It triggers a 3-stage verification pipeline (syntax compilation check, pattern pre-filtering, and container containment).
Keeps API credentials out of logs and prompts by redacting them, and holds an allow-list of saved scripts, in the local vault.
CRUCIBLE represents the Execution and Sandbox Containment boundary. It pairs directly with FORGE: FORGE shapes candidate code; CRUCIBLE runs it under container isolation (Docker) and grades the result before execution is trusted.
Enforces zero-network containment (--network none), a per-language memory ceiling (128m by default), and read-only container filesystems.
If runtime errors occur inside the container, CRUCIBLE feeds exact stack tracebacks back to FORGE for automated defect-repair loops.
ACCELERATOR profiles the compute on a machine — a discrete GPU, integrated graphics, a VM’s display adapter, or nothing — and tells the fleet what will fit in graphics memory and what would spill to system RAM.
It does not itself accelerate anything: inference runs on whatever backend is present, and this only decides where a model can run.
A machine whose graphics memory cannot be read is reported as unknown, never as zero — not knowing is not evidence that a model would spill.
MODEL FLEET is where the models a node can reach are managed. It routes tasks to a local Ollama backend or any OpenAI-compatible endpoint the operator has configured, local or cloud.
It heartbeats each host, discloses a failover when a host stops answering rather than switching silently, and enforces a cloud-spend budget whose action on exceeding is either fall back to local or block.
It runs air-gapped against local models, with no dependence on any single vendor.
SETTINGS is where an operator configures the node: the cloud provider and key, mail, the model fleet, evidence-anchor settings, and the installation of a signed corporate policy.
It can schedule an evidence export to a directory the operator declares, and it runs air-gapped. Role-based access control is not built, so it draws no per-user access boundaries.
There is no push distribution and no central control plane: CAIRN writes an evidence bundle, and your organisation moves it. A signed corporate policy is installed on each node by whatever channel you already use.
