PaperlayerView exact revision on arXiv

Source-linked AI summary

AgentMercury: Your Agent Can Synthesize Verifiable Environments for Business Scenarios at scale

Minbyul Jeong, Chanwoong Yoon

arXiv:2608.20634v1cs.CLcs.AI

TL;DR

Training environments are often built around predefined tasks, limiting their representation of realistic workflows in which diverse tasks emerge from persistent context. AgentMercury synthesizes executable business worlds from high-level scenarios, and policies trained in them improve across enterprise and out-of-domain benchmarks while world authoring becomes learnable.

  • Problem

    Existing environments are often manually constructed or task-centric, leaving systematic construction of executable worlds for evolving workflows largely outside the learning loop.

  • Method

    AgentMercury constructs persistent executable business worlds from high-level scenarios, including entities, services, tools, state, transition structure, and executable invariants, then instantiates tasks within them.

  • Results

    Policies trained on 4,783 AgentMercury environments improve across enterprise workflows and out-of-domain reasoning, coding, scientific computing, knowledge, and tool-use benchmarks.

  • Takeaways & Limitations

    Scenario-grounded executable worlds can provide transferable learning signals beyond benchmark-specific training, while construction traces can supervise executable-world authoring.

  • Takeaways & Limitations

    The current system does not use a learned world model to identify policy capability gaps and generate the next most useful scenarios.

Abstract

from arXiv · show

Agents learn to act through interaction with environments, yet the environments used for training are often manually constructed or synthesized around predefined tasks and benchmarks. This task-centric paradigm makes it difficult to scale environments that reflect realistic and evolving workflows where diverse tasks can naturally emerge from the underlying world. We introduce AgentMercury, a scalable framework for synthesizing executable environments from high-level business scenarios. Rather than constructing an environment for a specific task, AgentMercury first instantiates a persistent world with entities, services, tools, state, and executable cross-service invariants, from which diverse tasks and interaction trajectories can subsequently emerge. We construct 4,783 executable environments spanning 14 industries and 50 countries, and use them as training substrates for reinforcement learning. Despite being generated without targeting the evaluation benchmarks, policies trained on these business-oriented environments improve substantially on both enterprise workflows and out-of-domain benchmarks spanning reasoning, coding, scientific computing, and tool use. In our experiments, Qwen3.5-4B improves from 12.3 to 15.7 on EnterpriseOps-GYM and from 45.9 to 56.0 on AIME26 after training on AgentMercury environments. We further show that the construction process itself can be learned: fine-tuning Qwen3.5-35B-A3B on construction traces increases executable-world authoring success from 3.3% to 83.3% on held-out business scenarios. These results show that scenario-grounded environments can provide useful and generalizable learning signals beyond benchmark-specific training, while their construction can itself become a learnable capability.

1 INTRODUCTION

AgentMercury reframes environment construction around persistent, scenario-grounded business worlds rather than isolated benchmark tasks. These executable worlds support diverse interactions and provide training substrates whose benefits extend beyond the tasks used to construct them.

  • Existing environments are commonly specified before learning begins, leaving systematic construction of executable worlds outside the agent learning loop.
  • Task-centric synthesis designs environments around predefined tasks, instructions, or evaluation specifications rather than evolving workflows.
  • AgentMercury constructs executable worlds from high-level business scenarios, instantiating entities, services, tools, persistent state, transition dynamics, and world-level invariants.
  • 4,783 executable environments span 14 industries and 50 countries, with persistent state, multiple services and tools, and executable cross-service constraints.
  • Policies trained with reinforcement learning in these environments improve on executable business tasks and on benchmarks beyond the environments’ construction targets.
  • Construction traces provide supervision for fine-tuning models to author executable worlds from previously unseen business scenarios.

2 PRELIMINARIES

The preliminaries distinguish policies, world models, and executable environments in the agent interaction loop. Policies choose actions, world models predict existing dynamics, and environments concretely define states, actions, transitions, and observations.

  • A policy π maps an agent’s available interaction history to a distribution over actions at each timestep.
  • World models predict subsequent states or observations from interaction histories and actions, supporting prediction, planning, or simulation.
  • An executable environment applies a transition function to the current state and action, then produces observations through an observation function.
  • Unlike a world model, an executable environment concretely determines possible states, actions, and responses using persistent data, services, tools, and transition logic.

3 METHOD

AGENTMERCURY separates executable-world construction from task specification, agent interaction, and deterministic evaluation. PLANET builds reusable business worlds whose structured state, services, transitions, and invariants support multiple tasks and reproducible trajectories.

  • PLANET: Scenario-to-world construction: PLANET transforms a high-level business scenario into a complete executable world rather than directly generating an individual task.The world includes entities, services, tools, persistent state, transition logic, and world-level invariants.
  • PLANET: Scenario-to-world construction: An executable world is represented by state, action, and observation spaces, executable transitions and observations, a seeded initial state, and world-level invariants.Invariants are checked through executable verification conditions rather than enforced by the transition mechanism.
  • PLANET: Scenario-to-world construction: World synthesis factorizes scenario grounding into company identity, service graph, and state schema, with the resulting graph and schema determining executable structure and dynamics.The invariant set is constructed separately from the world structure.
  • PLANET: Scenario-to-world construction: World-level invariants are distinct from transition rules: transitions update software state, while invariants specify cross-service conditions checked afterward.This lets agents remain responsible for satisfying requirements that the simulator does not automatically enforce.
  • Task instantiation from a world: Tasks are instantiated from an existing world using task-specific state seeding and a grading rubric, allowing multiple tasks to share world structure while starting from different states.The task rubric specifies task-level assertions, whereas world invariants describe properties of the underlying world.
  • Executable agent–environment interaction: During interaction, a policy acts from history, the environment deterministically updates its state, and observations enter the history through the observation channel.Fixed initial seeds and action sequences make trajectories reproducible and replayable for deterministic evaluation.
  • Policy learning on synthesized worlds: AGENTMERCURY separates world authoring, task objectives, policy actions, environment responses, and deterministic grading so one world distribution can support multiple training configurations.The framework uses the executable environment itself for transition dynamics rather than training a separate world model.

4 EXPERIMENTS

AGENTMERCURY environments improve enterprise workflows and diverse out-of-domain capabilities, with gains emerging progressively during training and authoring becoming learnable from construction traces. The experiments also expose limits: cross-service structural constraints remain a concentrated failure mode.

  • Policy optimization of business-oriented tasks: 12.3 to 15.7: Qwen3.5-4B+GRPO+OURS improves the ENTERPRISEOPS-GYM average score over the base model, with gains across seven of eight domains.Drive and Email each improve by +9.4, while CSM decreases from 9.2 to 5.6.
  • Policy optimization of business-oriented tasks: 28.3 versus the base model: Qwen3.5-35B-A3B with SAO improves the ENTERPRISEOPS-GYM average by +3.5 points (+14.1%) across all eight domains.The corresponding GRPO result is 28.1, a +3.3-point (+13.3%) improvement.
  • Policy optimization of benchmark-oriented tasks: 45.9 to 56.0 on AIME26: Qwen3.5-4B+GRPO+OURS improves across mathematical reasoning, coding, scientific computing, tool use, and agentic benchmarks.Telecom remains largely unchanged, indicating that transfer is not uniform across benchmarks.
  • Policy optimization of benchmark-oriented tasks: The out-of-domain gains emerge progressively across training checkpoints rather than being concentrated at a single checkpoint.AIME26 rises from the base score of 45.9 to approximately 56.0 as policy optimization proceeds.
  • Training dynamics: Increasing reward, decreasing truncation, and near-zero degeneration accompany policy improvement, indicating no substantial response collapse or pathological generation.Response length initially increases as the policy learns more complex multi-step tasks before decreasing later in training.
  • Failure analysis: Cross-service structural constraints remain a central authoring failure mode, including invariants whose trigger and target are incorrectly placed within one service.The executable oracle and cross-service validators are therefore essential because syntactic validity alone may not reveal the structural violation.
  • Learning the authoring process: 83.3%: fine-tuning Qwen3.5-35B-A3B on 29,823 construction samples raises full-oracle authoring success from 3.3% on held-out briefs.The improvement is statistically significant, with Fisher exact test p = 1.2 × 10−10.
  • Learning the authoring process: Recipe conditioning can help the base model but reduce the fine-tuned model’s authoring success from 83.3% to 10.0%.For the fine-tuned model, 27 of 30 recipe-conditioned generations fail cross-service validation.

5 DISCUSSION AND CONCLUSION

AgentMercury argues that scaling diverse, persistent business worlds can transfer learning beyond benchmark-specific tasks, while environment construction itself becomes learnable. The current system, however, does not yet adapt synthesis using a learned world model or policy capability gaps.

  • Discussion: AgentMercury generates business-grounded environments independently of evaluation tasks, yet policies improve on enterprise and out-of-domain benchmarks.The out-of-domain benchmarks span mathematical reasoning, coding, scientific computing, knowledge-intensive reasoning, and tool use.
  • Discussion: Environment scaling can emphasize diversity, structure, and realism of persistent worlds rather than increasing benchmark-specific task instances.Business scenarios provide long-horizon interactions, heterogeneous tools, persistent state, and cross-service constraints.
  • Discussion: PLANET separates world construction, task specification, and policy optimization, allowing one world distribution to support varied tasks and trajectories.This framing treats world construction as a potentially first-class component of agent systems.
  • Discussion: GRPO and SAO show complementary scaling behavior: GRPO provides a stronger relative signal for smaller policies, while SAO may broaden coverage at larger scales.The comparison is reported as a potential environment-learning trade-off rather than a universal optimization rule.
  • Limitations and future work: The current system does not use a learned world model to identify capability gaps and synthesize the next most useful scenarios.A future adaptive curriculum would connect policy failures and uncertainties to targeted world generation.
  • Conclusion: The paper concludes that scenario-grounded environments can serve as scalable policy-training substrates and structured supervision for learning executable-world construction.The reported scope includes 4,783 environments across 14 industries and 50 countries.

A SYNTHESIZED & SAMPLED TASKS

AgentMercury constructs executable worlds first and samples multiple seeded investigation tasks from each world. The resulting corpus combines broad structural coverage with deterministic, state-based verification and separates world expansion from task generation.

  • Task instantiation: A synthesized world supports multiple tasks by varying seeded state, user intent, and task rubric without changing the underlying world structure.This separates task-specific objectives and initial conditions from persistent world dynamics.
  • Overview: Figure 5 summarizes the corpus, sampled training footprint, and lifecycle from scenario-grounded world construction through verification and reward optimization.Its lifecycle separates world construction from task sampling so one environment can support multiple seeded tasks.
  • Corpus composition: 43,300 tasks are drawn from 4,326 executable company environments spanning 2,287 industries, 842 tools, 222 state-table types, and 148 service combinations.Each environment has 10 sampled task seeds; environments expose 10–26 tools and tasks touch 1–5 services.
  • Task structure: Tasks combine company environments, personas, investigation objectives, executable tools, and programmatic state-based verification.Completion is checked through assertions over the resulting database state, including record existence, field equality, and field inequality.
  • RL sampling: 3,200 tasks received gradients over 200 training steps, representing 7.4% of the corpus while spanning 2,313 environments, 1,438 industries, 638 tools, 137 state tables, and 93 service combinations.The sampled subset was drawn from a shuffled task stream rather than manually selected.
  • Training diversity: The training footprint remains a broad cross-section of synthesized worlds because tasks are sampled after world construction.This allows expansion through new worlds, business structures, service combinations, initial states, and objectives without manually constructing an environment per task.

A.1 TASK DIVERSITY

Task diversity is expressed more strongly through executable tool structure than through task-description language. The corpus combines broad global variation with local near-duplicates that are not explained mainly by within-environment seed replication.

  • Textual structure: Textual t-SNE clusters do not correspond to meaningful metadata partitions, indicating that lexical variation is a poor proxy for task-level diversity.Cluster compositions remain similar across domain, persona, AF flag, exposed tools, and source shard.
  • Executable structure: Tool-set projections form clearly separated domain-specific clusters, making executable tool surfaces the dominant source of meaningful task variation.CRM, billing, project management, and support tasks form distinct regions in tool space.
  • Local similarity: The corpus has mean pairwise TF-IDF similarity 0.13, median nearest-neighbor similarity 0.83, and 8.3% of tasks with a nearest neighbor above 0.99.These statistics indicate broad global variation alongside a substantial population of near-twin tasks.
  • Redundancy source: Only 17% of near-twin pairs come from the same environment, versus an expected 78% if seed replication primarily caused the redundancy.The observed pattern points to shared task templates across different environments.
  • Combinatorial structure: Exposed tool counts take five values—10, 14, 18, 22, and 26—because each added resource contributes four search, list, get, and update operations.The structure begins with a fixed core of ten employee, email, and Slack tools.

B HYPERPARAMETER DETAILS

The training setup combines asynchronous executable-environment rollouts, verified rewards, and GRPO optimization for long-horizon tool-use trajectories. SAO is also evaluated, but its learning signal is substantially weaker for the 4B policy.

  • Configuration overview: The configuration is organized around model and memory, rollout execution, environment interaction, and policy optimization with reward computation.These settings target practical long-horizon interaction while preserving a rich learning signal.
  • Rollout and execution: Training uses two actor GPUs and six rollout GPUs on one node, with fully asynchronous optimization overlapping policy updates and environment rollouts.The setup permits up to 64 concurrent requests and caps policy staleness at four updates.
  • Executable environments: Each rollout interacts with a local executable MCP environment for up to 20 tool-use turns and 8,192 generated tokens per turn.Local in-process execution avoids network overhead during training.
  • Reward computation: Rewards are computed from the final environment state and agent trajectory, with behavior penalties and safeguards against repetition, continuation, and degeneracy.The reward configuration uses executable verification rather than static instruction-following alone.
  • GRPO optimization: The main Qwen3.5-4B experiments use GRPO with eight samples per prompt, global batch size 128, and rollout batch size 16.Zero-variance reward groups are filtered because they provide no relative learning signal.
  • Training corpus: The training corpus contains 43,300 executable tasks sampled from the synthesized environment library rather than constructed for downstream benchmark evaluations.The same corpus is used throughout RL training.
  • SAO comparison: SAO provides a substantially weaker learning signal for Qwen3.5-4B, so its run is excluded from the primary main-table comparison.The corresponding dynamics are reported separately rather than treated as evidence against the environment distribution.

C BENCHMARK DETAILS

The benchmark suite evaluates reasoning, coding, scientific computing, and interactive tool use with primarily programmatic verification and repeated sampling.

  • Mathematical reasoning: AIME 2026 evaluates 30 competition-level mathematics problems using avg@10 exact-match accuracy over 300 sampled attempts per run.
  • Coding: LiveCodeBench v5–v6 evaluates newly introduced programming problems through hidden-test execution and reports pass@1 correctness.
  • Scientific computing: SciCode measures scientific computing across physics, chemistry, biology, and materials science using executed code against reference implementations and H5 datasets.
  • Interactive tool use: Tau-3 evaluates multi-turn airline, retail, and telecom tool-use interactions through four trials per task and average pass1 reward.
  • Interactive tool use: BFCL measures structural tool-call precision, including functions, arguments, and argument types, using AST matching and executable verification.
  • Enterprise workflows: ENTERPRISEOPS-GYM covers eight business domains and counts success only when all task-specific verifiers pass in its oracle setting.

D TRAINING LOG

Training diagnostics show reward improvement alongside fewer truncated responses and negligible degenerate outputs for both GRPO and SAO.

  • GRPO: GRPO reward rises from around 0.4 to approximately 0.55-0.60 while truncation falls from roughly 0.35 to nearly zero.
  • GRPO: GRPO response length peaks mid-training and later decreases, while reward continues improving rather than simply tracking longer responses.
  • SAO: SAO reward increases from approximately 0.35 to above 0.6 as truncation decreases from approximately 0.4 to around 0.05.
  • SAO: SAO response length first decreases, reaches a mid-run minimum, and then increases substantially during later training.
  • Overall pattern: Both optimization methods improve reward while reducing severe generation failures, with degenerate-response ratios remaining near zero.

E ADDITIONAL DETAILS ON ENVIRONMENT AUTHORING

The authoring study tests whether executable-world construction can be learned from construction traces, using held-out briefs and a strict 12-validator oracle.

  • Protocol: The study evaluates zero-shot authoring and fine-tuned authoring from 30 held-out high-level business briefs.
  • Evaluation: The 12-validator oracle counts success only when every structural validator passes, requiring an executable world rather than textual similarity.
  • Results: 83.3% oracle-pass rate after fine-tuning rises from 3.3% before fine-tuning, with average validator coverage reaching 11.5 of 12.
  • Failure modes: Cross-service invariants are the dominant zero-shot failure mode, including constraints whose trigger and target are incorrectly placed within one service.
  • Supervision: Training uses 29,823 construction-trace samples spanning brief-to-world generation, intermediate completion, corruption repair, and intent-to-diff prediction.
  • Prompting versus learning: Recipe conditioning raises the base model from 3.3% to 20.0% but lowers the fine-tuned model from 83.3% to 10.0%.
  • Prompting versus learning: The fine-tuned model performs best with the original high-level brief alone, indicating construction behavior is internalized rather than merely instruction-following.
Loading 2608.20634v1…