Okay, OpenProse made it dead simple to make a multi-agent flow. I have a prose command to orchestrate 5 agents that all coordinate with beads and agent mail. Beautiful. cc @irl_danB
Henry Ventura · @hvent90
View on X →Stop scripting agents.Declare them.
Declarative by default. Reconciled on change, signed with a receipt.
$ npx skills add openprose/proseRuns inside Claude Code, Codex, or any Prose Complete harness.
Source
This is a Prose program.
A real *.prose.md file: the same source you commit, install, and run.
json-verifier.prose.md
--- name: json-verifier kind: function version: 0.15.0 --- # JSON Verifier ### Description Validates generated JSON before a downstream consumer uses it. ### Parameters - `candidate-json`: JSON text to validate ### Returns - `validation-report`: whether the JSON is valid, with parse errors and line references when validation fails ### Tools - `cli:jq`: JSON CLI available on PATH for syntax validation ### Strategies - when JSON validation fails, report the parse error and location without rewriting the input
$ prose run json-verifier.prose.md
compilingcontract
parameterscandidate-json
toolcli:jq on PATH
parsedcandidate-json
validatedcli:jq · 0 parse errors
returnsvalidation-report: valid
{ "valid": true, "errors": [] }
Representative output, not a live run.
The Parameters go in; the Returns come out. The model plus your harness is the runtime.
The stack
Author. Compile. Run.
OpenProse is one language and two phases. You author contracts; Forme compiles them into a wired topology once; a Prose Complete harness runs it.
ProseLanguage
A declarative language for standing AI work. Write a contract in Markdown; declare what should stay true. Drop into ProseScript when you want explicit control flow.
*.prose.md files are the source: versioned with your project, in five kinds from function to responsibility.
review.prose.md
---
kind: function
---
### Execution
let draft = call writer
let review = call critic
draft: draft
return review
FormeCompile
The compile phase. It matches each Requires to the Maintains that satisfies it, draws the subscription edges, and emits the wired topology the runtime follows.
prose compile lowers your contracts into the topology once; intelligent at compile, dumb at run.
prose compile
caller
└→ json-verifier · function
└→ cli:jq · tool ✓
→ manifest.next.json ✓
From the field.
Practitioners discovering that a declarative language for standing AI work changes how they work.
I just tried prose.md. Okay I really like. Why? I used it as a loop-wrapper for claude skills. And the SIMPLICITY is great~
Rijnard van Tonder · @rvtond
View on X →
adopted prose the last few days for my opencode workflows. being able to stitch together scripts, runners, sub-agents, skills, commands, etc into prose programs is such a mental-load unlock. i can build mini operating systems to execute complex workflows i've built without needing to remember how it's all wired.
bijan bina · @voidserf
View on X →
As a non-engineer, I cannot not love this idea: Open Prose relies "on the model to do the full orchestration", as opposed to more traditional frameworks who will still "wire all the steps together using a classical runtime (eg:Python)". An absolutely fascinating level of abstraction proposed here... And, on top of offering the project to the community, Dan is incredibly gracious in the replies.
Ben · @cocolitron
View on X →
I think this is immediately an essential tool for me. Just being able to implement a (research<->critique)->(implementation ->critique) loop is great. Does it work to be able to hand off between prose files? Am I even saying that the right way? Like if I did the above setup (coffeescript for prose.md lol) is that possible?
Max Caldwell · @max_takeoff
View on X →
@irl_danB @BenjaminDEKR please do! most interesting project of the last month by far
Gonzalo Nuñez · @gonzalo__nunez
View on X →
@irl_danB I use in folowing way Skill spawns prose Prose spawns parallel agent Each agent calls a skill Skill used to provide context to prose agents
David Hapunkt · @nichtsalsdavid
View on X →
@irl_danB just ran a 100 step process pretty fluidly, batched into groups of 10.
Michael Fraser · @zeroshotnothing
View on X →
example my issue: - have a claude skill to analyze some programs - skill is v long running - want to run it in a loop prose.md takes care of orchestration ^ i don't need to write "call subagents with this skill and do XYZ and aggregate the results"
Rijnard van Tonder · @rvtond
View on X →@Shpigford This looks like a perfect use case for OpenProse prose.md. It will make your e2e workflow more repeatable and reliable. @irl_danB
Winkle · @robbwinkle
View on X →
@irl_danB Actually.. I just tried it in @opencode. This is really interesting. The agent uses them flawlessly on initial testing. (Opus 4.5) I think I'll tryan mcp server and see if it can discover prose as tools and run as sub-processes. Or even a systemd vmspawn server.. very cooool
Tangled Circuit · @tangledcircuit
View on X →
Okay, OpenProse made it dead simple to make a multi-agent flow. I have a prose command to orchestrate 5 agents that all coordinate with beads and agent mail. Beautiful. cc @irl_danB
Henry Ventura · @hvent90
View on X →As a non-engineer, I cannot not love this idea: Open Prose relies "on the model to do the full orchestration", as opposed to more traditional frameworks who will still "wire all the steps together using a classical runtime (eg:Python)". An absolutely fascinating level of abstraction proposed here... And, on top of offering the project to the community, Dan is incredibly gracious in the replies.
Ben · @cocolitron
View on X →@irl_danB I use in folowing way Skill spawns prose Prose spawns parallel agent Each agent calls a skill Skill used to provide context to prose agents
David Hapunkt · @nichtsalsdavid
View on X →@Shpigford This looks like a perfect use case for OpenProse prose.md. It will make your e2e workflow more repeatable and reliable. @irl_danB
Winkle · @robbwinkle
View on X →Dogfooding in the open.
We run OpenProse on OpenProse. Responsibilities with scheduled and triggered runs and durable traces, an experiment in running the company on contracts. Alpha, frontier R&D, and fully honest about what that means.
Scheduled runs
alphaResponsibilities on a cron, each run leaving a durable trace in .agents/prose/runs/.
Eval loops
alphaProse programs that evaluate their own outputs: evals run inside the same session.
OpenProse on OpenProse
previewCompany responsibilities written as contracts, including this site. An experiment in progress.
See the full field notes for outcomes, run traces, and the dogfooding story.
Common questions
- 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.
- 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.
- 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.
- 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.
More questions? Read the OpenProse manual for the full FAQ, VM concepts, and worked examples.
Follow the build.
Field notes from building OpenProse in the open, and an open door if you want to take a real workflow further.