how it works
judgment, determinism, and a record of both.
The fabric is two threads held structurally apart — one decides, the other proves — over a record that sits under every move. You never have to know which thread is doing what; you state intent, and the fabric handles the rest.
the design principle
judgment lives in cache. determinism lives in substrate.
Most systems entangle the two: the code that decides what to do is the same code that does it, so neither half can be audited, swapped, or trusted on its own. Cachenetics keeps them apart — and once they are separate, every action carries both a decision and a proof.
Decides, never executes
It reasons, it learns, it chooses what to do or refuse — and it acts only through substrate's audited surface. Its judgment is the product; its reach is bounded by the environment, which is what makes autonomous judgment safe to hand real work to.
Executes, never decides
Given a task, it does exactly that, verifies the result, records both, and refuses anything it cannot prove safe. It is deterministic — the same request produces the same outcome and the same record — so any action can be replayed and checked.
Pulled apart, each half stands on its own, and every autonomous action has both a decision (cache) and a proof (substrate) — double-entry for machine work. The second law follows from the first: nothing acts off the record.
the deterministic thread
substrate — the environment.
An audited environment for operating real systems. It does what it is told, proves it, and writes it down — and it holds no opinion about what should be done.
Exact, verified, recorded
- Carries out the operation it is given — nothing more.
- Verifies the result before calling it done.
- Records the action and its outcome to a verifiable, queryable log.
- Fails closed — what it cannot prove safe is refused and recorded, not attempted.
Deterministic and auditable
The same request always produces the same outcome and the same record, so every action can be replayed, compared, and proven after the fact. It also keeps watch over the systems it runs, surfacing what needs attention and acting only within the limits it has been given.
substrate holds no judgment — it carries out what it is told and records the receipt. The deciding happens in cache.
the agentic thread
cache — the agent.
Judgment that decides, learns, and refuses on your behalf. It gets better at recurring work because it curates what it knows, rather than simply piling it up.
Swappable by design
It runs on a mix of local and frontier models behind a single interface, so adopting a better one is a configuration change, not a migration. Routine steps can run on a small local model, with the harder calls reaching for a frontier one.
Learns carefully, earns autonomy
- Learns from what you tell it and from what it does.
- Rejects bad or contradictory guidance before it can take root.
- Serves a single operator or a whole team.
- Consequential actions pass an approval gate — autonomy is earned from a track record, never assumed.
cache executes nothing outside substrate. Its judgment is bounded by the audited surface — the constraint that lets you hand it real work without handing over the keys.
what it runs on
yours, on your hardware, on the record.
Self-hosted and local-first. Runs on your own hardware, with no hard cloud dependency.
Your systems and data stay inside your environment. Nothing has to leave to get work done.
A swappable mix of local and frontier models. Knowledge persists as models come and go.
A hash-chained, queryable log. Every state change carries a receipt you can check.
One operator or a professional team — the same fabric, the same guarantees.
Fail-closed by default. Refusal is a first-class outcome, surfaced with its reason.
get started
see it on your own stack.
Book a short walkthrough — we map your work and show you where the fabric fits, before anything changes.