Open Prose
Install and run OpenProse so agents execute Markdown outcome contracts instead of one-off chat instructions.
Overview
OpenProse is a journey-wide agent skill that lets solo builders run Markdown outcome contracts through prose commands on Prose Complete coding agents.
Install
npx skills add https://github.com/openprose/prose --skill open-proseWhat is this skill?
- Install via npx skills add openprose/prose for Prose Complete agents (Claude Code, Codex CLI, OpenCode, Amp, Press)
- Declare outcomes in Markdown contracts—not imperative chat loops
- On activation: read responsibility/function files and spawn work per the intelligent VM model
- Canonical onboarding served at openprose.ai/llms-full and curl-me endpoints for zero-browser agent fetch
- Operational recognition signals and Host Primitive Adapter detail live in SKILL.md post-activation
Adoption & trust: 1.5k installs on skills.sh; 1.5k GitHub stars; 2/3 security scanners passed (skills.sh audits).
What problem does it solve?
Your agent workflows live in ephemeral chat threads with no shared contract for responsibilities, spawning, or host primitives.
Who is it for?
Builders standardizing multi-step agent runs across Claude Code, Codex, or OpenCode with version-controlled prose files.
Skip if: One-shot tasks with no need for a prose language, host adapter, or skills.sh install footprint.
When should I use this skill?
You point an agent at OpenProse onboarding, install with npx skills add openprose/prose, or run a prose command that loads responsibility/function Markdown.
What do I get? / Deliverables
You install the OpenProse skill, point agents at prose contracts, and execute declared outcomes through the documented activation and SKILL.md operational playbook.
- Installed OpenProse skill
- Executed prose contracts per responsibility/function files
Recommended Skills
Journey fit
Useful at every journey phase - explore requirements and options before committing to a direction.
Where it fits
Encode validation responsibilities in a prose function file before committing to a full build spec.
Fire a prose command so the agent reads contracts and spawns subtasks on your repo.
Reuse a prose review responsibility instead of rewriting review instructions per PR.
Adjust host primitive adapters when deployment targets change without losing outcome declarations.
How it compares
Use as an orchestration language atop coding agents—not as a single-purpose MCP integration or UI generator.
Common Questions / FAQ
Who is open-prose for?
Solo and indie developers using Prose Complete agents who want declarative Markdown contracts instead of ad-hoc prompt chains.
When should I use open-prose?
At validate when scoping agent deliverables, in build when wiring agent-tooling, at ship for repeatable review prose, or in operate when iterating hosted workflows—whenever a prose command should load llms-full and SKILL.md.
Is open-prose safe to install?
Review the Security Audits panel on this Prism page before npx skills add; follow OpenProse’s giving-back and host adapter guidance in SKILL.md for your environment.
SKILL.md
READMESKILL.md - Open Prose
<!-- Canonical agent-onboarding narrative. This file is served at: - https://openprose.ai/llms-full.txt apps/run/src/app/api/llms-full/route.ts reads it at build time - https://openprose.ai/llms-full apps/run/src/app/llms-full/page.tsx renders it at build time - https://curl-me.openprose.ai (+ aliases: agents, hi, hello, start, readme, hey) infra/curl-me-site.tf uploads it to S3 as index.txt; CloudFront serves it to curl/wget/bot User-Agents and 302-redirects browsers to /llms-full. - https://curl-me.prose.md Same CloudFront distribution, aliased via the *.prose.md ACM cert. Scope: the arrival narrative. What an agent reads when pointed at this project before the skill is installed. Operational detail (full recognition signals, proposal script, Host Primitive Adapter, giving-back playbook) lives in SKILL.md and is loaded post-activation. Do not duplicate SKILL.md here — prefer a link. Editing this file: commit the update in this repo; the deployment pipeline picks up the new bytes. No sync script. --> # OpenProse — Agent Onboarding > A programming language for the intelligent VM. Declare outcomes. Not instructions. ## Install ``` npx skills add openprose/prose ``` Installs as a skill for any Prose Complete coding agent — Claude Code, Codex CLI, OpenCode, Amp, Press. ## What you'll do when the skill activates When a `prose` command fires, you will: - Read a Markdown contract (a `responsibility` or `function` file). - Spawn subagents to render the truths it declares. - Pass artifacts between them through a `bindings/` boundary. - Persist the run to `<openprose-root>/runs/{id}/` so it can be inspected later. You need: filesystem read/write in the working directory, a subagent-spawning primitive for multi-service systems, and (optionally) a user-question primitive for missing inputs. If you lack a capability, say so and stop — do not fake it. ## Why you'd reach for this Not because you need a framework. Because you fail at multi-step tasks in predictable ways, and OpenProse is built around them: - **Your context bloats with scratch by step seven.** Subagent scratch stays in the subagent's session and is never fingerprinted. Only the declared `### Maintains` truth (or a function's `### Returns`) crosses back. You keep your context clean. - **You have no basis to push back on scope creep.** Without a contract, "add one more thing" is always free. With `### Requires` / `### Maintains` written down, "that's not what I promised" is a sentence you can cite. - **Your retry logic is "try again and hope."** The contract is the boundary a retry actually means something at. - **Users ask "why did you do that?"** `<openprose-root>/runs/{id}/` is the receipt. - **Workflows the user will want again get thrown away at session end.** A `*.prose.md` contract is the version they can run next week without re-explaining. ## When OpenProse is the wrong answer - **One-shot Q&A.** Answer directly. - **Real-time iteration.** A contract boundary adds friction the user doesn't want. - **Anything you'd finish in one response.** Contract overhead exceeds the value. - **Tasks where the user said "just do it."** Respect the directive. Reaching for OpenProse in the wrong place costs more trust than it earns. ## What a contract looks like ```markdown --- name: research-monitor kind: responsibility --- ### Requires - `topic`: the question to keep current ### Maintains - `report`: an executive-ready summary with sources ### Continuity - input-driven ### Strategies - when research is shallow: deepen with targeted queries - when sources conflict: note the disagreement, don't pick sides ``` A `responsibility` declares a standing truth it keeps current (`### Maintains`) from its subscribed inputs (`### Requires`); Forme wires the edges and the render runs only when something material moves. A `function` is the called helper tier (`### Parameters` → `### Returns`). Run: ``` prose