OpenProse

OpenProse is a programming language for AI sessions. You write a *.prose.md contract that declares an ideal world-model -- the truths you want kept current -- and an agent host reads that contract, wires the work, and keeps the truths true. The program is not a Python graph or a hosted workflow. The program is the Markdown, and it runs inside the agent session itself.

This is the foundation. Reactor is the deterministic harness built to run it. They are not two systems; they are one system, two layers. OpenProse is the language you author in. Reactor is the recommended host that serves it efficiently. The contract is harness-agnostic; the same Markdown runs on any compliant host.

Declare outcomes, not steps

A prompt says do this. A contract says these things must be true when you are done, and they must stay true as the world changes. Intent lives only in the contract (Tenet 1): the *.prose.md carries 100% of the semantic weight. There is no second authored surface for meaning -- not a prompt, not a config, not a tuned judge. Compiled artifacts and projections are derived views; when one disagrees with the Markdown, the Markdown is right.

So you do not script a sequence of model calls. You declare a standing goal and the shape of the truth that satisfies it, and you let the host figure out the rest -- which is exactly what makes the work reusable, inspectable, and portable.

A type system for agent workflows

The cleanest way to hold OpenProse in your head is as a type system for agent work:

A bare prompt is any -- it runs, but nothing is checked. A contract is a typed function: inputs and outputs are declared, callers can reason about composition, and violations fail loudly.

You would not write a 2,000-line TypeScript system in any. Multi-step agent workflows are the same. A contract gives the model a typed shape to satisfy instead of a pile of instructions, and gives you something better than vibes to inspect afterward.

The render atom

Underneath every kind of contract is one operation that both the compile and run phases agree on -- the render atom:

(contract, evidence, prior world-model) -> (new world-model, receipt)

A bounded agent session reads the contract and the new evidence, queries the truth it maintained last time, computes the next world-model, and signs a receipt. The receipt is the durable commit; it is the audit record, the composition edge, and the exit ticket all at once (Tenet 5). Continuity lives in that trail, not in a session that runs forever (Tenet 3) -- a one-shot run is just the degenerate case of a standing one.

The authored surface is small and complete

The whole language is five kinds and a fixed set of ### sections.

• responsibility -- the headline kind. A standing goal mounted as a node whose maintained truth is kept current over time. Node-ness comes from mounting, never from statefulness.
• function -- a called, ephemeral helper that binds ### Parameters and returns ### Returns. Never a node.
• gateway -- an external source (webhook, cron, manual ingress) that maintains the latest incoming truth.
• pattern -- reusable coordination, expanded into nodes at compile time.
• test -- assertions over a subject's world-model or receipts.

The load-bearing section is ### Maintains: the world-model schema, doing four jobs at once. It types the maintained truth, carries the canonicalization spec (which fields are material and how they normalize), declares optional facets (named sub-truths a consumer can subscribe to one at a time), and states postconditions (the obligations a render must satisfy before it may commit). A render that cannot satisfy its postconditions commits nothing -- the prior truth stands and a failed receipt records why.

Hands off to Reactor

OpenProse defines the contract and what it means. It deliberately does not define the runtime that serves it -- the two-phase compile/run split, memoization, the continuity clock, receipts, and composition are the harness's concern. Reactor (@openprose/reactor + reactor-cli + reactor-devtools) is that harness: it compiles your contracts into a content-addressed DAG and runs them so that expensive model work happens only when something material actually moved. Cost scales with surprise, not the clock.

You can author OpenProse against any Prose-Complete host. Reactor is the recommended fast path because it makes the maintained-truth model real, deterministic, and observable.

Source of truth

The canonical execution behavior lives in the open-source open-prose skill (currently 0.15.0). These docs are orientation. If the docs and the skill ever disagree, trust the skill.

The conversation always ends. The responsibility shouldn't have to.