A long-running AI session is a Turing-complete computer. OpenProse is a programming language for it.

Website • Language Spec • Examples

⚠️ Beta Software — Read before using

# Research and write workflow
agent researcher:
  model: sonnet
  skills: ["web-search"]

agent writer:
  model: opus

parallel:
  research = session: researcher
    prompt: "Research quantum computing breakthroughs"
  competitive = session: researcher
    prompt: "Analyze competitor landscape"

loop until **the draft meets publication standards** (max: 3):
  session: writer
    prompt: "Write and refine the article"
    context: { research, competitive }

claude plugin marketplace add openprose/prose
claude plugin install open-prose@prose

Then launch Claude Code and try:

"run example prose program and teach me how it works"

git clone https://github.com/openprose/prose.git ~/.config/opencode/skill/open-prose

Then launch OpenCode and try:

"run example prose program and teach me how it works"

git clone https://github.com/openprose/prose.git ~/.config/agents/skills/open-prose

Then launch Amp and try:

"run example prose program and teach me how it works"

By installing, you agree to the Privacy Policy and Terms of Service.

Traditional orchestration requires explicit coordination code. OpenProse inverts this��you declare agents and control flow, and an AI session wires them up. The session is the IoC container.

Other frameworks orchestrate agents from outside. OpenProse runs inside the agent session—the session itself is both interpreter and runtime. It doesn't just match names; it understands context and intent.

When you need AI judgment instead of strict execution, break out of structure:

loop until **the code is production ready**:
  session "Review and improve"

The **...** syntax lets you speak directly to the OpenProse VM. It evaluates this semantically—deciding what "production ready" means based on context.

OpenProse runs on any Prose Complete system—a model + harness combination capable of inducing the VM. Currently: Claude Code + Opus, OpenCode + Opus, Amp + Opus. It's not a library you're locked into—it's a language specification.

Switch platforms anytime. Your .prose files work everywhere.

Why not just plain English? You can—that's what **...** is for. But complex workflows need unambiguous structure for control flow. The AI shouldn't have to guess whether you want sequential or parallel execution.

Why not rigid frameworks? They're inflexible. OpenProse gives you structure where it matters (control flow, agent definitions) and natural language where you want flexibility (conditions, context passing).

Enable auto-updates (recommended):

/plugin → Marketplaces → prose → Enable auto-update

Or update manually:

claude plugin update open-prose@prose

cd ~/.config/opencode/skill/open-prose && git pull

cd ~/.config/agents/skills/open-prose && git pull

See the Language Reference for complete documentation.

The examples/ directory contains 37 example programs:

Start with 01-hello-world.prose or try 37-the-forge.prose to watch AI build a web browser.

LLMs are simulators. When given a detailed system description, they don't just describe it—they simulate it. The OpenProse specification (prose.md) describes a virtual machine with enough fidelity that a Prose Complete system reading it becomes that VM.

This isn't metaphor: each session triggers a real subagent, outputs are real artifacts, and state persists in conversation history or files. Simulation with sufficient fidelity is implementation.

The VM maps traditional components to emergent structures:

Run with --state=sqlite for queryable, transaction-safe state management. Requires sqlite3 CLI:

Run with --state=postgres for true concurrent writes, network access, and external system integration.

⚠️ Bring Your Own Database: You are responsible for providing and managing your PostgreSQL instance. OpenProse does not provision databases for you.

⚠️ Security Warning: Database credentials in OPENPROSE_POSTGRES_URL are passed to subagent sessions and will be visible in agent context/logs. Treat these credentials as non-sensitive. Use:

• A dedicated database for OpenProse (not your production DB)
• A user with minimal privileges (just the openprose schema)
• Credentials you're comfortable being logged

Setup:

Configure connection:

mkdir -p .prose
echo "OPENPROSE_POSTGRES_URL=postgresql://user:pass@localhost:5432/prose" >> .prose/.env

PostgreSQL state is for power users who need concurrent parallel writes or external dashboard integration.

Why not LangChain/CrewAI/AutoGen? Those are orchestration libraries—they coordinate agents from outside. OpenProse runs inside the agent session—the session itself is the IoC container. Zero external dependencies, portable across any AI assistant.

Why not just plain English? You can use **...** for that. But complex workflows need unambiguous structure for control flow—the AI shouldn't guess whether you want sequential or parallel execution.

What's "intelligent IoC"? Traditional IoC containers (Spring, Guice) wire up dependencies from configuration. OpenProse's container is an AI session that wires up agents using understanding. It doesn't just match names—it understands context, intent, and can make intelligent decisions about execution.

OpenProse is in beta. This means:

• Telemetry is on by default — We collect anonymous usage data to improve the project. See our Privacy Policy for details and how to opt out.
• Expect bugs — The software may behave unexpectedly. Please report issues at github.com/openprose/prose/issues.
• Not for production — Do not use OpenProse for critical or production workflows yet.
• We want feedback — Your input shapes the project. Open issues, suggest features, report problems. See CONTRIBUTING.md for guidelines.

You are responsible for all actions performed by AI agents you spawn through OpenProse. Review your .prose programs before execution and verify all outputs.

• MIT License
• Privacy Policy
• Terms of Service