# OpenProse (/)



# OpenProse [#openprose]

Contract authoring is
expressing intent by composing requirements. Reusable contracts provide the
building blocks; composition determines how their requirements apply together.

An agent performs the work, and an evaluator assesses whether the contract's requirements are satisfied. The executor returns a result that includes evidence for the assessment. Execution and evaluation repeat as needed.

These docs cover the public `open-prose` skill's **Contract Markdown and
ProseScript** format. A `responsibility` expresses requirements for information
or conditions maintained over time. A `function` provides a one-time call.
ProseScript specifies required steps when their order or method matters.

<Callout type="info">
  The syntax here was checked against [skill 0.18.0, runtime contract 2](https://github.com/openprose/prose/blob/770cebc9e03a7150a73bd454b7a6da307595ff9d/skills/open-prose/SKILL.md).
  Use the format supported by your installed skill. Requirements describe what
  must happen; tools, permissions, continuous operation, and enforcement depend
  on the selected host. See [Harness-agnostic](/harness-agnostic).
</Callout>

Install the language skill in a compatible coding agent, then provide the tools and inputs your contract needs:

```bash
npx skills add openprose/prose
```

From there, point your agent at a contract and say `prose run <file>`. The session itself embodies the VM: there is no parser and no separate binary.

## Start here [#start-here]

<Cards>
  <Card title="Setup" href="/setup" description="Install the skill, author a first contract, and run it where your agent lives." />

  <Card title="Contract authoring" href="/declare-outcomes" description="Express intent through requirements, combine reusable contracts, and distinguish completing work from evidence that it meets the requirements." />

  <Card title="Contracts" href="/contracts" description="The authored surface: the five kinds and the recognized sections. Learn how declared inputs and outputs connect." />

  <Card title="ProseScript" href="/prosescript" description="The optional imperative layer for when the order of operations matters." />
</Cards>

## The shape of a contract [#the-shape-of-a-contract]

For ongoing work, author a `responsibility`. It declares the inputs it subscribes to (`### Requires`) and the state it must maintain (`### Maintains`). This fragment assumes a separate telemetry responsibility supplies `usage`:

```markdown
---
name: renewal-risk
kind: responsibility
---

### Goal

Keep a current risk read on every account whose signals have moved.

### Requires

- `usage`: the per-account usage facet from the telemetry responsibility

### Maintains

A current risk score per account. Material: the score band and the top
driver per account; `fetched_at` and request ids are immaterial. Each
account carries a `valid_until`. Postcondition: every flagged account
cites a corroborating signal.
```

`### Maintains` is the section that defines maintained state: the schema for the state this contract maintains. [Contracts](/contracts) teaches it in depth, along with the five kinds and the rest of the authored surface.

The host serves the contract set using its available runtime capabilities, such as memoization, receipts, and a reconciler. The authored requirements remain the same when you change compatible hosts; successful execution still depends on the host and the required inputs. See [Harness-agnostic](/harness-agnostic) for that boundary.

<span id="where-the-truth-lives" />

## Source of execution rules [#source-of-execution-rules]

The canonical execution behavior lives in the open-source `open-prose` skill in the [`openprose/prose`](https://github.com/openprose/prose) repo. These docs are orientation; if the docs and the skill disagree, trust the skill.

***

*The conversation always ends. The responsibility shouldn't have to.*