CyberAlchemy
On this page Pillars Layers What's built Roadmap

The system

An operating system for humans and agents.

Give the same specification to an LLM agent twice and you get two different test suites, two implementations, two ideas of "done." The agent is fast. It is not reproducible. CyberAlchemy is the response: turn intent into governed, evidenced, reusable tools, where the same artifact is legible to a person and executable by a machine.

Three pillars

Different layers, different jobs. Keeping them distinct is the point.

DomainSpec says what is meaningful in a domain. Arcanum says how the work is done. Saturn closes the loop with evidence. CyberAlchemy is the whole.

DomainSpec

The structured-intent layer

Meaning made explicit. A closed vocabulary of 25 meta-types and 29 typed relationships, each edge with a fixed signature. From a typed model you derive the tests, metrics, and contracts by rule, not by guess: T = f(C, R, Δ). Same model in, same obligations out.

Arcanum

The execution layer

How the work gets done. Reusable agent capabilities (sigils), composed routes (spells), and a development loop from a wild idea to a validated slice. Every serious output leaves receipts. This is the part you can open and read today.

Saturn

The convergence loop

A spec is a baseline; reality drifts from it. Saturn is the intended convergence loop: observe what was built, compare it to the DomainSpec baseline, detect the drift, correct, verify, and feed the result back into governance. It is the target frame — today only the execution layer (Arcanum) is shipped publicly; Saturn names where this is going.

How they compose

Intent enters, evidence returns, governance tunes.

        intent  ───▶  DomainSpec   (what is meaningful: typed concepts + relationships)
                          │  derives
                          ▼
                       Arcanum     (how the work is done: sigils, spells, the loop)
                          │  produces
                          ▼
                        Saturn     (evidence: observe → compare → drift → correct → verify)
                          │  feeds back to governance
                          └──────────────▶  tunes DomainSpec + Arcanum

   CyberAlchemy = the whole loop, for humans and agents.

Status, honestly: today the execution layer (Arcanum) is the part that is public and shipped, and DomainSpec's deterministic engine is built and validated (see "What is built"). Saturn — the full convergence loop — and DomainSpec-as-a-published-layer are the intended frame, not yet a shipped public surface. This page names the target so the development is legible while it is still being built.

The agentic system

Coordination is explicit, and governance has a cost.

Humans and agents operate through these layers together. Multi-agent work goes through a dispatch system with a hard rule: agents meant to disagree are paired so they actually do, and nothing runs until a human confirms the plan. Adding rules to agents can lower compliance — an effect the work formalizes as governance attenuation — so the answer is structure (separate the agent that observes from the agent that acts; detect drift deterministically), not more rules.

What is built

Scoped to what exists and was validated.

Where something is planned, it says so. The development happens in the open so the claims stay tied to evidence. Two generators sit behind one contract: the LLM path is free and open; the deterministic engine is the optimized, reproducible path for the backend-domain slice — we show its results, not its algorithm.

  • A deterministic test-derivation engine is built. It realizes the C2 calculus T = f(C, R, Δ): the same specification documents produce byte-identical test obligations, across runs and machines. 95 tests pass; 0 type errors. We show the results here; the derivation itself is what we build with teams that need it.
  • It refuses rather than fabricates. When a spec expression is not formal enough to derive a real test, the engine emits a counted, visible gap — it does not invent a plausible test. That refusal is a measurement: the gap count is a spec-formalization metric. On the pilot feature it reads 96%.
  • Fault-detection was measured. Mutation testing on the pilot (financial-settlement — a single feature, not a corpus result): after authoring one closed-form rule the spec had left implicit, the derived suite's score moved 38.75% → 54.37%, and the hardest module doubled (17.2% → 36.56%). The regenerated suite passed 13/13 against the real, unmutated code — the gap was unwritten spec, not divergent code.
  • The engine derives its own feature. Run on its own DomainSpec docs, it produces its own test spec. The self-application is a fixpoint, not a slogan.
  • A conformance validator is specified. A pre-registered experiment defines a check that the types and edges in a generated spec are valid against the taxonomy and the relationship signatures. Defined and frozen; not yet built.
  • Multi-agent dispatch is in use. The dispatch ledger records real runs, each human-gated, dominated by research and review work.

Craft

The state of building something, kept explicit.

Work generates residue — the blocker you are circling, the half-made decision, the gap you mean to close. Craft is a small, file-backed ledger that holds that state on disk (contexts, blockers, decisions, gaps, recomposition), so a person or an agent resumes exactly where the work was. It coordinates and records; it does not execute, and it never makes one project's notes everyone's source of truth. How Craft works →

Roadmap

Planned, not done.

engine

Widen and harden

Widen the engine's coverage to more document classes; strengthen value-level checks for the hardest computations; take mutation testing from one pilot to a corpus.

pipeline

Replace the stochastic stage

Build the conformance validator; run the deterministic engine as the live test-spec stage in place of the LLM for the backend-domain slice. UI and scaffolding stay generative by design.

theory

Governance attenuation

The larger experiments on why governance fidelity decreases as layers accumulate, and on self-governance, remain open.

Absorb the complexity into the structure, so the people working inside it do not have to carry it.