acceptodds
Under review as a conference paper at ICLR 2027

It Takes Two: Co-Evolving Social Worlds and Agent Architectures

Abstract

The worlds in which large language model agents operate are becoming increasingly complex and open-ended, placing growing demands on the architectures that organize their reasoning, memory, and action. However, agent architectures are still typically designed or optimized in fixed worlds that quickly saturate, weakening the evolutionary pressure needed to discover stronger structures and strategies. We propose WoArc, a world–architecture co-evolution framework that makes the world itself an adaptive part of agent design, allowing worlds to evolve around the limitations of current architectures and architectures to evolve against the resulting challenges. WoArc closes this loop by letting current architectures guide the search for informative new worlds, accepting challenges through method-agnostic criteria, and feeding them back into executable architecture evolution, while a resolution-calibrated controller decides whether to keep evolving architectures, refresh the worlds, or stop. Experiments on hidden-information social interactions show that world evolution restores meaningful discrimination among increasingly capable agents, while the resulting architectures outperform published alternatives on test interactions. Our code and the evolved benchmark are available at https://anonymous.4open.science/r/WoArc-29CC.

Primary area:
optimization
Keywords:
Adaptive Worlds, World–Architecture Co-Evolution, Agent Architecture, Large Language Model Agents

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_ZSWaOpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

The paper proposes WoArc, a framework that co-evolves hidden-information social worlds to address the benchmark saturation problem. It effectively lower the overall scores and widen the spread across different models.

Critical strengths
  1. The acceptance criterion is clean in the sense that it does not depend on the evolving architecture.

  2. A lot of baselines are compared against in the paper and are documented clearly on how they are implemented.

Critical weaknesses
  1. The authors' own hand-written Seed Architecture is the strongest baseline and is not treated as one. Seed Architecture reaches +0.23 over Vanilla (Table 9), far above every published method (+0.14 at best) and above WoArc-from-Vanilla (+0.14). It appears only as a "foundation" for the +0.24 upper-reference row. The claim that search "finds a better agent than any published design" is therefore partly a statement about how weak the transplanted baselines are on this task. Seed Architecture should appear as a row in Table 2 and the comparison should be discussed.

  2. Only deepseek-v3.2 is used throughout the paper. Need at least one or two other model families to confirm the generalization of the method.

Questions for authors

N/A

2 comments
AuthorsOpenReview ↗

Response to Reviewer ZSWa

We sincerely thank you for your review and your valuable comments.


[W1] Is the hand-written Seed Architecture a missing baseline?

We add Seed Architecture to Table 2, as an insider reference. It is our own hand design, written with knowledge of how the benchmark's worlds hide information, so it encodes task knowledge that no published method and no search from an empty agent has. Its +0.230 over Vanilla measures what that knowledge is worth.

The fair comparison is among methods without that knowledge. Every published method is implemented with its own prompts on the same Vanilla agent and audited against its source (App. A). WoArc, searched from that same empty agent, matches or exceeds every one of them.

Seed Architecture also shows why the worlds must evolve. On the original benchmark, Seed Architecture is already within 0.09–0.14 of Oracle, less than the resolution ε ≈ 0.18. Any better design would differ from it by less than the benchmark can measure, and indeed a full three-generation search from Seed finds no candidate that beats it: for a design this strong, the original benchmark is saturated. On the evolved worlds, Seed's gap to Oracle widens to 0.43, and the benchmark can tell candidates apart again.


[W2] Does the result hold beyond DeepSeek-V3.2?

We now evaluate beyond DeepSeek-V3.2 on the judge side and on the agent side, and we re-run the search on a new agent.

Judge. We re-judged all Table 2 transcripts with GPT-4.1:

MethodΔ vs Vanilla (GPT-4.1 judge)
WoArc+0.178
MediQ+0.163
SAGE+0.153
ToMA+0.138
GATE (y/n)+0.063
Plan-and-Solve+0.063
ATD+0.058
CONVOLVE+0.038
CoT+0.020
ReAct−0.025
GATE (open)−0.038
ReflAct−0.038
LLM-Delib (greedy)−0.115

Under GPT-4.1, WoArc scores higher than every baseline, and its gain over Vanilla rises from +0.140 to +0.178 [+0.115, +0.242].

Agent, architecture frozen. We kept the partner and judge on DeepSeek and swapped only the agent, with no re-search:

AgentVanilla → WoArcΔ [95% CI]
GPT-4.1 (OpenAI)0.500 → 0.585+0.085 [+0.025, +0.145]
DeepSeek-V4-Pro (stronger)0.568 → 0.745+0.178 [+0.110, +0.245]
Qwen3.8-max (Alibaba)0.655 → 0.750+0.095 [+0.028, +0.160]
DeepSeek-V3.2, reasoning mode0.145 → 0.253+0.108 [+0.058, +0.160]

With the DeepSeek-V4-Pro agent we also ran the published baselines on the same 400 test cells:

Method (DeepSeek-V4-Pro agent)ScoreΔ vs Vanilla
WoArc0.745+0.178
ToMA0.740+0.173
GATE (y/n)0.575+0.008
Vanilla0.568—
MediQ0.553−0.015
GATE (open)0.475−0.093

Re-search on a new agent. WoArc is a procedure, not a fixed architecture. Re-running the search from Vanilla with a Qwen3.8-flash agent finds a different architecture that lifts the agent from 0.668 to 0.805, +0.138 [+0.077, +0.200].

AuthorsOpenReview ↗

Thank you again for your detailed review

Dear Reviewer ZSWa,

Thank you again for your review. Following your suggestions, we added Seed Architecture to Table 2 as an insider reference and discussed the comparison, and we evaluated WoArc beyond DeepSeek-V3.2: with a GPT-4.1 judge, with GPT-4.1, DeepSeek-V4-Pro and Qwen3.8-max agents, and by re-running the search on a Qwen3.8-flash agent. The gains hold in every case.

As the discussion period is coming to an end, we would like to check whether our response has addressed your concerns. If anything remains unclear, please feel free to let us know, and we will be glad to clarify. If our response has resolved your concerns, we would be grateful if you could take it into account in your final assessment.

Best regards, The authors

Reviewer_ogqfOpenReview ↗
Rating
3
Confidence
2
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes WoArc, a framework that co-evolves the hidden factual social world and the executable agent architecture in a single loop. On the world side, LLMs propose candidate worlds through two modes: architecture-aware generation and architecture-independent generation. Two fixed reference agents determine the acceptance criteria: Vanilla and Oracle. On the architectural side: The agent is represented as an executable graph with typed nodes and evolves through 11 types of typed editing, zero-cost causal filtering, and family-by-family Pareto selection. A "resolution calibration" stop rule is based on a select-aware noise model to determine whether to continue evolving the architecture, refresh the world, or stop.

Critical strengths

The question is precise and well-motivated. Benchmark saturation removes selection signals in architecture search, a real and increasingly urgent obstacle in agent design during testing.

The "method-agnostic acceptance criterion" is a clean design. Accepting only Vanilla and Oracle without consulting the architecture under test breaks the cycle of "customizing the benchmark for a certain system". Separating architecture-aware generation from architecture-independent generation for reporting and transforming "circularity" from an assumption into a measurable number is the most commendable design choice in this paper.

The stop rule for resolution calibration is a true contribution. Equation 5-6 explicitly models the winner's curse brought about by "selecting the best from mm candidates", and calibrates the progress determination with a select-aware εm(n)\varepsilon_m(n).

Critical weaknesses

Test set contamination and overfitting risk. The test set is "four unseen worlds in the evolutionary benchmark, one for each family". However, the evolution benchmark itself is generated by "architecture-aware generation", and the generator is explicitly informed of "the mechanism that the current architecture depends on" and is required to "prohibit making it easier for the world to access this mechanism". Meanwhile, the main text does not clearly state whether the architecture search development set comes from the same evolutionary benchmark. If so, the test and development worlds share the same origin and are both influenced by architecture-aware generation. The test set is not independent of the architectural evolution process.

The claim of the "method-agnostic acceptance" is weaker than stated. The acceptance criterion does indeed only read Vanilla and Oracle, and this holds true. However, the framework proposition of the paper is "co-evolution": generation is architecture-aware, the development set comes from the evolutionary benchmark, and the architecture searches on the evolutionary benchmark. Therefore, the entire loop is not method-independent; only the acceptance step is. The paper states that "circularity becomes a number we report rather than an assumption we defend,” but the reported number measures the skew in the "accepted worlds" rather than in the "architecture search." These two are different. Even if the scores of the accepted worlds on the aware/independent halves are similar, the architecture may still be searched for better in the aware world.

The co-evolution loop actually ran only about 1.5 times. The experimental process is as follows: one round of world evolution → three generations of architecture evolution → another round of world evolution (W1 → W2) → " further architecture evolution finds no valid successor". Therefore, the complete "world → architecture → world → architecture" cycle only closed once, and there was no corresponding architecture evolution after the second world evolution. For a paper with "co-evolution" as its core proposition, this is a significant empirical gap. §4.6 honestly attributes this to " the bottleneck having shifted from benchmark discrimination to the local architecture search neighborhood," but this precisely indicates that the current editing operators are insufficient to support multiple rounds of co-evolution.

Questions for authors

Independence of the test set. Do the 4 worlds in the test set come from the evolved benchmark? Do the 5 development worlds of architecture search also come from evolved benchmarks? If so, do the testing world and the development world overlap or originate from the same source? Please clearly state this and report a result on a held-out test set that is completely generated by architecture-independent generation.

Number of co-evolution cycles. The complete "world → architecture → world → architecture" cycle was closed only once (there was no architecture evolution after the second round of world evolution). Is this sufficient to support the core proposition of "co-evolution"? If the editing operator is insufficient to support multiple rounds of loops, why not express the contribution as "one round of world evolution + architecture evolution"?

Statistical significance. The gap between WoArc (+0.1400) and ATD (+0.1250) at 400 episodes is 0.015. Please report the bootstrap confidence interval and pairwise test results. Under the calibration seed of n=8n=8, the granularity of the acceptance criterion is 0.125. Does this mean that the quality of the accepted world is uneven?

5 comments
AuthorsOpenReview ↗

Response to Reviewer ogqf (Part 1/2)

We sincerely thank you for your review and your valuable comments.


Several of your points turn on how the loop ran, so we first lay it out. D and T denote the dev and test worlds of the architecture search, fixed before any search; T is the test set of Table 2.

StepWhat happensRole
A0Hand-designed reference architecture: the probe-then-act planner of App. A and Table 1, with a stop gateThe "current architecture" whose mechanism the first world round targets (§3 of the paper)
W0 → W1W0 is saturated; worlds evolve, and the architecture-aware half targets A0's mechanismHeld out from the search that produced A1
A1 (WoArc)Searched from Vanilla on DTested on T (Table 2); also evaluated on W1
A1 → W2Worlds evolve; the architecture-aware half targets A1's own mechanismA1's margin over Vanilla falls from +0.140 to +0.014
W2 → A2Search from A1 on W2A2 beats A1 on T by +0.080

In the table, Wn is the n-th generation of worlds and An the n-th generation of architecture.

Why the loop is laid out this way.

  • The world side moves first because the original benchmark W0 was saturated: three of its four families sat near 0.90 for Vanilla, collapsing a four-way construct to one (§4.2). W1 restores discrimination (spread 0.164 → 0.294).
  • A1 starts from Vanilla, not from A0, so that the search shows what it finds without a hand-written scaffold; every published method in Table 2 is also built on Vanilla.
  • W1 is kept out of the search it evaluates. W1 was built without reference to WoArc, and WoArc was selected without seeing W1, so W1 is a held-out test on newly evolved worlds, free of the circularity a co-evolving benchmark is otherwise exposed to. From the second round the loop closes: W2 targets A1 itself, and the search continues on W2.

[W1 & Q1] Is the test set independent of the evolution?

We answer your three questions and add the held-out evaluation you asked for.

  • D and T are not from the evolved benchmark. No candidate architecture was run on them and no architecture-aware generation was involved, which keeps the test independent of the evolutionary process. The wording in §4.1 is ambiguous, and the revision states it more clearly.
  • D and T do not overlap. They share no world and no SOTOPIA scenario, and neither shares a world or a scenario with the 17 worlds of W1.
  • Held-out test set produced entirely by architecture-independent generation. W1 provides it. On all 17 worlds of W1 (408 cells), WoArc beats Vanilla by +0.098 [+0.047, +0.150]; on its 7 worlds produced entirely by architecture-independent generation (168 cells), by +0.125 [+0.048, +0.202], and ToMA by +0.107 [+0.036, +0.173].

There is therefore no test-set contamination or overfitting risk.


[W2] Is the whole loop method-agnostic, or only acceptance?

We agree on the wording and now write "method-agnostic acceptance" throughout. The bias you point to, in the search rather than in the accepted worlds, we measured directly. We ran the same search twice, once on architecture-aware worlds only and once on architecture-independent worlds only, and evaluated both on the same 400 test cells. The two are indistinguishable (+0.133 vs +0.150 over Vanilla; difference −0.018 [−0.083, +0.048]): searching on worlds written with knowledge of the architecture gives the search no advantage.

AuthorsOpenReview ↗

Response to Reviewer ogqf (Part 2/2)

[W3 & Q2] Has the loop run enough cycles to support co-evolution?

The gap you name, no architecture evolution after the second world round, is now closed (table at the top of this reply). W2 targets A1's own mechanism, and A1's margin over Vanilla falls to +0.014 [−0.093, +0.129] there (140 cells): the benchmark has room again.

  • Why A2 did not occur in the paper. The search on W2 used structural edits only, and every structural edit in the vocabulary was already in A1. With room in the benchmark but no candidate, the controller stops and indicates that the bottleneck has moved to the architecture search (§3.3, §4.6). This is the stop rule working as designed.
  • Why it occurs now. We ran an incremental experiment that widens the edit vocabulary to also rewrite slot content, with the worlds unchanged. The best candidate on W2 (dev 0.475 → 0.588) beats A1 on T, 0.730 vs 0.650, +0.080 [+0.018, +0.142], and Vanilla by +0.190 [+0.125, +0.255]. The worlds had room; one more tool on the architecture side was enough to use it.
  • Why this is co-evolution (Q2). Each side has changed in response to the other. The worlds respond to the architecture: each world round targets the mechanism of the current architecture (W1 targets A0, W2 targets A1), and A1's margin over Vanilla collapses on W2. The architecture responds to the worlds: A2 is searched on W2 and beats A1 on T.

So the loop has run only a few cycles, but it has already paid off on both sides: a new benchmark that separates methods far better than the original (Table 1: spread 0.164 → 0.294, split-half reliability 0.73 → 0.87) and an architecture that beats Vanilla by +0.140 on test (Table 2). The bottleneck now is the architecture search, not the world side: the evolved worlds already offer room that today's search cannot fully use. Our contribution is the co-evolution framework itself, not any single architecture. Since acceptance never reads the candidate, the loop is open to any architecture-search method. We look forward to stronger architecture-search methods from the community: within this loop, they could sustain more cycles, and every extra cycle yields both a more discriminative benchmark and a stronger architecture. WoArc is the starting point of this process, and we hope the community will carry it through many more generations.


[Q3] Is WoArc significantly ahead, and is acceptance too coarse?

  • Significance. Under the DeepSeek judge, WoArc − ATD = +0.015 [−0.050, +0.080]: at 400 cells the two are level, and the revision now says so. The gap opens under an independent judge: with GPT-4.1, WoArc − ATD = +0.120 [+0.050, +0.193] and WoArc − GATE (y/n) = +0.115 [+0.052, +0.180]. On a 17-world, 408-cell evaluation, WoArc − GATE (y/n) = +0.069 [+0.017, +0.123].
  • Acceptance granularity. With 8 calibration seeds, a world's Vanilla rate moves in steps of 0.125, so a single admission decision is coarse: a world near a threshold can fall on either side of it. This does not make the admitted set uneven, because admission is only a cheap screen, and we check the admitted worlds as a whole, on the episodes of every method:
    • only 1 of the 17 evolved worlds fails to separate methods, against 5 of the 16 unevolved worlds;
    • the benchmark ranks methods consistently: split the seeds into two halves, and the two halves agree with reliability 0.868 (0.726 before evolution);
    • the conclusion does not depend on where the thresholds sit: across nine threshold settings, the evolved benchmark stays harder than the unevolved one for all six published method variants (App. B.8).
AuthorsOpenReview ↗

Thank you again for your detailed review

Dear Reviewer ogqf,

Thank you again for your careful review. In our response, we laid out how the loop actually ran and showed that the development and test worlds are not part of the evolved benchmark, so there is no test-set contamination; we added a held-out evaluation on worlds produced entirely by architecture-independent generation (+0.125 over Vanilla), showed that the loop now continues after the second world round, and reported confidence intervals for the comparisons you raised.

As the discussion period is coming to an end, we would like to check whether our response has addressed your concerns. If anything remains unclear, please feel free to let us know, and we will be glad to clarify. If our response has resolved your concerns, we would be grateful if you could take it into account in your final assessment.

Best regards, The authors

Reviewer_zS3JOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
3
Soundness
3
Read review
Paper summary

The paper proposes WoArc, a framework that co-evolves hidden-information social worlds and LLM agent architectures. New worlds are generated by an LLM and accepted only if a fixed unscaffolded agent (Vanilla) and an agent given the hidden facts (Oracle) meet a difficulty and information-value criterion. Agent architectures are evolved as executable graphs, and a resolution-calibrated controller decides when to stop or refresh the worlds. Experiments show that world evolution improves benchmark discrimination and that the evolved agent matches or exceeds published methods on the test set.

Critical strengths
  1. The paper addresses a real and timely problem: as agents improve, fixed benchmarks saturate and lose the selection signal that architecture search depends on. Making the world an adaptive part of agent design is a natural response. Admitting new worlds only through fixed reference agents, never through the architecture under test, is a sensible way to couple the two searches without circularity.

  2. The architecture search is principled. It starts from an empty agent, and its edit vocabulary creates interfaces but no content, so any strategy that emerges is discovered by search rather than written in by hand. Typed graph edits, causal screening and per-family Pareto selection make the search more disciplined than free-form code generation.

  3. The controller makes three decisions under one rule: whether to continue architecture search, refresh the worlds, or stop. The rule is grounded in evaluation resolution rather than a fixed iteration budget. Using the gap to Oracle to distinguish exhausted edits from an exhausted benchmark is a neat idea.

Critical weaknesses
  1. The task leaves little room for architecture design. The testbed is a short two-party conversation with no tools and no long-horizon control, the full history fits in context, and agents are limited to two calls per turn. Architecture search therefore reduces to prompt optimization of a single reasoning step. This does not match the paper’s motivation about increasingly complex worlds, and prompt-optimization baselines are missing.

  2. World evolution relocates overfitting rather than removing it. The generator, partner, judge, and reference agents all come from one model family. Worlds are selected where that model fails, the harness is then tuned to fix those failures, and the test worlds are drawn from the same generated pool. The gains do not hold on other world sources, transfer to MediQ is marginal, and no other base model is tested.

  3. The central claim is untested and the results are overstated. There is no control that runs the same search on the unevolved benchmark, so the benefit of co-evolution is not demonstrated. A further round of world evolution yields no better architecture. The headline result ties an existing baseline (GATE), and it rests on only four test worlds without confidence intervals.

Questions for authors
  1. Agents here have no tools, a short horizon, and the full history in context. What does the architecture search contribute beyond optimizing the prompt of a single reasoning step? How does WoArc compare with a prompt optimizer such as GEPA or MIPROv2 under the same evaluation budget?

  2. Can the framework be demonstrated in a setting where architecture plays a substantive role, such as tool use, long-horizon control or memory management (e.g., τ-bench-style environments)? Does the edit vocabulary extend meaningfully to such settings?

  3. Do the gains hold when the base model changes? For example: a stronger model, a reasoning mode, or a generator, partner and judge drawn from a different model family than the agent. Without this, it is hard to tell a general architecture apart from a patch for one model’s failure modes.

  4. The paper’s premise is that a more discriminative benchmark yields better architectures. Can you test this directly by running the same search, with the same budget, on the unevolved benchmark and evaluating on the same test worlds? How do you reconcile the premise with the finding that search finds no successor after the second round of world evolution?

  5. Acceptance is anchored to a fixed Vanilla agent, and the architecture-independent worlds turn out to be harder than the architecture-aware ones. In what sense, then, do the worlds evolve in response to the architectures? How would the benchmark remain informative once architectures substantially outperform Vanilla?

8 comments
AuthorsOpenReview ↗

Response to Reviewer zS3J (Part 1/3)

We sincerely thank you for your review and your valuable comments.


[W1 & Q1] Is architecture search just prompt optimisation?

WoArc optimises the architecture, not the prompt text. We would like to clarify that, even in this short two-party setting, architecture search does not reduce to optimising the prompt of a single reasoning step. The two-call limit bounds the model calls per turn, not the architecture. What is carried across turns, how evidence is aggregated and which branch runs are decided by components outside those two calls, and this is where the champion's gain lies. All 10 of its edits over Vanilla are structural: 15 effective nodes, a stop/continue branch with 2 conditional edges, 8 deterministic cross-turn memory operations (append_unique, count_distinct, set_if_changed), a verifier and parallel observers. Together they add only about 163 prompt tokens.

A prompt optimiser cannot reach these gains. It rewrites text inside slots that already exist; it cannot create a gate, a memory channel or a deterministic aggregation. The structure WoArc finds carries a real gain: in the random-search control (App. B.7), WoArc's architecture reaches +0.075, against −0.006 on average for six architectures drawn from the same edit space.

Equal-budget comparison. To answer Q1 directly, we ran MIPROv2 (0-shot, instruction-only) on Vanilla's two instruction slots, matched to WoArc on the 80 dev cells, the episode budget (2,720), the instrument, at most 2 calls per turn and the 400-token prompt-growth cap. Both arms are evaluated on the same 400 test cells (DeepSeek-V3.2 agent):

MethodScoreΔ vs Vanilla [95% CI]
Vanilla0.540—
MIPROv20.633+0.093 [+0.025, +0.160]
WoArc0.665+0.125 [+0.060, +0.190]

WoArc scores slightly above MIPROv2. The two optimise different things: MIPROv2 rewrites the text of slots that already exist, whereas WoArc's gain is structural. Because acceptance never reads the candidate, the same benchmark measures both.

So even in a short two-party dialogue, architecture search contributes what prompt optimisation cannot: structure the search finds, and a gain that holds when the agent is swapped (W2/Q3). The revision adds MIPROv2 as a baseline and a related-work discussion of prompt optimisers such as MIPROv2 and GEPA.


[Q2] Does the framework carry over to a tool-use setting such as τ-bench?

The framework ports. We ran WoArc on τ-bench retail with the pipeline unchanged: the user instruction is the hidden information, Oracle is the agent told it, and the edit vocabulary gained typed edits for tool use (a deterministic argument check, re-specification of the system/confirm slots, and an elicitation step before state-changing actions).

The original tasks leave little room; world evolution opens it. The room that hidden information offers any architecture is the gap between Oracle and Vanilla. We then applied WoArc's world side to the same retail tasks: each task hides one choice detail of the instruction and is admitted with the same Vanilla/Oracle rule.

AgentTasksVanillaOracleOracle − VanillaAdmitted as worlds
gpt-4.1-minioriginal (240)0.8360.844+0.0087–10%
gpt-4o-minioriginal (160)0.6980.634−0.0647–10%
qwen3.8-maxoriginal (200)0.8500.945+0.09538
qwen3.8-maxevolved, same 2000.7270.878+0.15256
qwen3.8-maxevolved, 80 new tasks0.7170.829+0.11319

On the original tasks, knowing the hidden instruction barely helps: retail failures are execution errors, not missing information, and that room lies outside the hidden-information setting WoArc targets. WoArc therefore correctly returns Vanilla, while a greedy accept-any-gain rule would have shipped a candidate significantly worse on test (−0.070 [−0.128, −0.014]). World evolution turns the same tasks into worlds where hidden information matters: the gap grows from +0.095 to +0.152, more tasks are admitted, and the gain holds on new tasks.

Architecture side. On the evolved worlds the search certifies one edit, the elicitation step, and on held-out worlds it ties Vanilla (−0.009 [−0.096, +0.079], 114 cells).

AuthorsOpenReview ↗

Response to Reviewer zS3J (Part 2/3)

[W2 & Q3] Does the result depend on one model family?

Swap the judge: DeepSeek → GPT-4.1. We re-judged all Table 2 transcripts with GPT-4.1:

MethodΔ vs Vanilla (GPT-4.1 judge)
WoArc+0.178
MediQ+0.163
SAGE+0.153
ToMA+0.138
GATE (y/n)+0.063
Plan-and-Solve+0.063
ATD+0.058
CONVOLVE+0.038
CoT+0.020
ReAct−0.025
GATE (open)−0.038
ReflAct−0.038
LLM-Delib (greedy)−0.115

Under GPT-4.1, WoArc scores higher than every baseline, and its gain over Vanilla rises from +0.140 to +0.178 [+0.115, +0.242].

Swap the agent: DeepSeek-V3.2 → GPT-4.1, V4-Pro, Qwen3.8-max (architecture frozen). We kept the partner and judge on DeepSeek and swapped only the agent, which is the decoupling you asked for; the architecture is frozen, with no re-search:

AgentVanilla → WoArcΔ [95% CI]
GPT-4.1 (OpenAI)0.500 → 0.585+0.085 [+0.025, +0.145]
DeepSeek-V4-Pro (stronger)0.568 → 0.745+0.178 [+0.110, +0.245]
Qwen3.8-max (Alibaba)0.655 → 0.750+0.095 [+0.028, +0.160]
DeepSeek-V3.2, reasoning mode0.145 → 0.253+0.108 [+0.058, +0.160]

With the DeepSeek-V4-Pro agent we also ran the published baselines on the same 400 test cells:

Method (DeepSeek-V4-Pro agent)ScoreΔ vs Vanilla
WoArc0.745+0.178
ToMA0.740+0.173
GATE (y/n)0.575+0.008
Vanilla0.568—
MediQ0.553−0.015
GATE (open)0.475−0.093

WoArc scores higher than every baseline on the stronger model as well.

Swap the agent and re-search: Qwen3.8-flash. WoArc is a procedure, not a fixed architecture. Re-running the search from Vanilla with a Qwen3.8-flash agent finds a different champion (a commitment/stopping edit) that lifts the agent from 0.668 to 0.805, +0.138 [+0.077, +0.200].

Swap the world source: architecture-independent worlds. The 4 test worlds and 5 dev worlds are not part of the evolved benchmark; no candidate architecture was run on them and no architecture-aware generation was involved. They are disjoint from the 17-world Table 1 benchmark, and dev and test share no SOTOPIA scenario. On the 7 worlds of the 17-world benchmark produced entirely by architecture-independent generation (168 cells), WoArc beats Vanilla by +0.125 [+0.048, +0.202] and ToMA by +0.107 [+0.036, +0.173].

Swap the world generator: DeepSeek → Qwen3.8-flash. We replaced the DeepSeek world generator with Qwen3.8-flash and admitted its worlds with the same rule (8 of 39 proposals). On these worlds the frozen champion again improves on Vanilla, from 0.706 to 0.769 (8 worlds × 20 seeds).

Swap the task: the MediQ benchmark. The transfer to the MediQ benchmark moves the frozen architecture to a different task with no re-search. Across models WoArc transfers the frozen architecture (the four agents above); across tasks it transfers the procedure, which re-searches instead of reusing an architecture (Q2).

AuthorsOpenReview ↗

Response to Reviewer zS3J (Part 3/3)

[W3 & Q4] Is the premise tested, and are the results overstated?

The premise concerns the saturated regime. From Vanilla, H_t/ε stays at 1.51–2.65 on the dev worlds the search runs on, so the controller does not call for world evolution there, as in the paper. Once the agent is strong, a fixed benchmark no longer separates candidates. We therefore ran the A/B control from a strong agent: the same three-generation WoArc search from Seed Architecture, once on the unevolved and once on the evolved dev worlds.

  • Unevolved worlds. Oracle is 0.925 and Seed Architecture already scores 0.79–0.84, so H_t ≈ 0.09–0.14 < ε. All 32 candidates over three generations score 0.70–0.825, none exceeds the start, and the search returns Seed Architecture unchanged. The controller correctly signals that this benchmark can no longer resolve improvements.
  • Evolved worlds. Oracle is 0.963 and Seed Architecture 0.53, so H_t ≈ 0.43 > ε: the benchmark has room again, and the search finds candidates up to +0.10 over the start.

The premise is thus measured by the controller rather than asserted.

No successor after the second round. The loop has run only a few cycles so far, but it has already paid off on both sides: it produced a new benchmark that separates methods far better than the original (Table 1: spread 0.164 → 0.294, split-half reliability 0.73 → 0.87, all 3 saturated families recovered) and an architecture that beats Vanilla by +0.140 on test (Table 2). The loop then stopped by the paper's stop rule, as §4.6 states: world evolution reopened headroom (the architecture-aware half of W2 targets the champion's own mechanism, and on W2 the champion's margin over Vanilla fell from +0.140 to +0.014), but every structural edit in the vocabulary was already in the champion, so the controller indicated that the bottleneck had moved to the architecture side. We ran an incremental experiment that widens the architecture search to also rewrite the content of existing slots. With this single change, the second architecture step proceeds and beats the submitted champion on test by +0.080 [+0.018, +0.142]. The bottleneck now is the architecture search, not the world side: the evolved worlds already offer room that today's search cannot fully use. Our contribution is the co-evolution framework itself, not any single architecture. Since acceptance never reads the candidate, the loop is open to any architecture-search method. We look forward to stronger architecture-search methods from the community: within this loop, they could sustain more cycles, and every extra cycle yields both a more discriminative benchmark and a stronger architecture. WoArc is the starting point of this process, and we hope the community will carry it through many more generations.

GATE tie. With CIs, WoArc − GATE (y/n) = +0.115 [+0.052, +0.180] under the GPT-4.1 judge, and +0.069 [+0.017, +0.123] on a 17-world, 408-cell evaluation.


[Q5] How do the worlds respond to the architecture under a fixed Vanilla anchor?

In what sense the worlds respond to the architecture. The generator is told which mechanism the current architecture relies on and must not write worlds that this mechanism makes easier. The worlds therefore respond to the architecture by testing what it cannot yet do, not by being harder on average. This shows in coverage: architecture-aware generation is the only source of acceptable new two-facts worlds (3 of 3; architecture-independent generation produced none). Architecture-independent generation in turn de-saturates the disconfirm family (0.896 → 0.604), so the two modes are complementary, and only together do all four families discriminate (Fig. 5a).

Why the anchor is Vanilla. A world is admitted when Vanilla fails it and Oracle solves it. The rule looks only at these two fixed agents and never at the architecture under test, so no candidate can shape the benchmark in its own favour.

Once architectures far exceed Vanilla. The anchor can then move to any frozen earlier champion, for example the first-cycle WoArc architecture. The rule still never reads the architecture under test, so this property is kept. The controller tells us when to move it: once the gap between the current agent and Oracle falls below ε, the benchmark no longer separates candidates. Our strong-agent experiment (W3/Q4) shows exactly this: on the unevolved benchmark the gap is only 0.09–0.14, below ε, and no candidate can be told apart, while the evolved worlds reopen it to 0.43.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General Response to All Reviewers

We thank all reviewers for their careful reading. The shared concerns were: (1) whether architecture search reduces to prompt optimisation, (2) dependence on one model family, (3) statistical resolution, and (4) whether co-evolution itself matters. We ran new experiments for each.

Model families (zS3J W2/Q3, ZSWa W2).

  • Judge. Re-judging all Table 2 transcripts with GPT-4.1 raises WoArc vs Vanilla from +0.140 to +0.178 [+0.115, +0.242]. Under GPT-4.1, WoArc is significantly ahead of GATE (y/n), GATE (open), ATD and every reasoning-paradigm baseline.
  • Agent, architecture frozen. WoArc's gain holds when only the agent is swapped: GPT-4.1 +0.085 [+0.025, +0.145], DeepSeek-V4-Pro +0.178 [+0.110, +0.245], Qwen3.8-max +0.095 [+0.028, +0.160], DeepSeek-V3.2 reasoning mode +0.108 [+0.058, +0.160].
  • Re-search. WoArc is a procedure. Re-running it with a Qwen3.8-flash agent finds a different architecture, +0.138 [+0.077, +0.200].

Prompt optimiser at equal budget (zS3J W1/Q1). On WoArc's dev cells, episode budget and instrument, MIPROv2 on Vanilla's instruction slots scores 0.633, and WoArc slightly above it at 0.665. The two optimise different things, text in existing slots versus structure. Acceptance never reads the candidate, so the same worlds and controller measure both.

Co-evolution itself (ogqf W3, zS3J Q4). The loop starts on the world side, because the original benchmark was saturated (three of its four families near 0.90 for Vanilla), and alternates from there.

  • The first world round restores discrimination (spread 0.164 → 0.294) and is kept out of the search it evaluates: WoArc, selected on fixed dev worlds, beats Vanilla on it by +0.098 [+0.047, +0.150].
  • The second world round targets WoArc's own mechanism, and WoArc's margin over Vanilla falls from +0.140 to +0.014 there. An incremental search on these worlds that also rewrites slot content then beats WoArc on the held-out test cells by +0.080 [+0.018, +0.142].
  • From a strong agent, the original benchmark leaves too little room to separate candidates (headroom 0.09–0.14, below ε), while the evolved worlds reopen it (0.43).

The worlds open the room and the architecture fills it. It takes two.

Resolution (ogqf Q3). On a 17-world, 408-cell evaluation, WoArc beats Vanilla by +0.098 [+0.047, +0.150] and GATE (y/n) by +0.069 [+0.017, +0.123].

All new results and corrected descriptions have been added to the revision and are marked in blue.

AuthorsOpenReview ↗

Summary of the Discussion

We thank all three reviewers for an engaged discussion. During the discussion, we addressed each of the main concerns; all new results are in the revision, marked in blue.

We addressed the concern of Reviewers zS3J and ZSWa about dependence on one model family: WoArc's gain holds when the judge, the agent and the world generator are each changed (e.g. +0.178 over Vanilla under a GPT-4.1 judge, and significant with GPT-4.1, DeepSeek-V4-Pro and Qwen3.8-max agents), and Reviewer zS3J confirmed that WoArc "is generalizable across datasets and models". We addressed Reviewer zS3J's question about settings beyond short dialogue: the framework ports to τ-bench, a tool-use setting. We addressed Reviewer ogqf's concern about test-set independence: the dev and test worlds are independent of the evolved benchmark, and WoArc beats Vanilla by +0.125 on worlds generated with no architecture information. We addressed the concern of Reviewers ogqf and zS3J about the number of co-evolution cycles: the second-round worlds, which target the champion's own mechanism, offer room for the architecture, and searching on them yields an architecture that beats the submitted one on the test set by +0.080 [+0.018, +0.142]. We also addressed Reviewer ogqf's request for statistical significance, with confidence intervals for all comparisons, and Reviewer ZSWa's request to include Seed Architecture, now a row in Table 2.

For Reviewer ogqf's remaining point on judges and the edit vocabulary, we commit to re-judging all Table 2 transcripts with additional judges from different model families, and to a vocabulary ablation, in the final version.

In short, WoArc addresses a growing problem in agent design: as agents improve, fixed benchmarks saturate and lose the selection signal that architecture search depends on. WoArc makes the world an adaptive part of agent design. Its evolved worlds restore that signal, separating methods far better than the original benchmark (spread 0.164 → 0.294, split-half reliability 0.73 → 0.87, all three saturated families recovered), while method-agnostic acceptance keeps the benchmark from being tailored to any system; the architecture found on these worlds generalizes across judges, agents and world generators; and a resolution-calibrated controller decides when to search, when to refresh the worlds and when to stop. We thank the reviewers again for helping us strengthen the paper.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.