AuthorOutcomes.
Write the future as a Markdown contract agents can run, review, and maintain.
Prefer to talk it through? Book time on Calendly.
Reactions
What builders are saying.
Early notes from people trying prose.md, skills, and agent-readable workflows.
What can I write?
Prose programs are Markdown contracts agents can run.
Each file names the work, declares what the agent needs, and states what must be true when the run finishes. Keep one responsibility current or compose several into a larger workflow.
responsibility
Qualify GitHub stargazers
Review new stargazers, enrich public context, draft thoughtful outreach, and leave final send decisions to a human owner.
---
name: high-intent-stargazer-outreach
kind: responsibility
---
# High-Intent Stargazer Outreach
### Goal
High-intent GitHub stargazers are identified, enriched, qualified, and
prepared for thoughtful OpenProse outreach.
### Criteria
- Qualification includes public GitHub activity, repository context, and
plausible OpenProse pain.
- Recommended outreach names a specific workflow the person could reuse.
- Leave final send decisions to a human owner.
### Fulfillment
Prefer the local `stargazer-outreach` system.$ prose run high-intent-stargazer-outreach.prose.md
responsibility
Keep release readiness current
Reconcile CI, merged changes, migration notes, docs, and owner overrides into an evidence-backed ship or hold decision.
---
name: release-candidate-ready
kind: responsibility
---
# Release Candidate Ready
### Goal
The current release candidate has an evidence-backed readiness decision that a
release owner can trust before shipping.
### Continuity
- Reconcile readiness when CI, merged changes, migration notes, docs, known
risks, or owner overrides change.
- Preserve enough decision history for rollback, handoff, and the next release
retrospective.
### Fulfillment
Prefer the local `release-readiness` system.$ prose run release-candidate-ready.prose.md
responsibility
Surface customer risk early
Review product usage, support history, commercial context, and owner notes before churn or renewal windows become urgent.
---
name: customer-risk-maintained
kind: responsibility
---
# Customer Risk Maintained
### Goal
Customer risk is visible early enough that account owners can intervene before
churn or renewal windows become urgent.
### Criteria
- Each risk brief combines product usage, support history, commercial context,
stakeholder movement, and owner notes when those signals are available.
- Risk levels include cited evidence, confidence, trend, and next action.
### Fulfillment
Prefer the local `risk-radar` system.$ prose run customer-risk-maintained.prose.md
Built by the builders
OpenProse runs on OpenProse.
Our marketing, GTM, enrichment, and community operations are maintained responsibilities. The same contract surface we ask you to trust is the one keeping our own company awake.
See how we run our companyFAQ
Common questions
What is OpenProse?
OpenProse is a programming language for AI sessions. Programs are Markdown files with requires/ensures contracts that define what services need and produce. Forme, our intelligent dependency injection system, auto-wires services by contract matching. The model+harness is the runtime — the AI session itself executes the program.
How is this a VM?
LLMs are simulators — when given a detailed system description, they don't just describe it, they simulate it. The prose.md spec describes a VM with enough fidelity that reading it induces simulation. But simulation with sufficient fidelity is implementation: each session spawns a real subagent, outputs are real artifacts. The simulation is the execution.
How is the managed cloud different from the open-source version?
The open source version is the language: install as a skill, write .md programs, run them in Claude Code, Codex, OpenCode, Amp, or any "Prose Complete" harness. Free, MIT-licensed. The managed cloud runs those same programs on our infrastructure — on a schedule, on events, with durable traces and enterprise controls. Cloud is early access today. You write programs with the OSS; request access to run them at scale without you in the loop.
How do I install it?
Run: npx skills add openprose/prose. This installs the OpenProse skill in your AI coding assistant. No other dependencies required.
What systems support it?
Claude Code, OpenCode, Amp, Codex, Gemini CLI, or any other "Prose Complete" harness. The language defines an abstract host interface — any “Prose Complete” harness that supports file IO and subagent spawning can execute Prose programs.
Does this lock me into Claude?
No. OpenProse programs are framework-agnostic — the language defines an abstract host interface (spawn_session, read_file, write_file, ask_user) that any Prose Complete harness implements. A program written for Claude Code runs on Codex, OpenCode, or Amp without modification. Declarative programs get cheaper and smarter as models improve; you don't refactor every time the landscape shifts.
What are contracts?
Contracts are requires/ensures declarations that define what a service needs (its inputs) and what it produces (its outputs). They serve as types for AI programs — the requires block declares dependencies, the ensures block declares guarantees. Forme uses these contracts to auto-wire services together.
What is Forme?
Forme is intelligent dependency injection that auto-wires services by contract matching. Instead of manually connecting components, Forme reads the requires/ensures contracts on each service and automatically determines how to wire them together. It's IoC powered by model understanding, not configuration files.
Why Markdown, not YAML or a custom .prose syntax?
Human understanding is the bottleneck. YAML is precise but alien. A custom syntax needs a parser and fights the model's training. Markdown is what your team already writes, what the model already reads, and what already diffs, reviews, and documents itself in every tool you use. OpenProse structures Markdown with contracts — it doesn't replace the medium.
Why not just plain English?
English is already an agent framework — we're structuring it, not replacing it. Plain English doesn't distinguish sequential from parallel, doesn't specify retry counts, doesn't scope variables. OpenProse uses English exactly where ambiguity is a feature, and structure everywhere else.
How is this different from Anthropic's SKILLS.md or AGENTS.md?
Same substrate: Markdown. Different purpose. SKILLS.md and AGENTS.md document a single capability a model has. An OpenProse program specifies a system — multiple services wired together by contract, with declared inputs, outputs, strategies, and invariants. OpenProse doesn't replace SKILLS.md; it structures it. The language itself installs as a skill.
Why not LangChain, CrewAI, or AutoGen?
Those are libraries that orchestrate agents from outside. OpenProse runs inside the agent session — the session itself is the runtime. This means zero external dependencies and portability across any AI assistant.
How does this compare to BAML, DSPy, or similar?
Those require a harness outside the model to execute orchestration. OpenProse pushes the orchestration down into the model itself — your harness is the runtime, your Markdown is the program. Different layer of the stack.
How does a team share and version OpenProse programs?
Programs are Markdown files — version them in git like any other source. Teams can also publish immutable package versions to the OpenProse registry and install dependencies by registry://openprose/... refs. Runtime still reads pinned Markdown snapshots from disk, so review remains reading diffs and lockfiles, not trusting a hidden service.
What happens when a Prose program fails?
Every run writes a durable trace to .prose/runs/{id}/: the manifest, the program, intermediate artifacts, per-agent logs, and a running state.md. Debugging is diffing those files. Each service can declare ### Strategies for known failure modes and ### Invariants for what must remain true. Tests (kind: test) are .md files with fixtures and natural-language expectations.
Is OpenProse deterministic?
OpenProse is not deterministic — it's unambiguous. A sufficiently intelligent model reading an unambiguous Prose program implements the requested call flow faithfully, but the language doesn't add deterministic fallbacks or type systems to replace model judgment.