OpenProse: Markdown Workflow Format

OpenProse provides a portable, markdown-based workflow format designed to orchestrate AI sessions. Within OpenClaw, it is delivered as a plugin that adds an OpenProse skill pack and a /prose slash command. Programs are defined in .prose files and can launch multiple sub-agents with explicit control flow.

Install, Activate the OpenProse plugin, then restart the Gateway.
Run a program, Execute a .prose file or a remote program with /prose run.
Write programs, Build multi-agent workflows that combine parallel and sequential steps.

Install

Enable the plugin

OpenProse ships bundled but is not active by default. To turn it on:

openclaw plugins enable open-prose

Restart the Gateway

openclaw gateway restart

Verify

openclaw plugins list | grep prose

The output should show open-prose as enabled. The /prose skill command is now ready for use in chat.

If you are working from a repository checkout, install the plugin directly: openclaw plugins install ./extensions/open-prose

Slash command

OpenProse exposes /prose as a skill command that users can invoke:

/prose help
/prose run <file.prose>
/prose run <handle/slug>
/prose run <https://example.com/file.prose>
/prose compile <file.prose>
/prose examples
/prose update

/prose run <handle/slug> points to https://p.prose.md/<handle>/<slug>. Direct URLs are retrieved as-is using the web_fetch tool.

Top-level remote executions must be explicit. When a .prose program contains remote imports, they are treated as transitive code dependencies. Before OpenProse fetches any remote use target, it displays the resolved import list and requires the operator to respond with exactly approve remote prose imports to proceed with that run.

What it can do

Multi-agent research and synthesis using explicit parallelism.
Repeatable, approval-gated workflows such as code review, incident triage, and content pipelines.
Reusable .prose programs that run across supported agent runtimes.

Example: parallel research and synthesis

# Research + synthesis with two agents running in parallel.

input topic: "What should we research?"

agent researcher:
  model: sonnet
  prompt: "You research thoroughly and cite sources."

agent writer:
  model: opus
  prompt: "You write a concise summary."

parallel:
  findings = session: researcher
    prompt: "Research {topic}."
  draft = session: writer
    prompt: "Summarize {topic}."

session "Merge the findings + draft into a final answer."
  context: { findings, draft }

OpenClaw runtime mapping

OpenProse programs correspond to OpenClaw primitives as follows:

OpenProse concept	OpenClaw tool
Spawn session / Task tool	`sessions_spawn`
File read / write	`read` / `write`
Web fetch	`web_fetch` (`exec` + curl when POST is needed)

Warning

If your tool allowlist blocks sessions_spawn, read, write, or web_fetch, OpenProse programs will fail. Review your tools allowlist config.

File locations

OpenProse maintains state under .prose/ in your workspace:

.prose/
├── .env                      # config (key=value), e.g. OPENPROSE_POSTGRES_URL
├── runs/
│   └── {YYYYMMDD}-{HHMMSS}-{random}/
│       ├── program.prose     # copy of the running program
│       ├── state.md          # execution state
│       ├── bindings/
│       ├── imports/          # nested remote program runs
│       └── agents/
└── agents/                   # project-scoped persistent agents

Persistent agents at the user level, shared across projects, are stored at:

~/.prose/agents/

State backends

filesystem (default)

State is written to .prose/runs/... inside the workspace. No extra dependencies are needed.

in-context

Transient state lives in the context window; choose it with --in-context. Best for small, short-lived programs.

sqlite (experimental)

Select with --state=sqlite. The sqlite3 binary must be present on PATH (it falls back to the filesystem if missing); state is placed in .prose/runs/{id}/state.db.

postgres (experimental)

Select with --state=postgres. Requires psql and a connection string in OPENPROSE_POSTGRES_URL (configure it in .prose/.env).

Warning

Database credentials for Postgres are visible in sub-agent logs. Always use a dedicated database with minimal privileges.

Security

Handle .prose files the same way you would source code. Always review them before execution, including any remote use imports. While top-level /prose run https://... requests are explicit, transitive remote imports need per-run approval before they can be fetched or executed. Control side effects with OpenClaw tool allowlists and approval gates. For deterministic, approval-gated workflows, see Lobster.

Skills reference, Describes how OpenProse loads skill packs and which gates are applied.
Subagents, OpenClaw's built-in multi-agent coordination system.
Text-to-speech, Enable audio output in your workflows.
Slash commands, Every chat command, including /prose.

Official site: https://www.prose.md