OpenProse brings contracts, composition, and version control to the Markdown your agents run on.
A Prose program is a Markdown file with a contract — requires, ensures, strategies — not a chain of prompts. Forme auto-wires services by semantic match; any Prose Complete harness (Claude Code, Codex CLI, …) executes it. The program declares what, not how, so it gets better as models improve. All MIT.
---
name: hunter
kind: program
services: [analyst, ranker, compiler]
---
requires:
- data_warehouse_url
- codebase_ref
ensures:
- brief: weekly growth findings, ranked by
confidence × impact, each with an owner and
a trivial next step
strategies:
- prefer findings with code-level evidence
- surface instrumentation gaps as first-class findingsOur marketing, GTM, and ops run on Prose programs. Thirteen responsibilities run the company — mention tracking, competitor intelligence, lead enrichment, outreach drafting, market indices.
See how we run our company →OpenProse is a programming language for AI sessions. Programs are Markdown files with requires/ensures contracts that define what services need and produce. Forme, our intelligent dependency injection system, auto-wires services by contract matching. The model+harness is the runtime — the AI session itself executes the program.
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.
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 and enterprise controls. Cloud is early access today. You write programs with the OSS; request access to run them at scale without you in the loop.
Run: npx skills add openprose/prose. This installs the OpenProse skill in your AI coding assistant. No other dependencies required.
Claude Code, OpenCode, Amp, Codex, Gemini CLI, 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.
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.
Contracts are requires/ensures declarations that define what a service needs (its inputs) and what it produces (its outputs). They serve as types for AI programs — the requires block declares dependencies, the ensures block declares guarantees. Forme uses these contracts to auto-wire services together.
Forme is intelligent dependency injection that auto-wires services by contract matching. Instead of manually connecting components, Forme reads the requires/ensures contracts on each service and automatically determines how to wire them together. It's IoC powered by model understanding, not configuration files.
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.
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.
Same substrate: Markdown. Different purpose. SKILLS.md and AGENTS.md document a single capability a model has. An OpenProse program specifies a system — multiple services wired together by contract, with declared inputs, outputs, strategies, and invariants. OpenProse doesn't replace SKILLS.md; it structures it. The language itself installs as a skill.
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.
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.
Programs are Markdown files — version them in git like any other source. To depend on another team's programs, reference them by owner/repo/path in your .prose file; prose install clones them into .deps/ and pins prose.lock. Runtime reads from disk. No registry, no lock-in. Code review is reading diffs. Sharing is git push.
Every run writes a durable trace to .prose/runs/{id}/: the manifest, the program, intermediate artifacts, per-agent logs, and a running state.md. Debugging is diffing those files. Each service can declare ### Strategies for known failure modes and ### Invariants for what must remain true. Tests (kind: test) are .md files with fixtures and natural-language expectations.
OpenProse is not deterministic — it's unambiguous. A sufficiently intelligent model reading an unambiguous Prose program implements the requested call flow faithfully, but the language doesn't add deterministic fallbacks or type systems to replace model judgment.