openprose

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.

Structure