Observe
Read telemetry from what was actually built and run.
Saturn
A system that defends its own architecture.
Saturn is the convergence loop we are building. It treats domain intent as a reference baseline, measures reality against it, and is designed to act on drift — not only report it — turning governance into executable behavior. The engine and audits beneath it exist today; the closed loop that wraps them is the frame we are assembling.
The architecture of convergence
Intent flows down. Truth flows up.
Saturn runs as a lifecycle. Intent descends into execution; evidence rises to inform governance. The same loop closes on itself.
Evaluate
Compare it against the domain contracts — the intent baseline.
Decide
Determine the corrective state when reality has drifted.
Route
Execute the correction through the agentic substrate.
Verify
Confirm closure, then feed the result back into governance.
Four layers, one meta-loop
Saturn traverses every layer.
It reads telemetry from the perception layers, evaluates it against the intent layers, and triggers responses through the execution and regulation layers.
Intent flows down the stack; evidence of drift flows back up. Saturn is the meta-loop that closes across all four layers.
Where humans set direction
The human harness (priorities, dashboards) and governance (constants, quality gates).
Where meaning is fixed
Foundation (domain structures, ontologies) and formalization (feature contracts). This is the DomainSpec layer.
Where the work runs
The agentic substrate (workflows, skills) and infrastructure (runtime, CI loops).
Where truth is measured
Quality (deterministic tests) and observability (drift telemetry). This is where the audits live.
Status, honestly: Saturn is the convergence frame. Today the execution layer (Arcanum) is shipped publicly and DomainSpec's deterministic engine is built; the full closed loop is the intended target, not yet a shipped public surface.
Get started
Run the audits free. Go deeper with the language and the proofs.
The layering, tag, and alignment audits are open — run them today as Arcanum skills, at no cost. When you need derivation that is deterministic and obligations that are machine-proved, that is where we go deeper together: the DomainSpec language and the Lean validations. The measured results are public — determinism, fault detection, machine-checked proofs — and we build the engine and the proofs with the teams that need them.
The audits
- Layering audit — does the system respect its own layer boundaries (domain depends on nothing; each layer only on the one below)?
- Tag audit — does the code still trace to the spec it claims, with no orphaned or drifted tags?
- Alignment audit — does what was built still match the domain intent, and where has it diverged?
- LLM test generator — the free, open reference path from spec to tests.
Language & Lean validations
The DomainSpec language's deterministic derivation, and the Lean validations that prove your obligations hold. We show the results — determinism (same docs in, byte-identical out), measured fault detection, machine-checked proofs — and build the engine with teams that need provable guarantees.
Open by design: the framework and calculus — the meta-types, the typed relationships, the derivation calculus — stay public. The optimized engine and the proofs are what we build with you.