AI Engineer · Published 2026-10-18

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

privateReview: unreviewedConfidence: high
openprosemarkdownagentsevent-drivenorchestrationfinancemarkdown-dslllm-as-compilerdeclarative-agentsmulti-agent-orchestrationcontractscomplianceprompt-composition
Open on YouTube ↗

Summary

Overview

  • Speaker: Dan Barrett, Raymond Weitekamp, Jose Montes de Oca
  • Channel: AI Engineer
  • Main topic: Event-Based Multi-Agent Financial Workflows with Only Markdown
  • Purpose: To demonstrate how OpenProse enables event-driven multi-agent workflows using pure markdown contracts and declarations. This workshop introduces OpenProse, a framework and language for agent-based multi-agent workflows written entirely in markdown. The speakers explain how declaring intent, contracts, and outcomes in plain markdown—rather than writing imperative Python or complex orchestration code—allows intelligent agents to figure out the 'how', dramatically simplifying multi-agent composition and integration with existing enterprise stacks.

Topic Map

Introduction to OpenProse and Markdown Workflows

  • Explanation: Dan Barrett and Raymond Weitekamp introduce OpenProse, explaining why programming language models with markdown is powerful and how intent is communicated to super-intelligence.
  • Key claims:
    • Language is the most powerful force of creation.
    • You can write a sentence and make that sentence true.
    • OpenProse allows writing prompts compositionally using declarative contracts.
  • Examples:
    • Writing markdown files to manage multi-agent workflows without deploying new code stacks.
  • Terminology:
    • OpenProse
    • Prompt composition
    • Contract creation
    • Declarative prompting
  • Why it matters: It allows developers to compose complex agent workflows using only text documents, lowering friction and infrastructure overhead.

Just Markdown & Event-Driven Architecture

  • Explanation: Raymond Weitekamp explains the two core pillars of OpenProse: it is entirely markdown, and it operates in an event-driven manner rather than conversational chat.
  • Key claims:
    • The entire agent framework is just markdown with no parser, binary, or SDK required.
    • Workflows are event-driven, triggering automatically when external events happen.
    • It avoids conversational chat interfaces in favor of automated job execution.
  • Examples:
    • A GitHub issue opening or a scheduled cron job triggering an agent execution.
  • Terminology:
    • Event-driven workflows
    • Markdown framework
    • Webhooks
    • Cron jobs
  • Why it matters: It integrates seamlessly with existing enterprise systems and CI/CD pipelines via plain text.

Why Should I Care? (Benefits for Finance, Developers, and PMs)

  • Explanation: Breaking down the benefits for regulated finance industries, AI engineers, and non-coding product managers.
  • Key claims:
    • Regulated finance companies don't need procurement or IT departments because OpenProse is entirely text.
    • If you can read logical English, you can read and edit the contract.
    • It acts as a programming language for agents, where the compiler is also just a prompt.
  • Examples:
    • Using existing approved LLM gateways and coding agents without changing security controls.
  • Terminology:
    • Guardrails
    • Logical English
    • Multi-agent workflows
    • Compliance
  • Why it matters: It bridges the gap between business requirements and technical execution using human-readable contracts.

Live Demos: run.prose.md and GitHub PR Reviews

  • Explanation: Demonstrating practical execution of OpenProse programs using GitHub webhooks, pull request reviews, and financial methodology documentation.
  • Key claims:
    • You can use run.prose.md to develop and maintain prose repositories.
    • Agents can act as grumpy senior developers reviewing pull requests.
    • Contracts benchmark agent output against declared ideal states to reduce hallucination loops.
  • Examples:
    • Automated pull request review workflows checking code against methodology documents.
  • Terminology:
    • Prose right function
    • Sub-agents
    • Evaluator-optimizer loop
    • Kernel
  • Why it matters: Shows real-world utility in software engineering and financial auditing tasks.

Key Points

Agents as Compilers

  • Explanation: The runtime and compiler in OpenProse are themselves LLM prompts where markdown code gets interpreted and compiled into execution.
  • Evidence: Raymond Weitekamp stating 'You are the compiler. This is not an analogy.'
  • Practical implication: Reduces the need for traditional software parsers and heavy backend orchestration frameworks.

Declarative vs. Imperative Prompting

  • Explanation: Users declare what they want (the contract and end state) rather than how to do it step-by-step.
  • Evidence: Explaining that the harness and intelligent model will figure out the execution steps.
  • Practical implication: Lowers cost and leverages smarter models to figure out optimal execution paths.

Institutional Operational Knowledge as Markdown

  • Explanation: Standard operating procedures and quant model documentation can be executed directly as prose programs.
  • Evidence: Discussion of quantitative models in big banks requiring annual re-documentation.
  • Practical implication: Saves millions of dollars in compliance and auditing overhead by turning SOPs into executable agent specifications.

Frameworks, Models & Processes

OpenProse

  • How it works: A markdown-based framework where events trigger agent execution against declarative contracts defined in text files.
  • Components:
    • Sub-agents
    • Skills
    • Tools
    • Inputs
    • Outputs
    • Triggers
  • When to use: When building reliable, repeatable, auditable multi-agent workflows without traditional coding frameworks.

Examples & Case Studies

An AGI-filled junior pull request review job triggered by a GitHub webhook.

  • Illustrates: Event-driven execution of markdown contracts.
  • Lesson: Agents can autonomously review code against strict guidelines and output structured suggestions.

Generating methodology documentation for USD OIS discount curves.

  • Illustrates: Handling complex financial and quant model documentation.
  • Lesson: OpenProse can automate expensive regulatory and compliance documentation workflows.

Actionable Takeaways

  • Immediate:
    • Try out OpenProse locally using npm skills add openprose/prose.
    • Explore run.prose.md for hosted event-driven workflows.
  • Strategic:
    • Shift from imperative agent orchestration graphs to declarative markdown contracts.
    • Leverage existing enterprise security stacks by keeping agent logic as plain text documents.
  • Questions to investigate:
    • How does OpenProse handle token efficiency at scale for massive multi-agent pipelines?
    • What are the best practices for structuring composable sub-agent markdown files?

Claims Worth Verifying

  • OpenProse requires no parser, binary, or SDK, running purely on markdown text. (technical architecture)
  • Financial institutions save between $10M to $50M a year on quant model re-documentation using automated workflows. (business impact)

Notable Quotes

"The entire agent framework is just Markdown. No parser. No binary. No SDK." "Finance runs on events, not chats." "You are the compiler. This is not an analogy. You are the compiler, and it seems to work."

Compressed Summary

  • OpenProse is a markdown-based framework for event-driven multi-agent workflows.
  • Workflows are declarative contracts defining goals, inputs, outputs, and sub-agents.
  • Integrates with existing webhooks, cron jobs, and LLM coding agents without custom software infrastructure.
  • Highly applicable for regulated finance, compliance auditing, and automated code reviews.
  • Keywords: openprose, markdown, agents, event-driven, orchestration, finance
  • Core insight: OpenProse replaces complex imperative agent frameworks with declarative markdown contracts, allowing event-driven multi-agent workflows to be read, edited, and composed entirely as plain text.

Core insights

6
Architecturehigh noveltymoderate evidence

The runtime/compiler for an agent workflow is itself an LLM prompt: markdown contracts are interpreted directly by a model acting as compiler and runtime, with no parser, binary, or SDK in the loop. This collapses the traditional interpreter boundary (grammar → AST → executor) into a single model call that both validates and executes the declaration.

Why it matters

It removes an entire layer of infrastructure (parser, orchestration backend, deployment) and relocates correctness responsibility to the model's instruction-following. That changes what you must test: instead of parser unit tests you need prompt-runtime conformance and hallucination bounds.

Generalization

Any DSL whose semantics are simple enough can be executed by an LLM instead of a bespoke interpreter, trading determinism and static checking for zero infrastructure cost and natural-language editability.

You are the compiler. This is not an analogy.
Open source video
The entire agent framework is just Markdown. No parser. No binary. No SDK.
Open source video
It acts as a programming language for agents, where the compiler is also just a prompt.
Open source video
Mechanismmedium noveltymoderate evidence

Declarative contracts — declaring the end state and success criteria rather than a step sequence — let the harness and the model select the execution path. The contract doubles as the evaluation target: agent output is benchmarked against the declared ideal state, which the speakers claim reduces hallucination loops.

Why it matters

It merges specification and evaluation into one artifact, so the same text that generates the run also gates it. This is a cheap evaluator-optimizer loop that doesn't require a separate rubric-maintenance pipeline.

Generalization

Write specs as machine-checkable acceptance criteria co-located with intent, so generation and verification share a single source of truth.

Contracts benchmark agent output against declared ideal states to reduce hallucination loops.
Open source video
Users declare what they want (the contract and end state) rather than how to do it step-by-step.
Open source video
Architecturemedium noveltymoderate evidence

The trigger layer is event-driven (webhooks, GitHub issue opens, cron), not conversational. Workflows fire from external system events and produce automated job output, deliberately avoiding chat interfaces.

Why it matters

Chat-first agent designs couple the agent to a human-in-the-loop session and to session-scoped context. Event-triggered execution makes agents CI/CD citizens — deterministic entrypoints, no interactive state — and is what lets them slot into existing enterprise infrastructure without new procurement.

Generalization

Design agents as event consumers with declared input/output contracts, not as always-on conversational services; the integration surface becomes the event bus rather than a UI.

Finance runs on events, not chats.
Open source video
Workflows are event-driven, triggering automatically when external events happen.
Open source video
A GitHub issue opening or a scheduled cron job triggering an agent execution.
Open source video
Practicemedium noveltyweak evidence

Because the program is plain text, it inherits the organization's existing compliance and security perimeter: it runs through already-approved LLM gateways and coding agents, so no new procurement or IT review is required for each new workflow.

Why it matters

In regulated environments, approval overhead — not engineering effort — is the dominant cost of shipping a new automation. Keeping logic as data (markdown) rather than as a deployable artifact changes the governance path fundamentally.

Generalization

Treat agent logic as configuration/data under existing controls rather than as new software, and deployment friction drops to the cost of a document review.

Regulated finance companies don't need procurement or IT departments because OpenProse is entirely text.
Open source video
Using existing approved LLM gateways and coding agents without changing security controls.
Open source video
Mental Modelmedium noveltyweak evidence

Institutional operating knowledge — SOPs and quant-model methodology docs that must be re-documented annually — is proposed as directly executable prose programs, with generation of methodology documentation (e.g., USD OIS discount curves) as the demonstrated workload.

Why it matters

It reframes documentation as an executable artifact rather than a stale parallel description. If a doc is the program, doc drift and implementation drift collapse into one failure mode instead of two.

Generalization

Where a written procedure already exists and is authoritative, the highest-leverage agent workload is executing that procedure and regenerating the document from the run, not authoring a separate pipeline.

Standard operating procedures and quant model documentation can be executed directly as prose programs.
Open source video
Discussion of quantitative models in big banks requiring annual re-documentation.
Open source video
Mechanismmedium noveltymoderate evidence

Composition is achieved by file-level decomposition — sub-agents, skills, tools, inputs, outputs, triggers — declared in separate markdown files rather than wired in code, allowing prompts to be composed like modules.

Why it matters

Defines a concrete composition unit (the markdown file with declared I/O) that can be reviewed, versioned, and reused, which is the missing primitive in most prompt-reuse schemes.

Generalization

Pick a text-native module boundary with explicit declared inputs/outputs so agents can be composed and reviewed by the same process as code, without a runtime linking step.

OpenProse allows writing prompts compositionally using declarative contracts.
Open source video
Writing markdown files to manage multi-agent workflows without deploying new code stacks.
Open source video

Deep dives

5

Behavioral conformance testing for an LLM-as-compiler runtime

Research question

If the runtime and compiler of a markdown agent workflow are themselves prompts, what test suite replaces parser unit tests, and how much cross-run and cross-model variance does a fixed contract exhibit?

Why

Removing the parser moves correctness responsibility onto instruction-following, so the failure surface shifts from syntax errors to silent interpretation drift. Without a conformance harness you cannot tell whether a contract edit or a model version bump changed behavior, which makes the whole architecture unauditable in practice.

The entire agent framework is just markdown with no parser, binary, or SDK required.
Open source video
It acts as a programming language for agents, where the compiler is also just a prompt.
Open source video
Source video

Self-grading contracts: circularity between generation target and evaluation rubric

Research question

When the contract supplies both the generation objective and the scoring rubric, does the contract-grader reproduce the generator's misinterpretations, and does a second independent evaluator agent catch what the first certifies as correct?

Why

The claim that contracts benchmark output against declared ideal states to reduce hallucination loops is asserted without error rates. If the same wording drives generation and grading, an ambiguous contract yields confidently wrong passes, which is worse than a loud failure because it produces no signal to act on.

declaring intent, contracts, and outcomes in plain markdown—rather than writing imperative Python or complex orchestration code—allows intelligent agents to figure out the 'how'
Open source video
It bridges the gap between business requirements and technical execution using human-readable contracts.
Open source video
Source video

Event-triggered agent jobs need idempotency, retry, and duplicate-event semantics that chat never required

Research question

What minimal job semantics (idempotency keys, retry policy, duplicate-event suppression, dead-letter handling) must a markdown-declared event-driven agent carry before it can safely run unattended against enterprise event sources?

Why

Moving the entrypoint from a human conversation to a webhook or cron job converts each run into a stateless automated job. Chat scoped state hid exactly the problems that now become production incidents: replayed events, partial writes, and unbounded retry loops, none of which a prose trigger declaration expresses by default.

Workflows are event-driven, triggering automatically when external events happen.
Open source video
It avoids conversational chat interfaces in favor of automated job execution.
Open source video
A GitHub issue opening or a scheduled cron job triggering an agent execution.
Open source video
Source video

Governance of executable prose: provenance, diff review, and rollback for programs that are documents

Research question

How do version control, review, and rollback work when the program, the runtime contract, and the compiler instruction are all natural-language documents editable by non-engineers under an existing compliance perimeter?

Why

The compliance argument rests on the logic being text that flows through already-approved gateways rather than a new deployable artifact. That only holds if change control moves with it: document versioning, reviewer identity, golden-run regression per revision, and pinned model versions. Otherwise the governance path was relabeled, not shortened.

Regulated finance companies don't need procurement or IT departments because OpenProse is entirely text.
Open source video
Using existing approved LLM gateways and coding agents without changing security controls.
Open source video
If you can read logical English, you can read and edit the contract.
Open source video
Source video

File-level module boundaries for composed sub-agents and interface validation without a linker

Research question

What file granularity and declared input/output schema minimize interface mismatch and review effort when workflows are composed from many sub-agent markdown files, given that nothing statically checks the interfaces?

Why

The file is proposed as the composition unit, but with no runtime assembly step there is no linker to catch a mismatch between one file's declared output and another's declared input. Boundary conventions and a lightweight interface check are what make prompt reuse safe rather than aspirational.

OpenProse allows writing prompts compositionally using declarative contracts.
Open source video
Writing markdown files to manage multi-agent workflows without deploying new code stacks.
Open source video
Source video

Article ideas

4

Your Compiler Should Be a Document: The Case for Trading Static Guarantees for Zero-Infrastructure Agent Runtimes

For declarative agent workflows, an LLM acting as compiler and runtime is a defensible engineering trade only if you replace the parser test suite with a behavioral conformance suite; teams that adopt the first half without the second get non-deterministic failures with no static signal.

Angle

Frame it as a straight swap of guarantees: what the interpreter pipeline used to give you, what you now buy instead, and the exact test artifacts a team must build before the trade pays off.

Source video

The Contract That Grades Itself: Hidden Circularity in Declarative Agent Evaluation

Collapsing specification and evaluation into one artifact is efficient but creates a circular reasoning risk, because the wording that makes an ambiguous contract under-specified is the same wording used to certify the resulting output as correct.

Angle

Argue for split evaluation: the contract stays the generation target, but grading requires an independently authored rubric or a second evaluator agent, and ambiguous-contract divergence should be measured explicitly.

Source video

Finance Runs on Events, Not Chats: What Unattended Agents Owe Their Event Bus

Choosing event triggers over conversational sessions is the right integration call, but it silently imports distributed-systems obligations, namely idempotency, retry bounds, and duplicate suppression, that chat-first agent designs never had to pay.

Angle

Walk through a single webhook-triggered agent job and enumerate everything a prose trigger declaration fails to specify, then show what must be enforced downstream of the declaration.

Source video

Ship the Document, Not the Deployment: Where Compliance Cost Actually Goes

Keeping agent logic as text under existing controls genuinely lowers shipping friction, but it moves the governance burden from procurement to document change control, so the savings are real only for organizations that already have prose review and regression discipline.

Angle

Separate the procurement claim from the change-management claim and show which one survives an audit and which merely relabels the artifact.

Source video

Project ideas

4

Contract Conformance Bench

beyond-evals

A fixed set of markdown contracts executed N times across M model versions will show run-to-run output variance concentrated in contracts with implicit success criteria, and explicit acceptance criteria co-located in the contract will measurably reduce that variance.

Proof of concept

Build 12 contracts (half with explicit machine-checkable acceptance criteria, half with prose-only intent), run each 20 times across two model versions through the same gateway, and diff normalized outputs plus declared-criteria pass rates.

Measurement

Per-contract output divergence rate across runs, pass rate against declared criteria, retry count, and token cost per successful run; compare explicit-criteria versus prose-only cohorts.

Source video

Ambiguity Divergence Probe

beyond-evals

Deliberately ambiguous contracts will be silently resolved to a single interpretation that the contract-based grader then certifies as correct, and an independently authored second evaluator will flag a detectable share of those self-certified passes.

Proof of concept

Author 10 contracts with one planted ambiguity each, run generation plus contract-as-grader, then run an independent evaluator with no access to the generator's reasoning; manually adjudicate disagreements.

Measurement

Percentage of ambiguous contracts where grader passes output judged wrong by human adjudication, and the recall of the independent evaluator on that subset.

Source video

Idempotent Event-Trigger Runner

gatehouse

An event-triggered markdown-declared agent job without idempotency keys and duplicate-event suppression will produce duplicate side effects on replayed webhooks at a rate above zero, and adding a declared job-identity layer will drive that to zero without changing the contract prose.

Proof of concept

Wrap a contract-declared workflow in a thin event adapter that replays the same webhook and cron events with injected duplicates and partial failures, first naive, then with idempotency keys and a dead-letter path.

Measurement

Duplicate side effects per 100 replayed events, retry loop depth, recovery time after injected mid-run failure, and contract-diff size required to gain the guarantee.

Source video

Executable SOP Drift Detector

movement-lab

Where a written procedure is the authoritative source, executing the procedure document and regenerating the documentation from the run will surface latent discrepancies between the prose and actual execution that a human re-documentation pass misses.

Proof of concept

Take two internal SOPs and one methodology-style document, run each as an executable prose program, auto-regenerate the document from the run trace, and diff against the human-authored version.

Measurement

Number and severity of semantic discrepancies found per document, reviewer acceptance score of the regenerated document, and edit volume required before sign-off.

Source video

Architectural implications

4

The compiler/runtime is a prompt rather than a program

Before

A DSL requires a parser, an AST, and an executor service; semantics are enforced statically and failures are deterministic

After

A model reads the declaration, decides the execution steps, and self-checks against the contract; semantics are enforced probabilistically

Consequence

You lose static guarantees and gain zero-infrastructure iteration; testing effort shifts from parser conformance to behavioral conformance and hallucination measurement

Source video

Workflow entrypoint moves from chat to events

Before

Agent invoked by a human in a conversation; context and state scoped to the session

After

Agent invoked by webhook/cron/issue event; each run is a stateless job with declared inputs and outputs

Consequence

Agents become auditable job runners that fit CI/CD and enterprise automation, but require idempotency, retry, and duplicate-event handling that chat never needed

Source video

Agent logic is delivered as a document instead of a deployment

Before

New automation means new code, new deploy, and security/procurement review of a new artifact

After

New automation means a markdown file reviewed as text and run through the already-approved gateway

Consequence

Shipping cost drops to documentation review cost; governance must instead track document versions and who may edit executable text

Source video

Specification and evaluation become the same artifact

Before

Spec lives in a design doc; evaluation lives in a separate harness with its own rubric that drifts

After

The contract declares the ideal end state and the run is benchmarked against it in the same loop

Consequence

Fewer desynchronized artifacts, but the contract's wording now directly determines both generation and grading, so a bad contract silently produces confidently wrong scores

Source video

Tradeoffs and failure modes

4

LLM-as-compiler vs. conventional parser

Benefit

No parser, binary, or SDK to build, version, or deploy; workflows ship as text and run through existing gateways

Cost or risk

No static validation of the declaration; malformed or ambiguous prose fails at runtime and failures are non-deterministic and model-version-dependent

The entire agent framework is just Markdown. No parser. No binary. No SDK.
Open source video
Source video

Declarative intent vs. control over execution path

Benefit

The harness and model choose steps, so contract authors don't hand-build orchestration graphs

Cost or risk

Execution path is chosen by the model, so cost, latency, and step count become emergent and hard to budget or bound ahead of time

Users declare what they want (the contract and end state) rather than how to do it step-by-step.
Open source video
Source video

Human-readable contracts vs. machine-checkable guarantees

Benefit

Anyone who can read logical English can read and edit the contract, collapsing the business-to-engineering handoff

Cost or risk

Prose admits ambiguity; correctness depends on shared interpretation between author and model, and edits by non-engineers can change runtime behavior without tests

If you can read logical English, you can read and edit the contract.
Open source video
Source video

Text-only delivery vs. depth of control

Benefit

Slots into approved enterprise stacks without touching security controls or procurement

Cost or risk

Constraints on token budget, tool permissions, and rate limits must be expressed in prose and enforced downstream, not by the runtime

Using existing approved LLM gateways and coding agents without changing security controls.
Open source video
Source video

Open questions

5

How does an LLM-as-compiler runtime degrade at scale — token efficiency and cross-run consistency for large multi-agent pipelines with many composed sub-agent files?

Why unresolved

The summary lists this as a question to investigate and offers no measurements; only small demos (PR review, methodology doc) are described.

Research direction

Build a benchmark that scales contract graphs from 1 to N composable sub-agents and measures token cost, latency, and output variance per run.

Source video

What are the failure modes when a contract is ambiguous — does the model silently pick an interpretation, and does the contract-as-evaluator loop then certify its own misinterpretation?

Why unresolved

The claim that contracts reduce hallucination loops is asserted without reported error rates or comparison against a control.

Research direction

Construct deliberately ambiguous contracts and measure divergence between declared ideal state and graded output; test whether a second independent evaluator agent catches what the first misses.

Source video

What is the right structure for composable sub-agent markdown files — how large should a contract be before decomposition, and how are interfaces between files validated?

Why unresolved

The summary names inputs/outputs/sub-agents/skills as components but gives no conventions for boundary design or interface checking.

Research direction

Prototype repositories with differing file granularity and declared I/O schemas; measure reuse rate, review effort, and interface mismatch frequency.

Source video

Does the claimed compliance cost saving ($10M–$50M/yr on quant model re-documentation) survive contact with an actual audit, i.e., can generated methodology documentation pass regulatory review?

Why unresolved

A business-impact figure is asserted with no methodology, customer, or audit outcome evidence in the summary.

Research direction

Run a side-by-side of agent-generated versus human-written model methodology docs through an internal model-risk review and score reviewer acceptance and required edit volume.

Source video

How do you observe and version control a system whose program, runtime, and compiler are all natural-language documents under continuous editing by non-engineers?

Why unresolved

The architecture moves logic to text without specifying provenance, change review, or rollback semantics.

Research direction

Adapt code-review and CI practices to prose repos: diff-based review, golden-run regression tests per contract, and pinned model versions per contract revision.

Source video

Key claims

7
factualVerification needed

OpenProse requires no parser, binary, or SDK, running purely on markdown text.

Evidence

The entire agent framework is just Markdown. No parser. No binary. No SDK.

Question

Is there genuinely no parsing or structured extraction step, or is a model-based parse happening implicitly on every run? What breaks when the prose deviates from expected form?

Source video
factualVerification needed

The compiler and runtime are LLM prompts, not an analogy.

Evidence

You are the compiler. This is not an analogy.

Question

What guarantees does the runtime provide, and how are compile-time errors surfaced to the author?

Source video
causalVerification needed

Contracts benchmark agent output against declared ideal states and thereby reduce hallucination loops.

Evidence

Contracts benchmark agent output against declared ideal states to reduce hallucination loops.

Question

Measured reduction in hallucination/retry counts vs. a no-contract baseline — and does the contract grader share the generator's blind spots?

Source video
comparativeVerification needed

Financial institutions save between $10M and $50M a year on quant model re-documentation using automated workflows.

Evidence

Financial institutions save between $10M to $50M a year on quant model re-documentation using automated workflows.

Question

What is the baseline (headcount × hours × rate), which institution, and does the figure include review and remediation of generated documentation?

Source video
opinionVerification needed

Event-driven triggering is a better fit than chat for finance workflows.

Evidence

Finance runs on events, not chats.

Question

Which finance workflows genuinely lack a human-in-the-loop review step, and what exception-handling latency does unattended execution introduce?

Source video
causalVerification needed

Regulated finance companies need no procurement or IT involvement because the framework is entirely text.

Evidence

Regulated finance companies don't need procurement or IT departments because OpenProse is entirely text.

Question

Does text-only delivery actually bypass change-management review in regulated environments, or merely relabel the artifact?

Source video
causalVerification needed

The same declarative form lets a coding agent review pull requests against methodology documents as a senior developer would.

Evidence

Agents can act as grumpy senior developers reviewing pull requests.

Question

Precision/recall of agent review comments against human reviewers on the same PRs, and false-positive rate as perceived by developers.

Source video

Connections

5