A long-running AI session is a Turing-complete computer. OpenProse is a programming language for it.
Website • Language Spec • Examples
---
name: research-with-agents
kind: program
services: [researcher, writer]
---
requires:
- topic: a research question to investigate
ensures:
- report: an executive-ready summary of research findings
strategies:
- when initial research is shallow: deepen with more targeted queries
- when findings are too technical for executives: simplify language while preserving accuracy
Overview
OpenProse is a programming language for AI sessions. Programs are Markdown files (.md) with YAML frontmatter and contract-based semantics — you declare what a program requires: and ensures:, and the runtime figures out the rest. Multi-service programs are auto-wired by the Forme Container, which matches contracts across components before the VM executes them.
This is the intelligent inversion of control: a container that understands context and intent, not just configuration.
OpenProse runs on any Prose Complete system — a model and harness combination capable of simulating the VM upon reading its specification. Currently supported: Claude Code + Opus, OpenCode + Opus, Amp + Opus. Your programs are portable across all of them; there is no library lock-in.
Legacy .prose programs still run via v0 mode (prose run file.prose). Use prose migrate to convert them to the new .md format.
Install
npx skills add openprose/prose
By installing, you agree to the Privacy Policy and Terms of Service.
Update
npx skills update openprose/prose
How It Works
LLMs are simulators. When given a detailed system description, they don't just describe it — they simulate it. The OpenProse specifications describe a virtual machine and a dependency injection container with enough fidelity that a Prose Complete system reading them becomes those systems.
This isn't metaphor: each session triggers a real subagent, outputs are real artifacts, and state persists in the filesystem. Simulation with sufficient fidelity is implementation.
Two-Phase Execution
For multi-service programs, execution happens in two phases:
| Phase | System | What It Does |
|---|---|---|
| Phase 1 | Forme Container (forme.md) | Reads all services, matches requires:/ensures: contracts, produces a wiring manifest |
| Phase 2 | Prose VM (prose.md) | Reads the manifest, walks the dependency graph, spawns sessions, passes data |
Single-service programs skip Phase 1 and execute directly in the VM.
| Aspect | Behavior |
|---|---|
| Contract matching | Strict — requires/ensures must resolve |
| Execution order | Strict — follows dependency graph exactly |
| Session creation | Strict — creates what program specifies |
| Context passing | Intelligent — summarizes and transforms as needed |
| Strategy application | Intelligent — applies declared strategies to edge cases |
| Completion detection | Intelligent — determines when "done" |
Language Features
| Feature | Description |
|---|---|
| Contracts | requires: inputs and ensures: outputs for each service |
| Shapes | Typed structure declarations for contract values |
| Strategies | Declarative edge-case handling (when X: do Y) |
| Errors | Structured error declarations |
| Invariants | Runtime constraints that must hold throughout execution |
| Services | Components wired by the Forme Container |
| Sessions | Subagent spawning (call service or session "prompt") |
| Parallel | parallel: blocks with join strategies |
| Variables | let x = call service |
| Loops | loop until condition (max: N): and repeat N: |
| Conditionals | if condition: / choice criteria: |
| Error Handling | try/catch/finally, retry |
| Pipelines | items | map: session "..." |
| Persistent Agents | persist: true / resume: agent |
See the Language Reference for the VM spec and Forme Reference for the container spec.