Agent2World: Symbolic World Modeling

• Agent2World is a framework that transforms natural language into executable symbolic world models with structured predicates, actions, and transitions for effective planning.
• It employs a three-stage multi-agent pipeline—Deep Researcher, Model Developer, and Testing Team—to iteratively refine implementations through research, simulation, and adaptive testing.
• Empirical evaluations on benchmarks like Text2World, CWMB, and ByteSized32 demonstrate measurable improvements in executability, planning accuracy, and dynamic behavior alignment.

Agent2World is a framework for generating symbolic world models—such as Planning Domain Definition Language (PDDL) domains and executable simulators—from natural-language task descriptions through tool-augmented multi-agent interaction (Hu et al., 26 Dec 2025). It is motivated by the observation that world-model correctness is primarily behavioral: a candidate model must not only parse or type-check, but also encode valid predicates, actions, constraints, rewards, and state transitions when executed. In the broader research landscape, this places Agent2World within a world-centered view of agent systems, in which explicit world representations rather than purely local agent beliefs become the operative substrate for planning, verification, and coordination (Mantsivoda et al., 1 Apr 2026).

1. Formal object and conceptual lineage

At the formal level, Agent2World treats world-model generation as a mapping

$F(x)=WM,$

where $x$ is a natural-language description and

$$WM=(P_{\text{env}}, A_{\text{env}}, T_{\text{env}})$$

comprises environment predicates, environment actions, and a transition function over states and actions (Hu et al., 26 Dec 2025). This framing makes the target artifact neither a free-form explanation nor a policy, but an executable environment model suitable for model-based planning.

The idea that agents should interact through explicit world structure has deeper antecedents. World Automata extended Hybrid I/O Automata with world variables whose values are functions of time and space, so that agents could communicate by perturbing and sensing an environment rather than only by direct message passing (Capiluppi et al., 2013). More recently, world-centered multi-agent systems formalized a world as

$W=(E,R,S,A,T,C),$

with entities, relations, state, admissible actions, transition function, and constraints or norms, and argued that structured institutional domains are better served by a shared, explicit world model than by fragmented agent-local representations (Mantsivoda et al., 1 Apr 2026). This suggests that Agent2World inherits two commitments from adjacent work: semantic explicitness and executional fidelity.

What distinguishes Agent2World from generic code synthesis is that its outputs are intended to be operational world specifications. In PDDL settings, this means action schemas, preconditions, and effects that support downstream planning. In executable-code settings, it means simulators whose runtime behavior matches the task specification. The framework therefore treats symbolic world models as first-class computational objects, not merely as textual proxies for tasks.

2. Multi-agent architecture

Agent2World is organized as a three-stage pipeline composed of a Deep Researcher, a Model Developer, and a Testing Team (Hu et al., 26 Dec 2025). The architecture is explicitly role-specialized: knowledge synthesis is separated from implementation, and implementation is separated from execution-grounded diagnosis.

The Deep Researcher resolves underspecification in the original prompt. It uses browser_search and browser_open, with the Serper API as the search backend, to identify ambiguities, gather external evidence, reconcile conflicts, and produce a structured report. The reported intermediate representation contains sections such as <Version & Provenance>, <Evidence Summary>, <Spec Patch>, <Theoretical Foundations>, <Final Specification>, <Assumptions & Risks>, and <Third-Party Library Usage>. In practice, this stage supplies missing reward definitions, observation and action conventions, seeding behavior, truncation logic, dependency versions, and other benchmark- or domain-specific details that are often absent from the initial task description.

The Model Developer receives the original task plus the Researcher’s report and implements the target world model. Its tool interface includes file_tool, sandbox, and run_code. Depending on the benchmark, it emits either PDDL or executable Python code, including Gym-like simulators, text-game environments, and MuJoCo-style tasks. The Developer is embedded in an iterative repair loop rather than a one-shot generation regime: it drafts an artifact, executes it in the sandbox, inspects diagnostics, and patches the implementation.

The Testing Team is split into a Unit Tester and a Simulation Tester. The Unit Tester uses run_code, run_bash, and file_tool to synthesize Pytest-style tests for API contracts, action handling, state invariants, determinism, observation validity, and interface compliance. The Simulation Tester uses play_env and file_tool to interact with the environment in a ReAct-style loop, collecting trajectories and checking whether actual state transitions, rewards, terminal conditions, and behavioral affordances match the specification. The two testers therefore probe different failure surfaces: one is contract- and invariant-oriented, the other is behavior- and rollout-oriented.

The loop is bounded rather than open-ended. All agents operate with a ReAct loop of at most 10 steps, and refinement iterations are benchmark-specific: 2 for Text2World, 2 for ByteSized32, and 3 for CWMB (Hu et al., 26 Dec 2025). The operational significance of this decomposition is that Agent2World does not ask a single LLM to jointly resolve ambiguity, implement semantics, invent tests, and judge dynamic behavior; it distributes those functions across agents whose outputs are mutually constraining.

3. Behavioral verification and the data engine

Agent2World formalizes each role as a tool-augmented LLM policy. Given a tool set

$T=\{t_1,\ldots,t_m\},$

an agent at step $t$ has history

$h_t=(x,o_{\le t},a_{<t}),$

where $x$ is the task, $o$ are tool observations, and $a$ are previous tool calls; the next action is sampled as

$x$0

(Hu et al., 26 Dec 2025). For the Model Developer, the paper induces an MDP

$x$1

where the state contains the specification plus tester diagnostics, the action is a new implementation or patch, the transition is induced by re-execution and re-testing, and the reward aggregates testing outcomes.

The framework’s central methodological move is to replace static validation with behavior-aware adaptive feedback. Earlier systems could often detect parse failures, schema mismatches, or planner-level inconsistencies, but Agent2World treats execution itself as the primary source of supervision. Unit tests are synthesized from the current artifact and observed failures rather than drawn from a fixed static suite, and simulation-based validation probes emergent runtime behavior rather than only declared interface structure. This is why the paper emphasizes behavior-level errors: wrong rewards, incorrect done conditions, inconsistent state updates, unreachable goals, missing or overly restrictive preconditions, non-determinism, and state drift can all survive syntax checks.

The same loop also serves as a data engine for supervised fine-tuning. A complete developer–tester interaction is stored as a trajectory

$x$2

and a verifier decides whether to retain it:

$x$3

Only successful trajectories are kept via verifier-guided rejection sampling:

$x$4

The resulting corpus contains 1526 high-quality verified trajectories spanning four world-model types: PDDL, MuJoCo-style environments, text games, and MCP-style tool environments (Hu et al., 26 Dec 2025). The significance is that the training signal is not just “here is a correct final artifact,” but “here is how a world model is iteratively repaired under execution-grounded critique.”

The reported error distributions clarify why this matters. On CWMB, the major categories include signature-mismatch, schema-mismatch, dynamics-error, non-deterministic behavior, judgment-bug, and invariant-violation; on ByteSized32 they include state-bug, contract-fail, undefined-symbol, invalid-action, and syntax-error (Hu et al., 26 Dec 2025). Turn-wise analyses show that early iterations predominantly eliminate interface-level failures, while later iterations focus on deeper dynamics errors. This progression suggests that symbolic world-model generation has a layered failure structure: surface legality is only the entry point to behavioral adequacy.

4. Benchmarks and empirical performance

Agent2World is evaluated on three benchmarks: Text2World for PDDL generation, CWMB for executable Python world models, and ByteSized32 for reasoning-heavy text-game environments (Hu et al., 26 Dec 2025). Text2World measures executability, normalized Levenshtein similarity, and several F1 scores over predicates and action components. CWMB measures prediction accuracy and normalized return

$x$5

which evaluates downstream planning utility relative to random and oracle planners. ByteSized32 measures technical validity, specification compliance, winnability, and physical reality alignment.

Benchmark	Representation	Agent2WorldMulti result
Text2World	PDDL	Executability 93.1, F1 AVG 75.4
CWMB	Executable code	Overall Acc 0.5441, Overall $x$6 0.4811
ByteSized32	Text-game code	Runnable Game 0.8958, Alignment 0.4768

On Text2World with GPT-4.1-mini, Agent2WorldMulti reaches 93.1 executability and 75.4 average F1, exceeding Text2World EC=3 by 14.9 points in executability and 15.3 points in F1 AVG (Hu et al., 26 Dec 2025). On CWMB with the same backbone, it attains overall normalized return 0.4811, surpassing GIF-MCTS by 0.132 in overall $x$7. On ByteSized32, its most striking advantage is physical reality alignment, reaching 0.4768 and improving over Agent2WorldSingle by 0.2848. These are not syntax-only gains; the metrics emphasize planning fidelity, runtime validity, and behavioral plausibility.

The training results are equally central. After supervised fine-tuning Llama-3.1-8b on the verifier-filtered trajectories, the paper reports an average relative gain of 30.95% over the same model before training (Hu et al., 26 Dec 2025). On Text2World, the fine-tuned model raises executability from 27.7 to 44.6 and F1 AVG from 21.8 to 28.2. On CWMB, it improves overall accuracy from 0.3150 to 0.3754 and overall $x$8 from 0.2296 to 0.3197. On ByteSized32, it increases runnable-game rate from 0.1963 to 0.2812 and alignment score from 0.0837 to 0.1040. The ablations further show complementary component effects: removing the Unit Tester causes the largest raw correctness drop on CWMB, removing the Deep Researcher sharply reduces return, and removing the Simulation Tester substantially degrades behavior-level utility (Hu et al., 26 Dec 2025).

5. Position within adjacent world-model research

Agent2World belongs to a broader movement that shifts agent intelligence from isolated next-action prediction toward explicit modeling of external environments, but it occupies a specific niche within that movement. It generates symbolic world models; it does not primarily benchmark online acting, predict next observations, or synthesize training worlds at scale.

In GUI environments, Code2World predicts the next interface state by generating renderable HTML and then rendering it,

$x$9

so that agents can simulate one-step futures for navigation and action vetting (Zheng et al., 10 Feb 2026). In web environments, WAC uses a world model as a web-environment expert to guide candidate action generation and simulate one-step post-action observations before execution, with a judge model providing confidence scores and corrective feedback (Shen et al., 17 Feb 2026). These systems are world-model-based, but their output object is a predicted next state or consequence model, not a symbolic environment specification in PDDL or executable simulator code.

At the environment-construction level, Agent-World scales outward rather than inward. It mines thousands of real-world themes into executable databases and toolsets, retaining 1,978 environments and 19,822 tools, and couples multi-environment RL with a self-evolving arena that synthesizes fresh tasks to expose capability gaps (Dong et al., 20 Apr 2026). This is complementary to Agent2World: Agent-World focuses on scaling the training world, whereas Agent2World focuses on synthesizing a correct symbolic model for a specified world.

Digital-environment benchmarks make a similar distinction. AndroidWorld provides a dynamic Android environment with 116 tasks across 20 apps, world-state-based reward, and seeded initialization/teardown logic for reproducible online evaluation (Rawles et al., 2024). MobileWorld extends that benchmark style to 201 tasks across 20 applications, emphasizes long-horizon multi-app workflows, and adds first-class ask_user and mcp_call actions for user interaction and MCP-augmented execution (Kong et al., 22 Dec 2025). These works instantiate agents acting in runnable worlds, but they are evaluation arenas rather than symbolic world-model generators.

Taken together, the adjacent literature suggests a useful taxonomy. World-centered architectures supply the representational thesis that a shared explicit world should be primary (Mantsivoda et al., 1 Apr 2026); AndroidWorld and MobileWorld supply runnable digital worlds for evaluation; Code2World and WAC supply predictive world models for one-step imagination; Agent-World supplies scalable environment synthesis for training; Agent2World supplies symbolic world-model generation with execution-grounded repair. The niche is narrow but consequential: it sits exactly at the interface between natural-language specification and formal world construction.

6. Limitations, misconceptions, and future directions

Agent2World’s gains do not erase the difficulty of symbolic environment generation. The paper’s own analyses show that later-stage residual failures are often dynamics-related rather than merely syntactic, and continuous-control environments in CWMB remain materially harder than discrete ones (Hu et al., 26 Dec 2025). The framework also incurs higher token cost than simpler baselines because it adds proactive research, unit-test synthesis, simulation-based play-testing, and iterative repair. Its success further assumes access to an execution sandbox, search tools, testing infrastructure, and environment-play tools; it is therefore not a pure prompt-only method.

A common misconception is to treat Agent2World as equivalent to generic multi-agent context sharing or protocol orchestration. Adjacent protocol work argues instead that A2A and MCP are useful substrates for inter-agent coordination and tool access, but insufficient as a complete semantic mediation layer for scalable agent systems (Li et al., 6 May 2025). Other infrastructure proposals fill different gaps: OAN adds a protocol-neutral pre-connection trust layer with Root-governed identity admission, authorization-aware discovery, and signed trusted invocation (Xu, 2 Jun 2026), while AWCP addresses temporary workspace delegation so one agent can project its workspace to another for deep-engagement collaboration (Nie et al., 24 Feb 2026). This suggests that a production-grade Agent2World stack would require not only world-model synthesis, but also surrounding layers for trust, discovery, invocation governance, and workspace sharing.

Another misconception is to regard symbolic world-model generation as interchangeable with predictive next-state modeling. The comparison with Code2World and WAC shows that the two problems are related but not identical. Predictive world models help action selection by imagining future observations; Agent2World instead constructs the environment formalism itself. The distinction matters because planning systems need reusable, inspectable dynamics models, not only one-step lookahead.

The broader implication is that Agent2World should be read as a systems program rather than a single benchmark trick. It demonstrates that symbolic world-model generation improves when underspecification is researched, implementations are executed, and failures are diagnosed behaviorally rather than textually. Its most durable contribution is therefore methodological: world models should be generated under an explicit loop of research, implementation, execution, and repair.