The OpenProse Manual
A long-running AI session is a Turing-complete computer. OpenProse is a programming language for it. Write contracts in Markdown; the model plus harness is the runtime.
Concepts
LLMs are simulators. When given a detailed system description, they do not just describe it. They become it. OpenProse exploits this property to build a real runtime from a Markdown specification.
The OpenProse spec describes a VM with enough fidelity that reading it induces simulation. Each session spawns a real subagent, outputs are real artifacts. Simulation with sufficient fidelity is implementation: the session does not describe the execution, it is the execution.
**...**When you need AI judgment instead of strict execution, break out of structure. The ** ... ** syntax lets you speak directly to the VM: it evaluates conditions semantically. Structured control flow where it matters, natural language where you want flexibility.
English is already an agent framework. We are structuring it, not replacing it. OpenProse uses English exactly where ambiguity is a feature, and structure everywhere else. The language does not fight the model's natural mode of reasoning; it gives that reasoning a contract.
OpenProse programs are framework-agnostic. The language defines an abstract host interface (spawn_session, read_file, write_file, ask_user) that any Prose Complete harness implements. A program written for Claude Code runs on Codex, OpenCode, or Amp without modification.
Reactor is the evented reconciliation runtime for standing responsibilities. The reconciler is deliberately dumb: it fingerprints each contract and its inputs and re-renders only the ones that actually moved, while everything unchanged is a memo hit at zero fresh cost. There is no judge step. Every decision leaves a content-addressed receipt, and spend scales with surprise, not the clock. Shipped as v0.2; benchmarks openly pending.
The stack
OpenProse is three composable layers. You author at the language level; the framework wires it; the runtime executes it.
A programming language for AI sessions. Write a contract in Markdown; declare what should happen. Drop into ProseScript when you want explicit control flow.
*.prose.md files are versioned with your project, in six kinds from service to system.
The intelligent dependency-injection framework. It matches each Requires to an Ensures, resolves dependencies, and produces a compiled manifest the runtime follows.
prose compile lowers your contracts into a dependency graph; on prose run, Forme wires it before the VM executes. IoC powered by model understanding, not configuration files.
The evented reconciliation runtime for standing responsibilities. The reconciler is dumb and deterministic: fingerprint the inputs, re-render only what moved, leave a receipt. Spend scales with surprise, not the clock.
Every decision leaves a content-addressed receipt; the ledger is append-only and chain-verifiable, so you can replay a run offline and keyless in reactor-devtools. Shipped as v0.2, benchmarks openly pending.
The frontier
A system is Prose Complete when it can run a .prose program of arbitrary complexity. Because the agent is the compiler, the same .prose.md source runs on any harness that can play the part: Claude Code, Codex, OpenCode, Hermes, Pi (with its sub-agents extension), whatever you trust. The requirement is modest: a filesystem, a shell, and sub-agents.
Most agents we've tested are complete enough to be useful once they have those three. The differences show up at the edges, and they keep shrinking: you write the contract down once, and every future model that can satisfy it gets to run it, with no rewrite. Here is where each one stands today.
Statuses are qualitative; no benchmark numbers. Evidence is vibe or anecdotal unless labeled. Honest data, no inflation.
.prose.mdComposition in practice
Responsibilities are the top-level outcomes. Beneath them, reusable services do the actual work: scanning, classifying, drafting, scoring. Above them, delivery composites wire responsibilities to cadences, channels, and human-review gates. Two concrete flows from OpenProse's own operations:
Daily to Slack
mention-intelligence and competitor-intelligence run in parallel, each calling platform-scanner across the monitored platforms.std/delivery/slack-notifier posts it to the team channel. The eval grades the briefing against the contract before the next run uses it as the baseline.On demand, human-gated
lead-enrichment takes a name or company and composes person-enrichment + company-enrichment, then adds qualification and a Save/Grow framing.program-designer drafts two Prose programs (one Save, one Grow) tailored to the lead. The output is demo-ready service files, not bullet points.std/delivery/human-gate holds the design for review before the irreversible step: customer-repo-scaffolder writing the customers/prose-{slug}/ directory.The same shape (responsibility / service / delivery / eval) repeats across all thirteen. Reuse is the point: a service written for one responsibility tends to become the primitive for three others. The full responsibility catalog, with every contract, is on Field Notes.
FAQ
Go deeper
The manual is a curated bridge. For the full language specification, examples corpus, and reference docs, go to the source.