Stop Scripting Your AI Agents. Start Declaring What You Want Them to Keep True.
You've probably written an agent workflow that ran perfectly the first three times and then quietly drifted into nonsense on the fourth. The problem isn't your prompt—it's the model of work itself. Instead of scripting a sequence of steps and hoping the run lands where you wanted, OpenProse lets you declare an ideal world state in Markdown contracts, and lets a reconciler figure out how much model work it takes to keep reality matching that declaration.
What It Does
OpenProse is a declarative language for standing AI work. You write contracts in structured Markdown files (*.prose.md) that describe what must stay true—not how to make it true. The system reads those contracts and works out the execution itself. When order, loops, or exact choreography genuinely matter, you can drop in optional imperative ProseScript plans. The default is declarative; the escape hatch to imperative is there when you want it.
The project positions itself as a language, not a platform. Contracts are plain files that run on any "Prose-Complete" agent harness—any agent host that can spawn sessions, read and write files, and call tools. It ships as a Skill your coding agent runs directly, so there's no separate binary to install or server to babysit. The session itself embodies the VM.
Why It's Cool
It applies the oldest good idea in software to agents. SQL, Terraform, Kubernetes, React—they all work the same way. You declare the desired state, and a reconciler is responsible for making reality match it. OpenProse points that pattern at model work. You set the temperature you want and the thermostat holds the room there; you never tell it when to fire.
The core abstraction is a Responsibility. A Responsibility is a standing goal written as a Markdown contract. Its ### Maintains section is a world-model schema: what truth the node keeps current, which fields are material (and so move the fingerprint—the content hash the runtime compares to decide whether work reruns), and which postconditions a render must satisfy before it may commit. That fingerprint detail matters: it's how the system avoids redoing work that hasn't actually gone stale.
The graph wires itself. Your ### Requires section names upstream facets the node subscribes to. The wiring layer matches Requires.<facet> against Maintains.<facet> and draws the subscription edge. Structure is subscription—you don't draw the graph, the contracts do. That's a genuinely elegant design decision, and it's the kind of thing that makes a system feel like a language rather than a framework.
Continuity is a first-class concept. The ### Continuity section declares the wake source. Input-driven by default, self-driven on a freshness cadence, or external-driven via a gateway turning an ingress event into an edge. Most agent tooling treats "when does this run?" as an afterthought. Here it's part of the contract.
There's a small vocabulary of kinds. Around the headline responsibility kind sit four more: function (a called, stateless helper), gateway (external ingress as a contract), pattern (a reusable coordination algorithm), and test (fixtures plus assertions). That's a tight set. It suggests the authors resisted the urge to add a kind for every idea.
How to Try It
The fastest way in is the skill:
npx skills add openprose/prose
That installs OpenProse into any Prose-Complete coding agent (Claude Code, Codex CLI, OpenCode, and friends). From there, point your agent at a contract and say prose run <file>. The session itself is the VM—no separate binary.
For a new program, say prose init, then use prose compose to shape its purpose, topology, Contract boundaries, and outside-in semantic tests. Compose progressively materializes one directory package. Use prose write when a single Contract is already understood and needs focused authoring.
Your first contract is a Markdown file away: kind: responsibility frontmatter, a ### Goal that states what should stay true, and the sections described above.
The examples/ directory is the tour. Start small and read the contract before you run it—the README says so, and it's good advice for any declarative system.
The repository lives at github.com/openprose/prose.
Final Thoughts
OpenProse is best for developers who've already felt the pain of imperative agent workflows drifting out of control and who are comfortable with the declarative mindset. If you've used Terraform or Kubernetes, the mental model will click fast. If you haven't, the Responsibility abstraction might take a session or two to absorb. The README is honest about its status, and the project is clearly early. But the underlying idea—declare what should stay true, let a reconciler handle the rest—is one of the few patterns in software that has survived every paradigm shift. It's worth seeing what happens when you point it at agents.
Follow @githubprojects for more developer tools and open source projects.