Automated Environment Synthesis for Agent Training
Listen to the summary
Uses a voice available on your device
Audio options
On this page 5 sections
Related concepts 5 concepts
Key Takeaways
- AgentMercury enables the automated synthesis of executable environments for training agent policies.
- Training on AgentMercury environments improved Qwen3.5-4B performance on EnterpriseOps-GYM from 12.3 to 15.7.
- Fine-tuning Qwen3.5-35B-A3B on construction traces boosted authoring success from 3.3% to 83.3% on held-out scenarios.
- The approach also demonstrated gains in general reasoning, with Qwen3.5-4B improving from 45.9 to 56.0 on the AIME26 benchmark.
Summary & Methodology Analysis
AgentMercury provides a pipeline for generating executable environments that simulate business workflows. By providing a high-level brief, the system instantiates an environment that includes services, tools, and persistent state. The agent acts within these environments through tool calls, enabling deterministic evaluation of its performance based on predefined rubrics and hidden invariants. This automated synthesis allows for large scale generation of training data without manual environment construction.
Interactive System Flowchart
Illustrative Implementation
A short sketch of the paper's core idea, not the authors' own code.
# Illustrative sketch (not from the paper)
import torch
from typing import Dict, Any
def instantiate_world(scenario: str) -> Dict[str, Any]:
# create entities, services, tools, state, dynamics, invariants
return {"state": {}, "invariants": []}
def generate_task(world: Dict) -> Dict:
# derive user objective and rubric from world
return {"objective": "process invoice", "rubric": {"steps": 3}}
def agent_step(state: Dict, action: str) -> Dict:
# deterministic transition (placeholder)
new_state = state.copy()
new_state[action] = True
return new_state
def evaluate_trajectory(trajectory: list, rubric: Dict, invariants: list) -> float:
# deterministic grading using final state
return 1.0 if all(trajectory[-1].get(k) for k in rubric["steps"]) else 0.0
# Fine‑tuning on construction traces (illustrative)
def fine_tune_author(model, traces):
optimizer = torch.optim.Adam(model.parameters(), lr=1e-4)
for trace in traces:
loss = model(trace["input"]).loss(trace["target"])
loss.backward()
optimizer.step()
optimizer.zero_grad()// Illustrative sketch (not from the paper)
const torch = require('torch'); // placeholder
function instantiateWorld(scenario) {
return { state: {}, invariants: [] };
}
function generateTask(world) {
return { objective: 'process invoice', rubric: { steps: 3 } };
}
function agentStep(state, action) {
const ns = { ...state, [action]: true };
return ns;
}
function evaluateTrajectory(traj, rubric) {
const final = traj[traj.length - 1];
return rubric.steps.every(s => final[s]) ? 1.0 : 0.0;
}
async function fineTuneAuthor(model, traces) {
const opt = new torch.optim.Adam(model.parameters(), { lr: 1e-4 });
for (const t of traces) {
const loss = model(t.input).loss(t.target);
loss.backward(); opt.step(); opt.zeroGrad();
}
}Cross-Examination & FAQs
A deeper dive clarifying mechanics, constraints, and baseline evaluations.
Q1. What is the primary goal of AgentMercury?
The goal is to provide a scalable way to automatically synthesize executable environments for training agents on complex business scenarios.
Q2. How does this benefit agent development?
It allows developers to move away from manually constructed environments and instead use synthesized ones, which improves performance and scalability.
Q3. Does this method work for general reasoning tasks?
Yes, testing on the AIME26 benchmark showed performance improvements from 45.9 to 56.0 for the Qwen3.5-4B model.
Q4. Which models were used in the experiments?
The researchers used Qwen3.5-4B and Qwen3.5-35B-A3B as the primary training models.
Q5. What is the result of fine-tuning on construction traces?
Fine-tuning Qwen3.5-35B-A3B on these traces increased the executable-world authoring success rate from 3.3% to 83.3% on held-out business scenarios.
Q6. What benchmarks were used to validate the approach?
The authors utilized EnterpriseOps-GYM for agent training and evaluation, along with AIME26 for measuring broader knowledge and reasoning abilities.
Q7. Does the system use a learned world model?
No, the current synthesis process does not employ a learned world model to predict how candidate worlds behave under agent interaction.
Q8. How is the agent performance evaluated?
Performance is measured by training policies in the synthesized environments and evaluating them on the EnterpriseOps-Gym benchmark.
Q9. What are the current limitations of AgentMercury?
The system lacks a learned world model to actively adapt environment synthesis based on policy failures.