Skip to content
OpenProse
1.6kInstall

The OpenProse Manual

A new kind of language for a new kind of computer.

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.

View on GitHubBrowse examples

Concepts

The OpenProse VM

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.

1

Simulation Is Implementation

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.

2

Discretion Text **...**

When you need AI judgment instead of strict execution, write the condition as discretion text. The ** ... ** markers let you speak directly to the VM: it evaluates the condition semantically. Structured control flow where it matters, natural language where you want flexibility.

3

Structure + 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.

4

Open Standard, Zero Lock-in

OpenProse programs are harness-agnostic. The language defines an abstract host interface (session spawning, filesystem state, tool calls, user input) that any Prose Complete harness implements. A program written for Claude Code should read the same on Codex, OpenCode, or Amp; only the host primitive adapter changes.

5

The Deterministic Harness

The deterministic harness runs standing responsibilities by evented reconciliation. 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. Benchmarks are openly pending.

The stack

One language. Two phases.

OpenProse is two layers: the language you author and the harness that runs it. Forme wires everything at compile time; the run phase executes the frozen output.

ProseLanguage

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 five kinds from responsibility to function.

FormeCompile phase

The intelligent dependency-injection layer. It matches each Requires to a Maintains and emits the wired topology; the compile step freezes it into the manifest the harness 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.

HarnessRun phase

The deterministic harness 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 the devtools viewer. Benchmarks are openly pending.

The frontier

Prose Complete

A system is Prose Complete when it runs a sufficiently intelligent model and supports the OpenProse primitives: session spawning, filesystem state, tool calls, and user input. Because the agent is the compiler, the same .prose.md source runs on any harness that can play the part: Claude Code, Codex, OpenCode, Pi (with its sub-agents extension), whatever you trust. The requirement is modest, and the hosts you already use meet it today.

Most agents we've tested are complete enough to be useful once they map those primitives. 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.

Prose Complete

the bar · run any .prose.md

Prose Complete today

Maps the primitives and runs contracts. Breaks only at the hard edge.
  • Claude Code+Opus 4.8
    Long-running programs.vibe
  • Claude Code+Sonnet 4.6
    Long-running programs.vibe
  • Codex CLI+GPT-5.5
    Sessions simulated in the weights.anecdotal
  • Deterministic harness+Opus 4.8
    Our own; early access.preview

Under test

Being measured now. Verdict pending.
  • OpenCode+Sonnet 4.6
    Sub-agents just landed; measuring now.anecdotal
  • Pi
    With the sub-agents extension.
  • Claude Code+Haiku 4.5
    Smaller model; genuinely unknown.preview
  • Amp+Opus 4.8 / Sonnet 4.6

Composition in practice

Shared functions, delivery workflows, graded outputs.

Responsibilities are the top-level outcomes. Beneath them, reusable functions do the actual work: scanning, classifying, drafting, scoring. Above them, delivery workflows bind responsibilities to cadences, channels, and human-review gates. Two concrete flows from our own experiments in running the company on Prose:

Daily to Slack

intelligence-daily

  1. mention-intelligence and competitor-intelligence run in parallel, each calling platform-scanner across the monitored platforms.
  2. Results are merged into a 2-minute briefing. No human gate, just a read-only digest.
  3. std/delivery/slack-notifier posts it to the team channel. An out-of-band std/evals run grades the briefing against the contract after the fact.

On demand, human-gated

gtm-pipeline

  1. lead-enrichment takes a name or company and composes person-enrichment + company-enrichment, then adds qualification and a Save/Grow framing.
  2. program-designer drafts two Prose programs (one Save, one Grow) tailored to the lead. The output is demo-ready contract files, not bullet points.
  3. 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 (responsibilities calling functions, delivery workflows, out-of-band evals) repeats across the experiments. Reuse is the point: a function written for one responsibility tends to become the primitive for three others. The experiments, with their contracts, are on Field Notes.

FAQ

Common questions

What is OpenProse?
OpenProse is a declarative language for standing AI work. Programs are Markdown contracts (*.prose.md) that declare what should stay true; the system works out how much model work it takes to keep it that way. It installs as a skill, so any Prose Complete agent can author and run contracts, and we ship a deterministic harness we recommend for running them.
How is this a VM?
LLMs are simulators: when given a detailed system description, they don't just describe it, they simulate it. The prose.md spec describes a VM with enough fidelity that reading it induces simulation. But simulation with sufficient fidelity is implementation: each session spawns a real subagent, outputs are real artifacts. The simulation is the execution.
How is the managed cloud different from the open-source version?
The open source version is the language: install as a skill, write .md programs, run them in Claude Code, Codex, OpenCode, Amp, or any "Prose Complete" harness. Free, MIT-licensed. The managed cloud runs those same programs on our infrastructure: on a schedule, on events, with durable traces, signed receipts, and guarded trigger endpoints. Cloud is early access today. You write programs with the OSS; request access to run them at scale without you in the loop.
How do I install it?
Run: npx skills add openprose/prose. This installs the OpenProse skill in your AI coding assistant. No other dependencies required.
What systems support it?
Claude Code, OpenCode, Amp, Codex, or any other "Prose Complete" harness. The language defines an abstract host interface: any "Prose Complete" harness that supports file IO and subagent spawning can execute Prose programs.
Does this lock me into Claude?
No. 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. Declarative programs get cheaper and smarter as models improve; you don't refactor every time the landscape shifts.
What are contracts?
Contracts are the declarations in a *.prose.md file. A responsibility declares ### Requires (what it subscribes to) and ### Maintains (the truth it keeps); a function declares ### Parameters and ### Returns. They serve as types for AI programs, and Forme reads them at compile time to wire the topology.
What is Forme?
Forme is the compile phase. It semantically matches each ### Requires to the ### Maintains that satisfies it and emits the wired topology the runtime follows. Intelligent at compile, dumb at run: the model work happens once, ahead of time, not on every execution.
Why Markdown, not YAML or a custom .prose syntax?
Human understanding is the bottleneck. YAML is precise but alien. A custom syntax needs a parser and fights the model's training. Markdown is what your team already writes, what the model already reads, and what already diffs, reviews, and documents itself in every tool you use. OpenProse structures Markdown with contracts; it doesn't replace the medium.
Why not just plain English?
English is already an agent framework; we're structuring it, not replacing it. Plain English doesn't distinguish sequential from parallel, doesn't specify retry counts, doesn't scope variables. OpenProse uses English exactly where ambiguity is a feature, and structure everywhere else.
How is this different from SKILL.md or AGENTS.md?
Same substrate: Markdown. Different purpose. Anthropic's SKILL.md packages a single capability for a model; an AGENTS.md gives agents instructions for working in a repository. An OpenProse program specifies a composition: responsibilities wired together by contract, each with declared inputs, the truth it maintains, and invariants. OpenProse doesn't replace SKILL.md; the language itself installs as a skill.
Why not LangChain, CrewAI, or AutoGen?
Those are libraries that orchestrate agents from outside. OpenProse runs inside the agent session: the session itself is the runtime. This means zero external dependencies and portability across any AI assistant.
How does this compare to BAML, DSPy, or similar?
Those require a harness outside the model to execute orchestration. OpenProse pushes the orchestration down into the model itself: your harness is the runtime, your Markdown is the program. Different layer of the stack.
How does a team share and version OpenProse programs?
Programs are Markdown files: version them in git like any other source. Dependencies resolve git-natively by host/owner/repo/path ref, pinned in a prose.lock, and prose install clones them into a local deps/ cache. Runtime still reads pinned Markdown snapshots from disk, so review remains reading diffs and lockfiles, not trusting a hidden service.
What happens when a Prose program fails?
Every run writes a durable trace under .agents/prose/runs/{id}/: the compiled topology, snapshots of the program and its sources, workspace artifacts, declared bindings, and a running vm.log.md. Responsibilities also persist a world-model and a signed receipt ledger. Debugging is diffing those files. A responsibility or function can declare ### Strategies for judgment calls and edge cases and ### Invariants for what must hold. Tests (kind: test) are .prose.md files with fixtures and natural-language expectations.
Is OpenProse deterministic?
The language isn't deterministic; it's unambiguous. A capable model reading an unambiguous contract implements the requested call flow faithfully, and the language never adds fallbacks or type systems to replace the model's judgment. Determinism lives in the harness: its reconciler decides skip or render, records receipts, and runs exactly what the contract declared, without ever deciding meaning itself.

Go deeper

The manual is a curated bridge. For the full language specification, examples corpus, and reference docs, go to the source.

Docs: What is OpenProse?GitHub: example programsdocs.prose.md