菜单
Train autoregressive world models on 1M+ real web interactions for accurate browser state prediction. Enables agent training with 100× more data than prior approaches, achieving GPT-4o comparable performance with format flexibility and cross-domain generalization.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/ADu2021/skillXiv --skill webworld命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
正在显示 SKILL.md
| name | webworld |
| title | WebWorld: A Large-Scale World Model for Web Agent Training |
| version | 0.0.2 |
| engine | skillxiv-v0.0.2-claude-opus-4.6 |
| license | MIT |
| url | https://arxiv.org/abs/2602.14721 |
| keywords | ["World Models","Web Agents","Simulation","Large-Scale Training Data","Generalization"] |
| description | Train autoregressive world models on 1M+ real web interactions for accurate browser state prediction. Enables agent training with 100× more data than prior approaches, achieving GPT-4o comparable performance with format flexibility and cross-domain generalization. |
Web agent training requires massive interaction data that's expensive or impossible to collect at scale. Existing web world models use sandbox or closed environments with limited realism. Data scarcity forces agents to overfit to specific websites. Prior approaches generated only 10K-100K trajectories. Standard models trained on such small datasets don't capture real web complexity, limiting agent performance and generalization.
WebWorld is a large-scale autoregressive world model trained on over 1 million real-world web interaction trajectories. Rather than generating synthetic data or using sandboxes, it learns from authentic web behavior patterns. The key innovation: collecting data through three complementary strategies (randomized crawling, autonomous exploration, task-oriented execution) creates diverse, realistic training distributions.
The model predicts next browser state given instruction and interaction history, enabling agents to train entirely in simulation. Multiple format support (A11y Trees, HTML, XML, Markdown) and explicit reasoning injection through chain-of-thought enable strong generalization to code, GUI, and game environments.
Three-level hierarchical data collection:
class HierarchicalDataCollection:
"""
Collect web interactions through three complementary strategies
to create diverse, large-scale training dataset.
"""
def __init__(self):
self.trajectories = []
self.stats = {
: ,
: ,
:
}
():
()
traj_idx (num_trajectories):
website = random.choice(corpus_websites)
browser = WebBrowser()
browser.navigate(website)
trajectory = {
: website,
: [],
:
}
step (random.randint(, )):
action = sample_random_action(browser)
before_state = browser.get_state()
browser.perform_action(action)
after_state = browser.get_state()
interaction = {
: action,
: before_state,
: after_state
}
trajectory[].append(interaction)
.trajectories.append(trajectory)
.stats[] +=
(traj_idx + ) % == :
()
():
()
traj_idx (num_trajectories):
website = random.choice(websites)
agent = AutonomousExplorer()
objective = agent.generate_objective()
trajectory = {
: website,
: objective,
: [],
:
}
step (random.randint(, )):
browser_state = get_browser_state()
action = agent.decide_action(browser_state, objective)
before_state = browser_state
perform_web_action(action)
after_state = get_browser_state()
interaction = {
: action,
: before_state,
: after_state
}
trajectory[].append(interaction)
agent.is_objective_achieved():
trajectory[] =
.trajectories.append(trajectory)
.stats[] +=
(traj_idx + ) % == :
()
():
()
traj_idx (num_trajectories):
task = random.choice(task_corpus)
website = task[]
instruction = task[]
trajectory = {
: website,
: instruction,
: [],
: ,
:
}
step (max_steps := ):
before_state = get_browser_state()
action = decide_task_action(before_state, instruction)
perform_web_action(action)
after_state = get_browser_state()
interaction = {
: action,
: before_state,
: after_state
}
trajectory[].append(interaction)
check_task_completion(after_state, task):
trajectory[] =
.trajectories.append(trajectory)
.stats[] +=
(traj_idx + ) % == :
()
():
{
: (.stats.values()),
: .stats,
: .compute_diversity()
}
():
websites = ()
traj .trajectories:
websites.add(traj.get())
(websites) / (.trajectories)
Autoregressive world model architecture:
class AutoregressiveWorldModel(nn.Module):
"""
Predict next browser state given current state and action.
Trained on 1M+ real web interaction trajectories.
"""
def __init__(self, vocab_size, hidden_dim=2048, num_layers=24,
model_size='14B'):
super().__init__()
self.hidden_dim = hidden_dim
self.model_size = model_size
# Transformer backbone for state prediction
self.backbone = TransformerLM(
vocab_size=vocab_size,
hidden_dim=hidden_dim,
num_layers=num_layers,
num_heads=32
)
# Action encoder
self.action_encoder = nn.Embedding(num_actions := 1000,
hidden_dim)
def predict_next_state(self, current_state, action,
interaction_history, format='html'):
"""
Predict next browser state in specified format.
Supports A11y Trees, HTML, XML, Markdown.
"""
# Tokenize current state
state_tokens = tokenize_state(current_state, format)
# Encode action
action_embedding = self.action_encoder(action)
# Append action to state sequence
full_sequence = torch.cat([
state_tokens,
action_embedding.unsqueeze(0)
], dim=0)
# Generate next state tokens autoregressively
with torch.no_grad():
logits = self.backbone(full_sequence)
# Sample next state tokens
next_state_tokens = sample_next_tokens(
logits, temperature=0.7, max_tokens=512)
# Decode tokens to state
next_state = decode_state(next_state_tokens, format)
return next_state
def generate_trajectory(self, initial_state, instruction,
max_steps=30, format='html'):
"""
Generate complete trajectory given initial state and instruction.
"""
trajectory = {
'initial_state': initial_state,
'instruction': instruction,
'interactions': [],
'states': [initial_state]
}
current_state = initial_state
for step in range(max_steps):
# Decide action based on instruction and current state
action = decide_action(current_state, instruction)
# Predict next state
next_state = self.predict_next_state(
current_state, action, trajectory['interactions'],
format=format)
trajectory['interactions'].append({
'action': action,
'from_state': current_state,
'to_state': next_state
})
trajectory['states'].append(next_state)
current_state = next_state
return trajectory
Chain-of-thought synthesis for reasoning:
class ReasoningInjection:
"""
Inject explicit reasoning through chain-of-thought synthesis.
Improves reasoning capability without requiring massive annotation.
"""
def __init__(self, cot_generator, sample_size=1000):
self.cot_gen = cot_generator
self.sample_size = sample_size
def inject_reasoning_into_dataset(self, trajectories):
"""
Add CoT reasoning to subset of trajectories.
Improves reasoning without expensive full annotation.
"""
# Sample subset for CoT synthesis
sample = random.sample(trajectories, self.sample_size)
annotated_trajectories = []
for traj in sample:
# Generate reasoning for trajectory
state = traj['interactions'][0]['before_state']
action = traj['interactions'][0]['action']
# Generate CoT explanation
reasoning = self.cot_gen.explain_action(
state, action, traj.get('instruction', ''))
# Add reasoning to trajectory
annotated_traj = copy.deepcopy(traj)
annotated_traj['reasoning'] = reasoning
annotated_trajectories.append(annotated_traj)
return annotated_trajectories
Multi-format state representation:
class MultiFormatStateRepresentation:
"""
Support multiple state formats for flexibility.
Enables transfer to code, GUI, game environments.
"""
@staticmethod
def state_to_a11y_tree(dom_tree):
"""Convert DOM to accessibility tree (high-level structure)."""
a11y = {
'type': 'root',
'children': [],
'text': ''
}
# Traverse DOM and build accessibility structure
return a11y
@staticmethod
def state_to_html(dom_tree):
"""Convert to HTML representation."""
return dom_to_html_string(dom_tree)
@staticmethod
def state_to_markdown(dom_tree):
"""Convert to readable Markdown."""
markdown = []
for element in traverse_dom(dom_tree):
if element.tag == 'h1':
markdown.append(f"# {element.text}")
elif element.tag == 'button':
markdown.append(f"[Button: {element.text}]")
return '\n'.join(markdown)
@staticmethod
def state_to_xml(dom_tree):
"""Convert to XML representation."""
return dom_to_xml_string(dom_tree)
When to use:
Data collection strategy:
Level 1 (Randomized): 60-70% of total
Level 2 (Autonomous): 10-15% of total
Level 3 (Task-Oriented): 20-30% of total
Model sizing recommendations:
Format selection:
Reasoning injection:
Expected performance:
Training considerations:
Agent fine-tuning on WebWorld:
Large-scale autoregressive world models trained on authentic web interactions enable efficient agent training in simulation. By combining randomized, autonomous, and task-oriented data collection with multi-format representation and reasoning injection, WebWorld creates a generalizable training environment that captures real web complexity at scale.
基于 SOC 职业分类
