TraceR1: Adobe’s RL framework for anticipatory agents that plan before moving
Reactive planning is betting on the next step. Anticipatory planning is mapping the whole path. TraceR1 shows that for tasks where early mistakes compound (computer-use, multi-tool orchestration, long-horizon GUI navigation) the difference in outcome is measurable, not theoretical.
TL;DR: TraceR1 trains agents to forecast multi-step trajectories before acting, using two-stage RL: first to optimize global trajectory consistency, then to refine executability with real tool feedback. Across 7 benchmarks, from AndroidWorld to GAIA, it improves on the executor or base model it is paired with by about 1 to 9 points, with the largest gains on OSWorld-Verified and the GAIA and GTA tool-use benchmarks.

The reactive planning problem: why early mistakes compound
Most agents running today work like this: observe the current state, reason about the next action, execute it, observe the new state, repeat. This is the ReAct loop, covered in depth in post 0014. It works well when tasks are short, or when the environment is unpredictable enough that any upfront plan would become stale within two steps.
The problem shows up on longer tasks. Consider a computer-use agent navigating a GUI to file an expense report. The agent has to open the right app, locate the correct form, fill fields in order, and submit. Each action eliminates options. Clicking into the wrong submenu may not cause an outright error. The agent might not realize the mistake until three steps later, when the context has drifted and recovery requires backtracking through UI state that’s no longer visible.
The core failure mode isn’t poor reasoning at any single step. Reactive agents have no representation of where the action sequence is going. They optimize for the current decision without a model of how that decision shapes the ones that follow. Per-step errors compound: an agent that gets each step right 95% of the time finishes a 20-step task without a mistake only about 36% of the time (0.95^20 ≈ 0.36).
This isn’t a problem MCTS solves at training time. MCTS explores branching futures at inference (covered in MCTS for agent planning). TraceR1 asks a different question: can you train a model to carry trajectory-level reasoning as an intrinsic capability, rather than invoking it as an external search procedure on every call?
What TraceR1 does: two-stage RL for trajectory forecasting
TraceR1 (arXiv:2603.16777) was published March 17, 2026 by researchers at Adobe Research alongside the University of Maryland, The Ohio State University, and SUNY Buffalo. TraceR1 is an 8B planner. Before each action, it generates a forecast of the next several actions it expects to take, then hands the first one to a separate, frozen executor such as UI-TARS or Qwen3-VL.
The framework is trained in two stages, each with a distinct reward signal.
Stage 1 is trajectory-level RL. The model learns to predict multi-step trajectories that match reference sequences. The reward combines an alignment score measuring similarity between predicted and reference actions (sim(â_t, a_t*)), and a repetition penalty for redundant steps. A temporal discount factor γ weights near-term predictions more heavily than distant ones, since uncertainty grows with forecast horizon. Stage 1 trains on offline reference trajectories without executing anything. After it, the model has learned to think several steps ahead as part of its normal reasoning process. (For more on how a trajectory-level reward gets spread across individual steps, see credit assignment in agentic RL.)
Stage 2 is grounded reinforcement fine-tuning. Stage 1 produces a model good at trajectory consistency but not necessarily grounded in what tools can actually execute. Stage 2 corrects this using binary rewards: coordinate matching for GUI actions, answer matching for tool calls, computed against execution feedback from frozen tool agents. The training objective is GRPO (group-relative policy optimization), normalizing rewards within a group of candidate trajectories. Ablations show removing Stage 2 costs roughly 6 points on average (AndroidWorld 64.8% to 57.2%, OSWorld-Verified 41.2% to 36.3%, GTA 56.7% to 50.2%). Stage 1 builds the planning capacity; Stage 2 anchors it to physical executability.
At inference, TraceR1 predicts the full trajectory τ_{t:T}, executes only the first action a_t, then re-plans from the new state. Plan ahead, act one step, replan. In the horizon ablation, success improves as the training horizon T grows, then drops noticeably beyond T=10: the model is forecasting too far into uncertain state space and the reward gets noisy.
Across the 7 benchmarks, TraceR1 is paired with different executors, so read each number against its own baseline:
| Benchmark | Setup | Without TraceR1 | With TraceR1 |
|---|---|---|---|
| AndroidWorld (success) | Qwen3-VL-32B-Thinking executor | 61.4% | 64.8% |
| OSWorld-Verified (success) | Qwen3-VL-32B-Thinking executor | 35.6% | 41.2% (15.7% relative) |
| AndroidControl-High (step success) | UI-TARS-7B executor | 72.5% | 75.3% |
| GUI-Odyssey (step success) | UI-TARS-7B executor | 87.0% | 88.2% |
| Multimodal-Mind2Web (step success) | UI-TARS-7B executor | 63.1% | 65.3% |
| GAIA (answer accuracy) | 8B model vs Qwen3-VL-8B | 31.5% | 40.2% |
| GTA (answer accuracy) | 8B model vs Qwen3-VL-8B | 49.2% | 56.7% |
The paper highlights AndroidControl-High, where it reports a margin of more than 40% over R1-style GUI agents. That holds against GUI-R1-7B (51.7%), but InfiGUI-R1-3B scores 71.1% in the same table and the UI-TARS-7B executor alone scores 72.5%, so the planner adds about 3 points there. The larger gains are on OSWorld-Verified and the GAIA and GTA tool-use benchmarks.
How it compares to ReAct, MCTS, and chain-of-thought planning
These three approaches are already in production at various levels of adoption. Where does TraceR1 fit?
ReAct interleaves reasoning traces with actions in a step-by-step loop. The agent sees an observation, produces a thought, produces an action, receives the next observation. There’s no trajectory representation: the “plan” is implicit in each reasoning trace and doesn’t extend beyond the current step. ReAct works fine when the environment is unpredictable and a fixed plan would become obsolete quickly. It breaks down on tasks requiring coherent multi-step strategy, because each step is optimized without awareness of downstream constraints.
Chain-of-thought planning adds an upfront decomposition step before acting. Better than pure ReAct for structured tasks, but the plan is generated by the model’s forward pass at inference time and never reinforced through execution feedback. There’s no training signal rewarding trajectories that cohere globally over ones that look reasonable step by step. CoT planning is static; TraceR1’s trajectory forecasting is trained against actual execution outcomes.
MCTS searches a tree of possible futures at inference time, branching on possible actions, evaluating outcomes, backtracking. Expensive per call: O(branching_factor × depth × node_evaluations) at inference. It works when you have a good value function and can afford the search budget. TraceR1 amortizes the trajectory reasoning into model weights at training time. One forecast per step at inference, then execute. TraceR1 is expensive to train and cheap to run; MCTS is cheap to train and expensive to run. They’re complementary rather than competing: you could run MCTS at inference on a TraceR1-trained base model.
One thing worth saying plainly: the comparison to CoT planning is the most important one for practitioners. Most teams adding “planning” to their agents are doing upfront CoT decomposition. TraceR1’s results show that planning trained via RL with execution feedback improves on the same models without it. The paper does not include a prompt-only planning baseline, so how much it beats upfront CoT decomposition is still an open question. The training is also harder to set up.
Adding anticipatory planning to an existing agent: an implementation sketch
TraceR1’s two-stage approach is a training pipeline, not a drop-in wrapper. The design principles still translate into practical patterns for engineers working with existing agents.
The two diagrams below show what changes when you switch from reactive to anticipatory:
Reactive (ReAct)
─────────────────────────────────────────────────
Obs_1 → Reason → Act_1 → Obs_2 → Reason → Act_2
[next] [next]
Anticipatory (TraceR1)
─────────────────────────────────────────────────
Obs_1 → Forecast [Act_1, Act_2, Act_3, ..., Act_T]
↓
Execute Act_1 → Obs_2 → Reforecast [Act_2', ..., Act_T']
↓
Execute Act_2' → ...
TraceR1 two-stage training process:
flowchart TD
A[Base VLM\ne.g. Qwen3-VL] --> B[Stage 1: Trajectory RL]
B --> C{Reward}
C -->|Alignment score\nsim â_t, a_t*| D[Trajectory consistency]
C -->|Repetition penalty\nλ_rep| D
C -->|Temporal discount\nγ ∈ 0,1| D
D --> E[Stage 1 Model\nglobal trajectory planner]
E --> F[Stage 2: Grounded Fine-tuning]
F --> G{Execution feedback\nfrom frozen tools}
G -->|GUI: coordinate match| H[Binary reward]
G -->|Tool: answer match| H
H --> I[GRPO optimization\ngroup-relative advantage]
I --> J[TraceR1\nAnticipatory agent]
J --> K[Inference: forecast τ_t:T\nexecute a_t, replan]
If you’re not running a training pipeline, the trajectory-forecasting concept maps to a prompt-level pattern: require the agent to output a predicted action sequence before executing any step, then evaluate the sequence for consistency before allowing execution. This is weaker than TraceR1’s trained capacity (no execution feedback in the reward signal) but approximates anticipatory reasoning at inference time with no retraining cost:
SYSTEM_PROMPT = """
Before taking any action, first output a trajectory forecast:
<trajectory>
Step 1: [action]
Step 2: [action]
...
Step N: [action]
</trajectory>
Then execute only Step 1. After observing the result, update the forecast and execute Step 2.
Trajectory horizon: 10 steps or fewer. If you cannot forecast more than 2 steps ahead with confidence, state this explicitly.
"""
For teams running RL fine-tuning on their own agents, the Stage 1 reward structure is the key contribution to replicate: trajectory alignment reward + repetition penalty + temporal discount. The discount factor γ is important: without it, the model gets equal credit for correct near-term and distant predictions, which destabilizes training when distant steps are uncertain.
Action = str # e.g. "click(submit_button)"
def similarity(a: Action, b: Action) -> float:
"""Placeholder: swap in action-type match or embedding cosine similarity."""
return 1.0 if a == b else 0.0
def trajectory_reward(predicted: list[Action], reference: list[Action], gamma: float = 0.9,
lambda_align: float = 1.0, lambda_rep: float = 0.5) -> float:
"""Discounted sum of per-step rewards, as in the paper:
r_t = lambda_align * sim(pred_t, ref_t) - lambda_rep * rep(pred_1..t)."""
total = 0.0
for t in range(min(len(predicted), len(reference))):
r_t = (lambda_align * similarity(predicted[t], reference[t])
- lambda_rep * repetition_penalty(predicted[:t + 1]))
total += (gamma ** t) * r_t
return total
def repetition_penalty(actions: list[Action]) -> float:
"""Penalize semantically redundant consecutive actions."""
if len(actions) < 2:
return 0.0
penalties = [
similarity(actions[i], actions[i-1])
for i in range(1, len(actions))
]
return sum(penalties) / len(penalties)
Stage 2 ground-truth rewards are task-specific: for GUI tasks, check pixel coordinates against reference; for tool-calling tasks, compare final answers. The GRPO objective normalizes rewards within a candidate group: run multiple rollouts, normalize by group mean and std, train toward the better ones.
The horizon ablation finding (performance drops beyond T=10) translates directly: don’t ask agents to plan 20 steps ahead. The forecast degrades into noise, and training on long-horizon predictions that are structurally unpredictable teaches the model nothing useful.
Frequently asked questions
What is TraceR1? A two-stage RL framework from Adobe Research and university collaborators (arXiv:2603.16777) that trains agents to forecast multi-step action trajectories before executing the first action. Evaluated on 7 benchmarks spanning computer-use and multimodal tool reasoning tasks.
How does TraceR1 differ from ReAct? ReAct interleaves reasoning and action one step at a time, with no forward trajectory plan. TraceR1 forecasts the full expected sequence before moving. The gap matters most on tasks where early decisions constrain later options and mistakes don’t surface until several steps downstream.
How does TraceR1 differ from MCTS? MCTS explores a branching tree of future states at inference time. TraceR1 bakes trajectory reasoning into the model weights through RL training. MCTS is expensive at inference; TraceR1 pays that cost at training time and amortizes it across all future runs. They’re complementary rather than competing. You could run MCTS at inference on a TraceR1-trained base model.
What benchmarks did TraceR1 improve on? With Qwen3-VL-32B-Thinking as executor: 64.8% on AndroidWorld and 41.2% on OSWorld-Verified (+15.7% relative). With UI-TARS-7B as executor: 75.3% on AndroidControl-High, 88.2% on GUI-Odyssey, 65.3% on Multimodal-Mind2Web. As an 8B model: 40.2% on GAIA (+8.7 points over Qwen3-VL-8B) and 56.7% on GTA. See arXiv:2603.16777 for full tables.
What trajectory horizon should I use? In the ablation, performance improves as the horizon grows and drops noticeably beyond T=10, where the model is forecasting into uncertain state space. A horizon of 10 steps or fewer is a sensible default.
TraceR1 paper: arXiv:2603.16777. Related: ReAct pattern deep dive · Planning and decomposition · Hierarchical planning