# Stop Telling Agents How — Dan Barrett, Raymond Weitekamp & Jose Montes de Oca, OpenProse

## Executive summary

OpenProse is a framework that allows users to define complex, multi-agent workflows as declarative contracts written entirely in plain markdown. Instead of telling an agent *how* to perform a task (procedural), users declare the desired *outcome* or end state (declarative contract). This approach enables the creation of reliable, auditable, and repeatable event-driven systems—such as PR reviews or regulatory documentation—that can be triggered by webhooks, cron jobs, or GitHub events, making it highly suitable for automated build and operational workflows.

## Key takeaways

- Declarative Contracts over Procedural Logic: The core principle is to define the desired outcome (the 'what') rather than the steps to achieve it (the 'how'). This is formalized as a 'contract' that the multi-agent system must satisfy, allowing the underlying agent/harness to figure out the optimal execution path.
- Event-Driven, Multi-Agent Workflows: OpenProse is designed for event-driven systems, not chat. Workflows are defined as a 'contract plus a trigger,' where triggers include webhooks, cron jobs, and GitHub events (e.g., PR creation).
- Composition and Reusability: The framework emphasizes composing contracts rather than inheritance. Users can build complex systems by wiring together multiple, self-contained contracts, which is crucial for managing complexity in large-scale enterprise systems.
- Contract Pinning for Cost Optimization: A key feature allows users to take a successful, complex agent run (a 'golden session') and 'codify' it into a reusable workflow. This process allows the system to shift from using expensive, highly intelligent models for the initial run to more specific, deterministic instructions, thereby reducing operational cost.

## Technical details

- OpenProse Mechanics: The entire framework is implemented using plain markdown text, making it highly portable and 'harness agnostic.' It supports defining sub-agents, assigning specific skills (e.g., using Exa for search), and defining clear input/output contracts.
- Workflow Triggers and CI Integration: The system supports defining jobs triggered by external events. Specific demos included: 1) GitHub issue creation (input: issue, output: commit); and 2) Pull Request (PR) reviews, demonstrating an 'adversarial review' process where agents provide backpressure to ensure quality.
- Comparison to DSPy: OpenProse is presented as the conceptual opposite of DSPy. While DSPy focuses on deterministic code and typed interfaces around black-box LLM calls, OpenProse allows the AI itself to act as the compiler, keeping the entire workflow definition in a 'fuzzy' language (markdown).
- Enterprise Use Cases: The framework is demonstrated for high-stakes, regulated environments, such as documenting quantitative (quant) models. This process, which is typically manual and highly labor-intensive, is automated by defining the regulatory requirements as a contract, ensuring compliance and auditability.

## Practical implications

- Automating complex, multi-step business processes (e.g., regulatory documentation, code review) that require high reliability and auditability.
- Reducing reliance on specialized engineering knowledge by allowing non-coders (e.g., PMs, domain experts) to define complex workflows using natural language.
- Creating composable, modular systems where individual contracts can be reused and combined across different teams or business units.
- Implementing advanced CI/CD checks (like adversarial PR reviews) that go beyond simple linting by having agents validate the code against a defined 'contract'.

## Topics

Multi-Agent Systems, Declarative Programming, Workflow Automation, Event-Driven Architecture, LLM Orchestration, Contract-Based Design, run.prose.md, OpenProse

Source: https://www.youtube.com/watch?v=7T-gldvgfpo