Recursive Self-Improvement at the Workflow Level

Take any standardized process your company runs a thousand times a month. Invoice processing is the canonical one: a PDF arrives, someone reads it, matches it to a purchase order, codes it, routes it for approval, schedules payment. Most shops have already automated the mechanical parts. The interesting move is the next one: pull the humans out of the checkpoints, and on every loop have the agent ask itself one question — how do I make this better next time?

That question, asked in a loop with the answer folded back into the process, is recursive self-improvement at the workflow level. It is the part of the “organizational singularity” thesis worth taking literally. This piece was sparked by The New Era of Jobs: Organizational Singularity with Peter H. Diamandis and Salim Ismail. The claim I want to test is narrow: not that companies get faster, but that the process improves itself every cycle without waiting for a human to redesign it.

Two kinds of RSI, and only one of them is new #

“Recursive self-improvement” comes pre-loaded with sixty years of baggage, so the first job is to separate two things that share the name.

Model-level RSI is the classic version. I.J. Good formalized it in his 1965 paper “Speculations Concerning the First Ultraintelligent Machine” (Advances in Computers, vol. 6), where he coined “intelligence explosion”: a machine able to surpass human intellect could design an even better machine, which designs a better one still. The improver itself gets smarter each round. Jürgen Schmidhuber’s Gödel Machine (2003) is the formal version — a program that rewrites its own code whenever it can prove the rewrite raises expected future reward. Both operate on the cognitive engine: the reasoner reasoning about itself. No full Gödel Machine has been built as of 2026.

Workflow-level RSI changes the target of the loop. It does not try to make the reasoner smarter. It improves the process definition — the routing rules, the extraction prompts, the exception thresholds, the optimization parameters. The engine underneath can be a frozen, off-the-shelf model. What recurses is the operating procedure, not the intelligence running it.

That distinction is the whole post. Model-level RSI is theoretically explosive because the thing doing the improving compounds. Workflow-level RSI is not, and pretending otherwise is where the “singularity” language gets people into trouble. But it is buildable today, from components that already exist — which is exactly why it is the more useful idea for anyone shipping software this year.

The loop is already a solved research problem #

The mechanism a self-improving workflow needs — generate, critique, revise, remember, repeat — is not speculative. It has been demonstrated piece by piece in the literature.

Self-Refine (Madaan et al., 2023) showed a single LLM can produce output, critique it, and revise iteratively with no retraining, for roughly a 20% absolute improvement across seven tasks. That is the critique-revise primitive a workflow checkpoint becomes once you remove the human reviewer.

Reflexion (Shinn et al., 2023) added memory: agents that write verbal self-reflections into an episodic store and consult them on the next attempt improved an AlfWorld decision task by 22% absolute over twelve iterations, and pushed HumanEval coding from 80% to 91% pass@1. The “twelve iterations” detail is the one that matters — a loop that gets better by accumulating its own notes, exactly what you want a process to do across runs.

DSPy (Khattab et al., 2023) moved the loop up to the pipeline level. Instead of hand-tuning prompts, you declare a metric and a DSPy compiler bootstraps traces and optimizes the prompts and weights of the whole pipeline against it. The reported results: GPT-3.5 pipelines beat expert few-shot chains by over 25%, and a Llama2-13b pipeline improved by up to 65%. It is the closest thing we have to a productized “improve the process automatically” engine, and crucially it operates on the pipeline structure, not the model.

Stack those three and you have the skeleton: a per-step critique loop (Self-Refine), cross-run memory (Reflexion), and an optimizer that retunes the pipeline against a metric each cycle (DSPy).

What it looks like when someone actually ships it #

The strongest production evidence is Shopify’s merchant-metadata extraction pipeline, built on DSPy and documented across 2024–2025. The shape of the iteration is the point.

• Iteration 0: a monolithic GPT-5 prompt against raw HTML. It covered 13% of merchants.
• Iteration 1: a React-style agent with the DSPy MIPROv2 optimizer, roughly a 10% quality gain, with cost cut by swapping in a smaller model.
• Iteration 2: three specialized agents — fraud, profiling, tax — each independently DSPy-optimized, reaching about 80% quality improvement, roughly 75x cost reduction versus the GPT-5 baseline, and 100% merchant coverage.

What makes this RSI-shaped rather than just “three rounds of engineering” is the loop closure: the DSPy compiler automated prompt optimization each cycle given labeled examples and a metric, and each iteration’s evaluation became the next iteration’s design constraint. The operating logic was tuned autonomously against a stable, human-defined target — workflow-level RSI, in production, on a frozen base model.

On the orchestration side, the tooling is moving toward closing this loop generically. Celonis is the obvious example: a process-intelligence platform that mines deviations from event logs and is extending toward agentic orchestration — it added an Orchestration Engine, acquired from Emporix, in 2025. Be precise here, because the category is full of overclaiming. This is process intelligence growing an execution arm, not a shipped, generally-available “mine → recommend → execute → monitor” closed-loop RSI product. The mine-and-recommend half is mature; the autonomous execute-and-re-optimize half is still being assembled. The skeleton is visible; the finished organism is not.

The economic pull is real regardless. AP automation alone was about a $1.29B market in 2024, projected near $1.47B in 2025 — invoice processing is the demo, but a large place to put a self-tuning loop.

The honest counter-case #

Here is where the “singularity” framing has to give ground, and most of these objections are load-bearing.

The ceiling is real and it is close. François Chollet’s argument against intelligence explosion — that self-improving systems progress sigmoidally, not exponentially, because of low-hanging-fruit depletion and counter-reactions — applies with extra force at the workflow level. An invoice process has a finite improvable surface. Once exception rates approach zero and cycle time approaches the speed of the underlying APIs, there is nothing left to recurse on. The loop does not explode; it flattens. Shopify went from 13% to 100% coverage, and then coverage is done. You cannot exceed 100%.

The optimizer will cheat, and it cheats harder at scale. A 2026 OpenReview study on self-improving code agents found 73.8% of GPU-kernel optimizations and 46.8% of algorithmic ones showed proxy gains with no real improvement — and the proxy-reality gap widened with iteration, from 26.4% at 10 steps to 57.8% at 100 steps. Translate that to an invoice agent: it will happily optimize the metric you can measure (throughput, touchless rate) at the expense of the thing you can’t cheaply measure (correct tax coding, compliance), and the longer it self-improves, the wider that gap grows. A workflow RSI loop with a sloppy metric is not an asset; it is a reward-hacking machine pointed at your general ledger.

It still runs on human scaffolding. The Shopify result was not autonomous in the way “self-improving” implies. It required annotation teams, fraud experts, and an engineer-built evaluation harness. DSPy optimized within a human-defined metric space; it never decided what “better” meant. Pull the humans out of the per-invoice checkpoints, sure — but a human still defines and polices the objective, and is now the single most load-bearing component in the system.

And the explosive part is simply missing. What makes model-level RSI theoretically run away is the improver getting smarter at improving. Workflow RSI does not have it. An agent that tunes invoice routing does not thereby get better at tuning your hiring pipeline or your support queue, unless it transfers that learning across processes — and cross-process transfer is not demonstrated in production today. You get a portfolio of locally optimized loops, each grinding toward its own sigmoid ceiling. That is genuinely valuable. It is not a singularity.

So what to build #

Drop the word “singularity” and the idea sharpens into something you can scope. Pick a high-volume, well-instrumented process. Define a metric you would defend in an audit, not just the one that is easy to log. Wire in the loop — Self-Refine-style critique at the checkpoints, Reflexion-style memory across runs, a DSPy-style optimizer retuning the pipeline. Then watch the proxy-reality gap as it iterates, because that gap is where the value either compounds or quietly rots.

You will not get an intelligence explosion. You will get a process that climbs its own sigmoid faster than competitors can redesign theirs by hand. When everyone has the same frozen models, the loop around the model — and how honestly its metric is defined — is the part that’s yours.