# Stop Telling Agents How

Dan Barrett, Raymond Weitekamp & Jose Montes de Oca, OpenProse | AI Engineer NYC 2026 | 49:36

Source: https://www.youtube.com/watch?v=7T-gldvgfpo
Channel: AI Engineer (https://www.youtube.com/@aiDotEngineer). Summarised by AIE Talks.
Page: https://aietalks.com/talks/stop-telling-agents-how
Published: 2026-10-18
Tags: agents, multi-agent, workflows

## TL;DR
- OpenProse expresses multi-agent workflows as declarative contracts in Markdown, while the user's harness compiles and runs them.
- Contracts can run as event-driven jobs triggered by schedules, webhooks, GitHub issues, or pull requests, with separate agents checking the result against the declared outcome.
- A strong run can be pinned into a reusable workflow, allowing teams to start with an open-ended goal and later reduce cost and variation with more specific instructions.

## Summary
Dan Barrett, Raymond Weitekamp, and Jose Montes de Oca present OpenProse as a way to write multi-agent workflows in plain Markdown. A contract describes the desired outcome, inputs, outputs, agents, skills, tools, and constraints. A coding harness such as Claude Code or Codex compiles and runs it, so OpenProse does not replace the harness. The team focuses on event-driven jobs rather than chat sessions. Schedules, webhooks, GitHub issues, and pull requests can trigger workflows such as a skeptical senior review of AI-generated code. Each run is checked against a contract by fresh sessions, which gives the workflow an external standard instead of relying on the same agent to approve its own work. The demos also cover a bank model-documentation workflow, where regulatory requirements become the contract. The speakers are candid that this approach fits repeatable, auditable work better than exploration, and that its flexible execution can produce different results across models.

## Key ideas
### The useful abstraction is declaring an outcome
[01:00](https://www.youtube.com/watch?v=7T-gldvgfpo&t=60s)
Dan Barrett says the persistent problem is getting intent out of a person's head and into a capable system. OpenProse treats the desired end state as a contract. The author describes what must be true and leaves the harness to decide how to reach it. This differs from earlier prompt engineering, manual context engineering, and hand-built harnesses. Barrett argues that specifying the procedure too tightly can waste model capability and force an expensive model to do work that a cheaper model could handle. The contract can stay broad when the system is still exploring, then become more specific after a good run.

### OpenProse is Markdown compiled by the user's harness
[05:59](https://www.youtube.com/watch?v=7T-gldvgfpo&t=359s)
Raymond Weitekamp says the two facts to remember are that OpenProse is all text and that it runs event-driven multi-agent workflows. A program can declare sub-agents, skills, available tools, inputs, outputs, and required dependencies. For example, a workflow can require Exa for search and refuse to run if that skill or tool is unavailable. The compiler and runtime are also prompts. OpenProse is therefore a layer above existing harnesses rather than a replacement for Claude Code or Codex. The same Markdown program can be exported and used in another environment.

### Jobs combine a contract with a trigger
[12:32](https://www.youtube.com/watch?v=7T-gldvgfpo&t=752s)
Weitekamp defines a job as a contract plus a trigger. The trigger can be a schedule, a webhook, a new GitHub issue, or a pull request. The hosted product currently makes webhooks and cron jobs available, with GitHub events wired directly. An issue workflow can take the issue as input and produce a commit. A pull-request workflow can run an adversarial review. This moves the system away from conversations and toward standing jobs that handle an event from start to finish.

### A winning run can become a more deterministic workflow
[15:22](https://www.youtube.com/watch?v=7T-gldvgfpo&t=922s)
When an open-ended contract produces a good result, the team can capture the agent trace and turn it into a reusable workflow. Dan Barrett describes this as pinning the how after initially declaring only the what. The result can shift from a flexible, expensive execution toward more specific and deterministic instructions, which can reduce the cost of later runs. Weitekamp adds that a golden session can be converted into a reusable workflow. He also warns that model behavior and user expectations change, so a pinned workflow is not automatically a permanently stable endpoint.

### Separate review sessions check each run against the contract
[24:43](https://www.youtube.com/watch?v=7T-gldvgfpo&t=1483s)
The pull-request demo uses a 'grumpy senior developer who doesn't like AI-generated code' as the reviewer persona. New pull requests trigger review agents, and the development agent must respond to their feedback before its job is complete. Weitekamp describes runs with one review round and others with 14 rounds before the reviewers aligned and allowed the change to pass. Dan Barrett says the important distinction is that each fresh session is compared against a declarative contract. The workflow avoids asking the same model to create and approve its own work.

### OpenProse fits repeatable, auditable work better than exploration
[40:17](https://www.youtube.com/watch?v=7T-gldvgfpo&t=2417s)
Raymond Weitekamp says OpenProse is for work that happens repeatedly, needs to be reliable and auditable, and has a known desired result. Chat is better when someone is exploring a problem and does not yet know its shape. The team presents the contract as a way to turn institutional operating knowledge into versioned documentation that can live in Git, Notion, or Jira. The approach is less strict than DSPy because it does not require every return object and interface to be fully specified, but it still requires the user or an agent to express the intended outcome.

### Regulated model documentation can be expressed as a contract
[31:28](https://www.youtube.com/watch?v=7T-gldvgfpo&t=1888s)
Dan Barrett demonstrates a workflow for documenting quantitative models. Regulatory and internal requirements describe the desired document, including the model's purpose, testing conditions, upstream references, and other compliance details. The workflow runs in Codex with a public model, so the demo does not expose bank data. Barrett presents the use case as an in-house deployment on a company's own harness and models, keeping data and institutional procedures inside the organization. The generated documentation is then subject to review by quants, auditors, compliance teams, and regulators.

### Composition lets contracts define both workflow shape and intermediate checks
[41:18](https://www.youtube.com/watch?v=7T-gldvgfpo&t=2478s)
The speakers describe composition as a core feature. Multiple contracts can be injected into one run, requiring the agent to satisfy several conditions. Smaller contracts can also act as intermediate checkpoints in a larger workflow. The team says common patterns such as fan-out and fan-in, adversarial review, and loops that continue until a condition is met can be expressed in a Prose program. This allows the author to constrain important stages without writing every implementation step. They compare the structure to a directed graph of contracts whose downstream work proceeds when an upstream condition changes.

## Notable quotes
- Dan Barrett: "We want to tell it what to do, not how to do it because the harness in its infinite wisdom and its infinite intelligence is going to figure that out." (04:42)
- Raymond Weitekamp: "If you only remember two things about us, that's it. It's all text and we're doing these event-driven multi-agent workflows, not chatting." (06:36)
- Raymond Weitekamp: "A job is a contract plus a trigger." (12:16)
- Dan Barrett: "The whole point is that this is harness agnostic." (34:26)
- Dan Barrett: "What this is good for is something you need to do a lot. It needs to be reliable, it has to be repeatable, it needs to be auditable." (41:38)

## Tools & references mentioned
- OpenProse
- Claude Code
- Codex
- Anthropic
- Exa
- DSPy
- GitHub
- Stripe
- Fable
- Haku
- Matt Pocock
- run.prose.md

## Who should watch
- You are building agent workflows that need to run from webhooks, schedules, issues, or pull requests instead of inside a chat.
- Your team wants operating procedures in Markdown that can be versioned and run on an existing coding harness.
- You work on repeatable compliance, operations, product, or documentation tasks and need each run checked against an explicit outcome.

## Editor's note

Dan Barrett says a good OpenProse run can be captured and pinned into a more specific, repeatable workflow. Kitaru records every model call and tool result from a real run, then replays the agent against those same inputs and responses after a prompt, model, or code change. That lets the team check whether the pinned workflow still behaves as intended.

Written by the AIE Talks editors (the Kitaru team), not by the speaker.

## Related talks

- [Every Company Is Building Agents That Can't Work Together](https://aietalks.com/talks/every-company-is-building-agents-that-cant-work-together) (Justin Schroeder, Standard Agents, 34:49)
- [Agents Don't Do Standups: Building the Post-Engineer Engineering Org](https://aietalks.com/talks/agents-dont-do-standups-building-the-post-engineer-engineering-org) (Mike Spitz, PFF, 17:50)
- [Build Your Own Team of Managed Agents](https://aietalks.com/talks/build-your-own-team-of-managed-agents) (Jack Wotherspoon, Google DeepMind, 19:44)
- [From Your Laptop to the Pipeline: Scaling Custom Agents with GitHub Copilot](https://aietalks.com/talks/from-your-laptop-to-the-pipeline-scaling-custom-agents-with-github-copilot) (Jose Palafox, GitHub, 19:39)
- [Develop at Idea Velocity](https://aietalks.com/talks/develop-at-idea-velocity) (Jeffrey Lee-Chan, Snapchat, 15:28)
