OpenProse skill
A contract language and skill: state in Markdown what agents must accomplish, and the agent session itself acts as the virtual machine that runs them
- 1,848 ★ on the repository
- Last commit
- MIT
Broad access
Why this level
- Executes contracts with the host's tools: the agent starts helper agents, reads and writes files and runs commands from the sources
- The delivery library can send email, Slack messages and webhooks, and `prose serve` brings up local schedules and HTTP triggers
- State, receipts and dependencies are written to the OpenProse root, where `.env` may hold keys
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add skills/openproseDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewBroad accessThe tool can change data, run commands or handle secrets.
- Executes contracts with the host's tools: the agent starts helper agents, reads and writes files and runs commands from the sources
- The delivery library can send email, Slack messages and webhooks, and `prose serve` brings up local schedules and HTTP triggers
- State, receipts and dependencies are written to the OpenProse root, where `.env` may hold keys
This is third-party code. Review the repository files before installing.
What it does
OpenProse is the Contract Markdown format plus the open-prose skill for compatible agents. A program is made of `*.prose.md` files with a `kind:` header. The `responsibility` kind describes a goal that must stay true over time: `### Maintains` sets the schema of the data it keeps current, `### Requires` subscribes it to data from other contracts and `### Continuity` defines what wakes the work. The `function` kind is a one-time call with parameters and a result, `gateway` accepts external events, `pattern` describes a reusable coordination scheme and `test` holds checks. When step order, loops, retries or parallelism matter, they are pinned in ProseScript inside an `### Execution` block. The skill wakes on `prose ...` commands and on `.prose.md` files. `prose run file` makes the agent session itself behave like a virtual machine: there is no separate binary. The agent reads the contract, picks a state backend (files by default, also SQLite, PostgreSQL and the session context), wires the contracts through the Requires and Maintains pair and executes them with the host's tools. It then judges the result against the contract's requirements: finished work alone does not count as success. Rework starts through a deterministic reconciler only when the fingerprints of the inputs or of the contract itself have moved. `prose init` and `prose compose` design the program, `prose write` writes a single contract, `prose compile` builds the sources into `dist/manifest.next.json`, `prose serve` brings up local schedules and HTTP triggers and `prose upgrade` moves sources to the new vocabulary. Libraries sit alongside in packages/std: delivery to email, Slack and webhooks, run evaluation and comparison, memory, diagnostics and patterns such as fan-out and map-reduce.
Who it is for. For developers and anyone building multistep processes from several agents who want to write down the requirements for the result once rather than rewrite a long prompt with every revision.
Good fit when
- The task has three or more steps that need different expertise: research, synthesis, review, or plan, implementation, tests
- A process repeats every week or on every pull request and you want a reusable contract rather than another prompt
- There is a natural loop of draft, critique and revision or implement, test and fix that the agent must follow by the rules
- You need parallel options and a final synthesis: compare three approaches or collect several opinions and merge them
- You want to write down 'X must always hold' as a checkable requirement and get a receipt with evidence after a run
Not a fit when
- You need an answer to a single question or a one-step task: the skill itself advises answering directly without a contract
- You want to work with the agent in a live dialogue and adjust on the fly: a contract boundary adds friction
- Your agent is not a compatible (Prose-Complete) one: the skill runs on the session's own strength and relies on the host's tools
- You need a standing service with guarantees of continuous operation: standing responsibilities require a host that supports them, and the reference host Reactor is experimental
- You rely on the old OpenProse 0.14 vocabulary and expect your data to migrate: the author does not migrate old ledgers
Example request
prose init Every week collect a digest of new pull requests in the repository, have a second agent check each digest and send the result to SlackLimitations
The license is MIT. The author calls the language young and asks for cautious use. The skill version is 0.18.1, `runtime_contract` 2. Moving from the 0.14 and earlier vocabulary breaks compatibility: the judge loop is gone, `kind: service` is renamed `kind: function`, `kind: system` is deleted and old run ledgers are not migrated. The `prose upgrade` command updates sources, and you should start with `--dry-run`.
The author does not yet publish speed benchmarks: the language went out first, the numbers come later. Facet inference and ledger compaction are listed as plans, and the fixpoint is specified but deferred. The reference host Reactor lives in a separate openprose/reactor repository and is marked alpha with no stability guarantees.
Portability of contracts does not guarantee the same result from different models and does not add missing tools. State and run receipts live in the OpenProse root: the repository root, `repo/.agents/prose` or `~/.agents/prose`.
In its documentation the author asks agents to file issues in the repository themselves when something fails. Do that only with the user's knowledge.
How to disable. Remove the open-prose skill from the agent's skills directory or disable the plugin in its plugin manager. Your `*.prose.md` contracts and the `runs/`, `state/`, `dist/` and `deps/` folders in the OpenProse root stay: delete them by hand. If you ran `prose serve`, stop the local schedules and HTTP triggers.
FAQ
How does a responsibility differ from a function?
A responsibility describes a goal that must stay true over time: it maintains data, subscribes to other contracts' data and wakes on inputs, a schedule or an external event. A function is called once, takes parameters and returns a result, with no state between calls.
Do I need a separate `prose` binary?
No. `prose run file` is an instruction for the agent session: the agent plays the virtual machine itself and uses the host's tools. A separate reference host, Reactor, with a `reactor` binary lives in another repository and is marked experimental.
What is a fingerprint and why might there be no rerun?
A fingerprint is a hash of a node's material data fields and of its contract. The deterministic reconciler starts the work again only when the fingerprints of the subscribed inputs or of its own contract have moved. No language model takes part in the decision to wake or commit.
Where is run state kept?
In the OpenProse root: the repository root, `repo/.agents/prose` for an attached repository or `~/.agents/prose` for personal contracts. It holds sources in `src/`, compiled output in `dist/`, receipts in `runs/`, durable state in `state/`, dependencies in `deps/`, plus `prose.lock` and `.env`.
What is in the packages/std library?
Delivery contracts for email, Slack and webhooks, a file writer, an HTML renderer and a human approval gate, evaluators and run comparison, project and user memory, the compose, lint, wire, status and diagnose operations, and patterns: fan-out, map-reduce, blind review, dialectic, guard and fallback chain.
How do I move from an old OpenProse version?
Version 0.14 and earlier uses a different vocabulary, and migration of run data is not provided. Sources are updated in the agent session with `prose upgrade --dry-run`, which shows a plan without edits. Working state starts from a clean directory.
Discussion
No questions or reviews yet.
Related
SkillsA skill with 25 commands to audit and improve the prompts, tools and agent designs of a project in Cursor, Claude Code and Codex
A multi-agent harness that verifies results by artifacts: stop hooks, an independent judge and an event log for Claude Code, Codex, Cursor and more
Numman Ali's small plugin marketplace: agent orchestration, open-source maintenance, Gas Town and Z.AI CLI
A team of AI agents from one request: it plans the task, writes code in parallel branches, tests, reviews and opens a pull request
oah links 80-plus skills, five roles and /commit, /review, /test-tdd commands into Claude Code, Cursor, Codex and other agent folders
An open coding agent for the terminal, browser and desktop that works with models from OpenAI and Claude to Ollama
README in short
The English description explains the idea: requirements are written down and composed from ready contracts, the agent executes and an evaluator checks. It then gives the install command, how to start with `prose run`, the contract kinds, a warning about incompatibility with version 0.14, a section on portability, a description of hosts, a status summary and a request to send cases the language does not yet cover. The repository has a spec in spec/, the skill with guides and examples, libraries in packages/std and packages/co, manifests for Claude Code and Codex, a privacy policy and terms of service.
README badge
Original SKILL.md
--- name: open-prose version: 0.18.1 runtime_contract: 2 description: | Activate when the user types `prose ...`, opens a `.prose.md` file with `kind:` frontmatter, opens a `.prose` file, or asks for reusable multi-agent orchestration. Treat `prose run ...` as an in-session instruction: embody the OpenProse VM yourself; do not shell out to a `prose` binary. On activation read the Markdown contract, select a state backend, wire responsibilities, execute with host primitives, and persist run state under the selected OpenProse root. Decline for one-shot questions — a plain prompt is often the right answer. --- # OpenProse Skill Contract authoring is expressing intent by composing requirements. An agent performs the work, and an evaluator assesses whether the contract’s requirements are satisfied. Reuse and combine contracts through the interfaces in this skill; see [requirements and composition](guidance/authoring.md#requirements-and-composition). OpenProse has five load-bearing pieces: | Piece | File | Role | |-------|------|------| | **Contract Markdown** | `contract-markdown.md` | Human-readable `*.prose.md` source format | | **Forme** | `forme.md` | Semantic dependency-injection container that wires contracts | | **Prose VM** | `prose.md` | Execution engine that runs responsibilities, functions, and pinned execution blocks | | **ProseScript** | `prosescript.md` | Imperative scripting layer for `### Execution` blocks and pattern delegation | | **Responsibility Runtime** | `responsibility-runtime.md` | Responsibility-Oriented Architecture: standing goals, the reconciler, and compile/serve doctrine | Use Contract Markdown when authors want declarations and auto-wiring. Use ProseScript when authors want to pin choreography: order, loops, conditionals, parallelism, retries, and explicit function calls. ## First 90 Seconds After activation, choose the narrowest path that matches the user's intent: | User Intent | Load First | Then Load If Needed | |-------------|------------|---------------------| | Explain OpenProse or answer "how do I..." | `help.md` | `examples/README.md`, then one focused example | | Initialize or compose an OpenProse program | `guidance/tenets.md` | `guidance/authoring.md`, then run `std/ops/compose` | | Run a `.prose.md` responsibility or function | `contract-markdown.md` | `state/README.md` and the selected backend (`state/filesystem.md` by default); `forme.md` if responsibilities must be wired (`### Requires` → `### Maintains`); `prose.md` to execute | | Inspect or upgrade source layout | `changelog.md` | `contract-markdown.md`, `prosescript.md` if migration details require them |