drag the sky. eight contracts hide in it.

COOLDIS

by Emotion Scientific

A governed runtime for agent workloads. The kernel does not think; it keeps the receipts.

↓ receipts

WHAT THIS IS

state = fold(events)

Cooldis is a Rust kernel for declared agent workloads, in the microkernel tradition: closer to seL4 than to Semantic Kernel. It does not think, prompt, or orchestrate. It owns mechanism and refuses policy: grants, tool visibility, provider access, dispatch, cancellation, resume, receipts.

Each step folds the event stream, refreshes policy, computes the admissible continuations, executes, records. A workflow is a strict continuation policy; an agent is an adaptive one. Settings on the same machine, not rival product categories.

Chaotic, but lawful.

TRUTH IS APPENDED

The only durable truth is the stream: append-only, totally ordered, never mutated. Order comes from sequence, not time; wall-clock is witnessed on every event and trusted for nothing.

Every event declares its origin: witnessed, the world did it, or discharged, a coupled function did it. Model output is chaotic by definition, so it crosses as events with provenance, never as views. Recovery re-runs from the top and feeds completed admissions from the log; replay folds the policy that was recorded, never the one currently loaded.

Replay, resume, audit: for free, and not as suggestions.

LAW IS COMPILED

The membership test is mechanical: if changing a thing could make the receipts lie, it is compiled into the kernel. Below the bar, configuration. Above it, law.

  1. 1

    Every surface is faithful, or it is illegal.

  2. 2

    Every discharge carries provenance; chaotic output discharges as events, never as views.

  3. 3

    Assembly is deterministic, budgeted, and receipted; it selects and arranges, never creates.

An effect without a receipt did not lawfully happen.

AUTHORITY IS LEASED

Published is not visible; visible is not granted; granted is not unobserved.

A mandate is a standing grant with a grantor, a scope, a budget, an expiry. Leased, never owned.

The vocabulary of change is denial-driven: a petition widens the universe, a condensation settles recurring work into an operation, a demotion narrows what failed.

DESIGN IS GOVERNED

The design itself runs under law. A deterministic oracle (compiler, tests, the kernel's own receipts) faces a written canon; every anomaly between them is triaged: absorb it, escalate it, or fix the code. A settled change must leave a mechanical guard behind. Elegance does not downgrade case 2 to case 1.

Seven amendments so far. The record of them is append-only, like everything else here.

The final authority is a human, and is never modeled.

RECEIPTS ARE WITNESSED

Receipts record what the runtime actually did, and are never recomputed.

≈137,000lines of Rust
17workspace crates
800+tests in CI
3laws
4ladder layers
7amendments

Operations and manifests are content-addressed: aliases resolve to immutable hashes, and the resolution emits a receipt. The numbers above are counted from the tree, not the roadmap.

SURFACES ARE FAITHFUL

One kernel, many surfaces: CLI, daemon, RPC app-server, MCP server, ACP agent, a grant-scoped virtual filesystem, bash builtins over operations, a Wasm runtime for declared folds.

Every surface is a projection of the same stream. A surface selects and arranges; it never creates, and it never steers.

If two surfaces disagree, one of them is illegal.

WHERE IT STANDS

You declare the agent before anything runs: model, tools, secrets, permissions, context policy. The kernel turns the declaration into governed work, durable on your machine.

Experimental, and says so on the box. V1 is deliberately local: packageable agents, no cloud between you and your own event stream. Cloud placement, registries, marketplaces: designed, named in the lexicon, and not claimed until they exist.

The console ships inside the kernel release: cooldis console.