
A blueprint for multi-agent systems that improve themselves.
A blueprint for multi-agent systems that improve themselves, assembled from five techniques that have each been validated on their own. To our knowledge, no one has combined them; the integration is the contribution.
Small animals built this reef, and the reef now shelters them.
Tanush Jagdish · March 2026
Organizations are multi-agent systems. Every role, department, and automated process is an agent: it has inputs, outputs, and objectives. A credit analyst is an agent. So is a sourcing pipeline, and so is an onboarding flow. An org chart is a graph of agents passing work to each other.
So the question was never whether to model an organization this way. What matters is whether the optimization loop can close automatically: whether the system can watch its own work, find what went wrong, and adjust, without a person redesigning the process every quarter.
Every component needed to close that loop now exists and has been validated on its own.
What follows is the architecture, and an honest accounting of what exists versus what is left to build.
#1Integration, not invention
Every piece you need already exists, and each has been validated by its own research community. To our knowledge, no published work combines them.
- 1
Reflexion
Agents improve from their own execution traces, in context, with no retraining.
Shinn et al., NeurIPS 2023 · 91% HumanEval - 2
Multi-Agent Reflexion
Diverse critic personas, so the self-critique doesn’t echo the blind spot that caused the error.
Ozer et al. 2025 · Society of Mind - 3
Credit Assignment
Shapley-style reasoning to figure out which agent deserves blame or credit for a system outcome.
Shapley-Coop / COPPER / LLM-MCA · NeurIPS 2024 to 2025 - 4
OCEL 2.0
An open event-log standard that captures the multi-object structure of real organizational processes.
Berti et al. 2024 · OCEL 2.0 specification - 5
Process Mining + RL
Reinforcement learning run on process traces to optimize the process itself.
Soliman et al. 2024 · process optimization
Integration is the contribution.
Five blocks:
- Reflexion: agents that improve from their own execution traces, in context, with no retraining.
- Multi-Agent Reflexion: diverse critic personas, so self-critique doesn’t repeat the blind spot that caused the error.
- Credit assignment: Shapley-style reasoning about which agent deserves blame or credit for a system-level outcome.
- OCEL 2.0: an open event-log standard that captures the multi-object structure of real organizational processes.
- Process mining with reinforcement learning: optimizing a process by learning from its own traces.
None of these is speculative. Each has papers and benchmarks, and one is a published data standard. Composing them is the hard part, not inventing new techniques.
#2Reflexion: improvement without retraining
Reflexion is the engine at the center of this design, and it breaks the usual assumption that getting better means retraining the model.
- 1
Act
Execute in the environment.
- 2
Observe
Take in the full execution trace plus a reward signal.
- 3
Reflect
Write a verbal analysis of what went wrong and why.
- 4
Remember
Store the reflection in episodic memory.
Limitation: single-agent self-reflection degenerates, because the blind spots that produced an error also limit the critique.
Source: Shinn et al., NeurIPS 2023
Its loop has four steps. An agent acts in its environment. It observes the result: the full execution trace plus a reward signal. It reflects by writing a verbal analysis of what went wrong and why. And it remembers, storing that reflection in episodic memory so the next attempt can use it.
Notice what does not happen: no weights change. All the improvement comes from in-context learning. A reflection works like a gradient written in language. Instead of backpropagating a number through a network, the agent writes a sentence, “I assumed the spreadsheet was current; it wasn’t,” and that sentence tells it what to change and why. Reported results are strong: 91% on HumanEval and 97% on ALFWorld.
Reflexion has a catch, and the figure flags it. Single-agent self-reflection degenerates, because the blind spots that produced an error also limit the critique. An agent that is wrong in a particular way tends to be wrong in the same way when it grades itself. Staring harder does not reveal your own blind spot.
#3From one agent to many
Fixing the blind-spot problem is the bridge from one self-improving agent to a self-improving organization. Instead of making one agent reflect harder, bring in other agents to reflect on its work.
Multi-Agent Reflexion
Diverse critic personas debate. A Society-of-Mind setup prevents the single-agent echo chamber.
Counterfactual PPO
A shared reflector generates personalized reflections per agent, marginalizing out each agent to compute counterfactual credit in reflection space.
Fair Cooperation
Self-interested agents coordinate via Shapley chain-of-thought about marginal contributions: fair reward redistribution with no central coordinator.
Reflection quality is bottlenecked by the diversity of the reflector, not the capability of the actor.
Reflection quality is limited by the diversity of the reflectors, not the capability of the actor. You don’t need a smarter agent; you need critics who fail differently. Our curriculum teaches the same instinct at ground level: Part 1 · Chat covers verification, and Part 2 · Agent recommends having a different agent grade the work, because a fresh perspective catches what the author cannot. Multi-agent reflection formalizes that instinct and scales it to a whole system of agents critiquing each other.
#4OCEL, the substrate underneath
Everything so far assumes the agents can see what happened: that a trace exists rich enough to reflect on, to assign credit over, and to compute a reward from. That trace is rarely discussed, and it is where the real novelty lives.
- One case, one trace
- Each event belongs to exactly one case
- Multi-object interactions flattened
- Causal structure destroyed
- Multi-object, multi-relationship
- Events relate to many objects at once
- Dynamic attribute histories
- Qualified E2O and O2O relationships
- Agent trace
- events referencing that agent’s object, enriched with full state
- Evaluator input
- an OCEL trace with KPIs from object-attribute histories
- Credit assignment
- O2O relationships as the causal graph
- Reflection context
- the full object-centric state at each decision point
Trace format and learning algorithm fit together as if designed for each other, though they were not. That connection is the new contribution. Source: Berti et al., OCEL 2.0 specification, 2024
Traditional logs leave out the structure that matters. They flatten everything into one case per trace, where each event belongs to exactly one case. Real organizational work isn’t like that. A single deal touches an analyst, a partner, a CRM record, an investor, a document, and a calendar. Forcing that into one case per trace flattens the interactions between objects and destroys the causal structure, so you can no longer ask which agent’s action caused an outcome.
OCEL 2.0, an open standard for object-centric event data, keeps that structure. Events relate to many objects at once. Objects carry histories of their changing attributes. Relationships between events and objects, and between objects themselves, are qualified and preserved.
OCEL also maps directly onto Reflexion, a link that, to our knowledge, no prior work makes. An agent’s trace is the set of events that reference that agent’s object, enriched with full state. An evaluator’s input is an OCEL trace with KPIs computed from object-attribute histories. Credit assignment runs on the graph of relationships between objects, which serves as the causal graph for counterfactual reasoning. And the reflection context is the full object-centric state at every decision point. Trace format and learning algorithm fit together as if designed for each other, though they were not. That connection is the novel contribution.
Here this piece meets its companion, AI Governance Is a Data Infrastructure Problem, which ends on logs that show what the agent saw and did. Those logs are the same substrate seen from the other side: besides making governance auditable, they are the optimization input that lets an organization improve itself. One substrate does two jobs.
#5A blueprint: five layers, one closed loop
Put the pieces in order and the architecture appears.
- 1
OCEL Traces
Capture multi-agent execution with full object-centric structure.
- 2
Reward
Extract KPIs from the trace: compliance, satisfaction, whatever the objective is.
- 3
Credit
Decompose the system-level reward to per-agent credit, with Shapley / counterfactual reasoning.
- 4
Reflection
Each agent writes a verbal reflection from its trace plus its credit signal.
- 5
Propagation
Distribute reflections through the inter-agent dependency graph, so a lesson reaches the agents it touches.
Then it loops. Propagated reflections change behavior, which produces new traces, new rewards, and the organization adapts.
Mostly an engineering gap, not a research gap.
Five layers, and the arrow comes back around:
- 1.OCEL traces: capture multi-agent execution with its full object-centric structure.
- 2.Reward: extract KPIs from the trace, such as compliance or satisfaction, depending on the objective.
- 3.Credit: decompose the system-level reward into per-agent credit with Shapley or counterfactual reasoning.
- 4.Reflection: each agent writes a verbal reflection from its trace and its credit signal.
- 5.Propagation: distribute those reflections along the dependency graph, so a lesson learned by one agent reaches the agents that depend on it and those it depends on.
Then the loop repeats. Propagated reflections change behavior, which produces new traces and new rewards, and the organization adapts. Each of the five layers has a validated implementation in isolation; the novelty is wiring them into a closed loop. What remains is mostly an engineering gap, not a research gap.
#6What exists, and what is missing
Manifestos drift into hand-waving, so here is the state of the field, concretely.
rise in multi-agent-system inquiries to Gartner, Q1 2024 to Q2 2025
of enterprise apps forecast to include task-specific agents by the end of 2026 (Gartner, Aug 2025)
Langfuse & W&B Weave already capture structured traces with parent-child agent relationships
- Closed optimization loop: today’s multi-agent systems use static orchestration with human-mediated feedback
- OCEL extraction from agent traces: observability data is proto-OCEL, not structured as such
- Inter-agent reflection propagation: reflections stay siloed inside individual agents
- Convergence guarantees: coupled Reflexion loops can oscillate without damping
Each part is validated. Integration and stability are the open work.
Interest is already large. Gartner reported a 1,445% rise in multi-agent-system inquiries from the first quarter of 2024 to the second quarter of 2025, and in August 2025 it predicted that 40% of enterprise applications would include task-specific AI agents by the end of 2026, up from less than 5% in 2025. Observability tools such as Langfuse and Weights & Biases Weave already capture structured traces with parent-child relationships between agents. That tracing data is proto-OCEL: nearly the right substrate, just not structured as such.
Missing, above all, is the closed loop. Today’s multi-agent systems use static orchestration with a person in the middle of the feedback. OCEL extraction from agent traces is rare. Reflections stay inside individual agents instead of propagating along dependencies. And one open problem is real: coupled Reflexion loops can oscillate without damping, so the loop needs convergence guarantees before it runs unattended. Addressing that risk takes oscillation detection, damping, veto agents for compliance, and objective functions that people define.
#7How to run it: ephemeral identity
This architecture forces an engineering question, and I think it is the most interesting design problem we work on. Agents must persist enough to remember and reflect, cost little enough to run by the thousand, and stay free to switch runtimes whenever a better one ships. How do you build that? Those three goals look like they conflict. They don’t, if you derive the architecture from the goals instead of guessing.
Identity continuity
Users perceive one persistent agent that remembers, learns, and keeps a consistent voice.
Test · A partner can’t tell if the underlying system changed under them.
Availability under spiky load
Cost and latency track actual usage, not headcount. Fifty idle agents can’t cost more than five busy ones.
Test · 10× the agents, same cost if usage is flat.
Harness-agnostic
Whichever agent runtime is best at the moment can be swapped in, with no lock-in.
Test · Swap the runtime in a config change, not a rewrite.
Name the invariants first. Three things must always be true:
I. Identity continuity. Users perceive one persistent agent that remembers, learns, and keeps a consistent voice. Test: a partner cannot tell whether the underlying system changed.
II. Availability under spiky load. Cost tracks actual usage, not headcount; fifty idle agents cannot cost more than five busy ones. Test: ten times the agents, same cost if the work is flat.
III. Harness-agnostic. Whichever agent runtime is best at the moment can be swapped in, with no lock-in. Test: swapping the runtime is a configuration change, not a rewrite.
Identity continuity holds the key insight. Conventional thinking says continuity requires a persistent runtime, a long-running process that is the agent. That conflates what the user needs with what the system needs. Persistence is an experience, not a process. Identity is context assembly: personality, memory, skills, and history are files in storage, reconstructed at the moment of invocation, and the runtime that channels them is interchangeable.
Between requests, the agent does not exist. A message arrives, the identity files are pulled from storage, and a runtime assembles them, executes the turn, and terminates. To the user, it feels like a colleague who is always there.
Ephemeral identity
Persistent data, disposable runtimes, a thin orchestration layer between them.
Each turn assembles the identity, executes, and dissolves.
Once the invariants are written down, the architecture follows. Identity continuity wants persistent data, not a persistent process. Spiky-load economics want cost proportional to usage, which only scale-to-zero serverless execution delivers. Harness-agnosticism wants the runtime to be a swappable parameter, which is possible only if identity is fully separated from execution. One architecture satisfies all three: ephemeral identity, with persistent data, disposable runtimes, and a thin orchestration layer between them. Each turn assembles the identity, executes, and dissolves.
Part 5 · Managed architecture describes a design along these lines at the deployment level: a dispatcher routing work to isolated runtimes, with durable state kept outside every runtime. And the identity files that ephemeral identity reconstructs correspond to the L1, L2, and L3 brains in Part 6 · Institutional brain: institutional memory loaded first, the principal’s personal overlay second.
#8Event logs become a data asset
This design also has a commercial consequence.
Internal observability
Event logs from our own agents show how they actually perform.
Customer reporting
Each managed agent shows its owner what it did, how long it took, and what it cost.
Cross-organization patterns
Anonymized patterns across deployments show what a great agent actually looks like.
Each invocation emits an event, so the ledger grows as a byproduct of normal work.
When every interaction is a discrete invocation, the event log is a structural byproduct, not instrumentation bolted on afterward. Every deployment generates a complete audit trail, because assembling and dissolving per message is the same act as emitting an event per message.
Run that forward. Every agent invocation produces a structured event, and over time those events accumulate into a time-resolved ledger of every action the organization takes.
That ledger compounds in three stages. First comes internal observability: we see how our own agents perform, and this stage is under way. Next comes customer reporting: each managed agent shows its owner what it did, how long it took, and what it cost. At scale come anonymized patterns across deployments, which can answer a question no single deployment can: what does a great agent actually look like?
Here the closed loop reappears as a business. A single OCEL ledger makes governance auditable (the companion article), feeds the optimization (this article), and becomes a proprietary dataset. One substrate does three jobs: it proves what happened, improves what happens next, and builds an asset that others cannot copy because they did not capture it from the start.
#9Where this leads
An organization stops being a designed system that people periodically redesign. It becomes a self-optimizing system that continuously adapts its structure to feedback from its environment.
Process improvement is the wrong analogy, because it still has a person standing outside the system, tuning it. Biological adaptation is the right one: a system that changes its own structure in response to its environment, with no one redrawing the org chart. Only the clock differs. Biology runs that loop over generations; this one runs in hours.
Each component is validated. We have started capturing the substrate from our own agents. Integration is the open work, and most of it is engineering, not research.
Read next. AI Governance Is a Data Infrastructure Problem argues that the same trace substrate, the logs that show what the agent saw and did, is what makes governance real; auditability and optimization are two jobs of one ledger. Part 5 · Managed architecture covers deployment: a dispatcher, isolated runtimes, durable state outside every runtime, and the channel as a parameter. Part 6 · Institutional brain treats organizations as multi-agent systems and describes personal-to-institutional distillation; its L1, L2, and L3 brains are the identity files that ephemeral identity reconstructs. Part 1 · Chat and Part 2 · Agent cover verification and having a different agent grade the work, the everyday form of Reflexion and multi-agent critique.
More from our research.
Working on the same question?
We look for people to interview, data to compare against, and teams willing to test what we find. Leave a note and we will write back.