Conclave

Conclave started as a question: what would a programming language for AI agents look like? Not machine code, and not another general-purpose language to rewrite everything in. Something closer to plans and constraints, structured as a graph that several agents can contribute to, review and argue over, and that becomes fully deterministic once everyone agrees.

The pipeline

.conclave source → lower → Plan IR (canonical JSON)
                 → seal  → manifest pinning every capability by sha256
                 → pack  → self-contained artifact.cnclv
                 → run   → trace.json, same bytes every time

Every stage hashes its output. Change a rate limit, an import or a capability binary and the hash chain breaks.

A program declares capabilities (external calls, run as subprocesses over a one-line JSON stdio protocol, written in any language), intrinsics (pure built-ins) and goals with a want block and a constraints block:

goal SummarizeUrls(urls: List<Url>) -> Json {
  want {
    map urls as url {
      let html = fetch(url);
      emit summarize(extract_text(html));
    }
    return assemble_json(collected);
  }
  constraints {
    determinism.mode == "sealed_replay";
    rate_limit(fetch) <= 2 req/s;
  }
}

map, reduce, if/else and imported goals each lower to a named subgraph, and every node carries the subgraph_id it came from, so a trace says which map iteration, branch or imported module produced which output. Goals can be published to a local module cache and imported by hash.

What keeps it deterministic

• BTreeMap everywhere, never HashMap
• A virtual clock in the scheduler, no wall time
• Seeds are explicit inputs
• Ed25519 verification at seal time

v0.2 is done, including “Conclave in Conclave”: a sealed capability that lowers other .conclave files. The repo has a blog/ folder with the reasoning behind it, starting with a human-written preamble.

Running it

cargo build --release
cargo test --workspace

docs/hello_world.md walks through lower, seal, pack and run end to end.