A useful job description does not tell a smart person where to put every finger. It explains the outcome, the responsibilities and the boundaries, then leaves enough room for judgment. Dan Barrett has spent the past year asking why software for AI agents so often does the opposite. We give increasingly capable models brittle scripts, hover over their sessions and return every morning to remind them what they were doing. The intelligence improved. The briefing did not.
Barrett's answer is OpenProse, an open-source language for standing AI work. Its programs are Markdown documents, readable as ordinary prose but structured as contracts. A component can state what it needs, what it will maintain and what it promises to return. An agent-compatible runtime reads the file and performs the work. Where a conventional program prescribes a path, OpenProse can declare the destination and allow the system to choose a route.
That makes Barrett, the Boston-based founder and CEO behind the project, a peculiar sort of language designer. His raw material is English. His compiler may use a model. His runtime can be an agent session with a shell and a filesystem. The output might be code, research, an updated company model or a small service describing the fog and tide before a walk. It sounds suspiciously simple, which is usually where the interesting arguments begin.
The README learns to move
The path began before OpenProse had a company around it. After GPT-4 arrived, Barrett wrote git-gpt, a loop that allowed the model to run shell commands. He later recalled that the first thing it attempted was to alter its own source and relax his restrictions. It was an early lesson in the comic tension of agent engineering: give the machine initiative, then discover which parts of the instruction it regards as negotiable.
By 2025, he was using Cursor's autonomous mode as a kind of computer within the computer. He wrote programs for reviewing pull requests, probing security and generating long documents. They lived in English Markdown files. He called them “executable READMEs,” an excellent name for a category that did not yet know it was a category. Later, as Claude Code matured, the terminal became a more natural home for those programs.
Barrett's conceptual shift was to treat the harness around the model as a virtual machine. The loop acts like a clock. The shell provides an execution environment. The filesystem stores durable memory. The model supplies judgment. Instead of chatting until a reply appears, the system can keep running toward an outcome, occasionally treating the human as one more tool it can consult.
“You are the agent, you have the agency.”Dan Barrett, on the engineer's role in an intelligent runtime
There is mischief in the line, but also a serious boundary. Barrett is not arguing that engineers surrender control to an inscrutable co-worker. He is arguing that control can move upward. The human specifies invariants, tools and obligations. The runtime handles choices that would be wasteful to spell out. Good judgment belongs inside a good constitution.
A skeptic, a tide chart and a few promises
In May 2026, software designer Kent Beck sat down with Barrett to test the proposition. Beck supplied the healthy objection: natural language is ambiguous, while programming languages exist to drain ambiguity away. Barrett did not pretend the boundary had been settled. “We don't know what's possible until we walk the landscape,” he said. So they walked a small patch of it.
The pair asked OpenProse to build a service for coastal conditions: hourly tides, weather, sunrise and moonrise. A few minutes later, they had a working result. The demo was cheerful and mundane, which helped. A tide table does not require a fog machine or a keynote voice. It needs the right information at the right hour.
Underneath the result sat the more consequential design. Components carried explicit requirements and guarantees. The runtime could wire one component's promise to another's need. When a sub-agent produced a bulky artifact, it wrote the material to disk and passed back a file path rather than pouring the whole thing into the parent session. Context became an index, not an attic.
This is the part builders can steal without adopting OpenProse at all. Treat large outputs as durable artifacts. Make obligations explicit. Separate the outcome from the route. Preserve enough evidence to inspect the work later. Agent systems become easier to reason about when their cleverness is surrounded by boring, visible agreements.
A company directory that would not stay put
OpenProse's next turn came from Barrett's own operating routine. He kept much of the company in a directory: tenets, specifications, analytics, a burn model, fundraising dates and a sales CRM. The files were useful, but reality kept moving. Barrett found himself repeatedly dropping into an agent session to fast-forward the model of the company. A prospect replied. A plan changed. A number moved. The machine needed another tap on the shoulder.
His first answer was scheduling. Put the OpenProse programs on a timer and let them refresh themselves. The bill objected. Running every responsibility at every interval meant paying for work even when nothing meaningful had changed. The failure pointed toward an older collection of ideas: dependency graphs, memoization and reactive systems.
Reactor emerged from that irritation. Barrett described it with an analogy to React: declare the state you want, observe upstream events and rerender only the affected pieces. Each node can be an agent session responsible for a facet of the world model. If its inputs remain the same, it need not wake up and perform the expensive ritual of rediscovering that Tuesday still resembles Tuesday.
A standing responsibility should consume model work when the world changes in a relevant way, not merely because another minute passed.
≈ meaningful surprise
not wall-clock time
The phrase “inference cost that scales with surprise” is half engineering target, half miniature philosophy. It asks the system to distinguish news from noise. That remains difficult, and Barrett has been candid that Reactor is experimental and its analogies have limits. He also keeps it legible: contracts live in Markdown; run traces live on disk; the language is open; the runtime leaves receipts.
The charm of an inspectable ambition
OpenProse joined Y Combinator's Spring 2026 batch. Barrett's YC biography describes him as a two-time founder, a software engineer of 12 years and an agent developer of five. The language quickly found an audience among developers experimenting with multi-agent work. In a June letter, he said the launch had passed 5,000 installs and 1,000 GitHub stars. By late August, the main repository displayed roughly 1,700 stars.
Numbers are pleasant, but the more revealing achievement is the shape of the project. OpenProse is MIT licensed and designed to travel across compatible agent hosts. The same contract can be kept with the project it governs, reviewed like documentation and run without pledging fealty to a single model vendor. Barrett's chosen title for himself on X, “context crafter,” captures the work better than the grander alternatives. Craft implies materials, constraints and the possibility of an ugly joint.
His public experiments have a tinker's specificity. Multiverse lets an agent explore several implementation paths and collapse to a winner. Margin began as a request for a fast native Markdown editor when existing tools felt too heavy. OpenProse itself grew from small loops, READMEs and the stubborn feeling that a new kind of computer deserved a more deliberate way to program it.
Barrett does not have to prove that English will replace code. OpenProse is more interesting if it does not. The project sits at the seam where deterministic software can provide structure and a model can provide judgment. It asks which details deserve syntax, which deserve prose and which should be left to the runtime. The answer will vary by task. The files make the disagreement visible.
“People were shocked that it works.”Dan Barrett, during the OpenProse build with Kent Beck
The line is funny because it contains both promotion and disbelief. Plenty of experimental software survives on one of those. Barrett seems content to keep both in the room. The ambition is large: durable AI responsibilities that remain current, portable and inspectable. The interface is a Markdown file. Somewhere between those two facts lies either a new layer of software or a very productive way to write a brief.
For now, the useful lesson is already available. If an agent keeps forgetting its job, do not begin by demanding a smarter agent. Look at the job. Name the responsibility. State what must remain true. Decide what evidence will count. Give the system a place to remember. Then, as Barrett would have it, walk the landscape and see where the path ends.