🤖 AI

Workspace Optimization: How to Train Your Agent

This paper introduces "workspace optimization," a training paradigm that evolves an agent's structured external substrate instead of its weights, and demonstrates its effectiveness through DreamTeam, a multi-agent system that achieves a new state-of-the-art score of 38.4% on the ARC-AGI-3 benchmark while using fewer actions.

Original authors: Elad Sarafian, Gal Kaplun, Ron Banner, Daniel Soudry, Boris Ginsburg

Published 2026-05-12

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Elad Sarafian, Gal Kaplun, Ron Banner, Daniel Soudry, Boris Ginsburg

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Problem: The "Frozen Brain"

Imagine you drop a person into a brand-new video game. They have no instructions, no map, and no idea what the buttons do.

The Catch: This person has a "frozen brain." You cannot teach them new things by rewiring their neurons (which is how standard AI training works). They can't learn by changing their internal code.
The Challenge: They still need to win the game. They have to figure out the rules, the goals, and the strategy just by playing.

Most AI agents try to "learn" by changing their internal weights (like a student memorizing a textbook). But if the AI is locked behind an API (like a chatbot) or if we can't touch its code, we can't change its brain. So, how does it learn?

The Solution: The "Workbench" (Workspace Optimization)

The authors argue that instead of changing the agent's brain, we should change its workbench.

Think of the agent as a master carpenter with a frozen set of skills (the brain).

Standard Training: You try to rewire the carpenter's hands to hold the hammer differently. (Impossible here).
Workspace Optimization: You give the carpenter a workbench where they can write notes, draw diagrams, build prototypes, and leave sticky notes for their future self.

The agent doesn't change who it is; it changes what it has written down. It reads its notes, tries a move, sees what happens, and then edits the notes to reflect the new reality.

How It Works: The "Dream Team"

To test this, the researchers built a multi-agent system called DREAMTEAM. Imagine a construction crew working on a single project, each with a specific job and a specific notebook:

The Observer (The Eyes): Looks at the game screen and writes down what they see in a structured format (e.g., "There is a red block at coordinates 5,5").
The Simulator (The Brain's Prediction Engine): Takes the Observer's notes and predicts what will happen next. "If I move left, the red block will move left."
The Explorers (The Testers):
- Inductive Explorer: Tries to find reusable strategies (e.g., "Always avoid red blocks").
- Transductive Explorer: Runs specific experiments to learn unknown rules (e.g., "Let's touch the blue tile just to see what happens").
The Critic (The Quality Control): Checks everyone's work. "Wait, the Simulator predicted the block would move, but it didn't. Who wrote that wrong rule?"
The Team Leader (The Boss): Decides the final move based on all the notes and predictions.

The Learning Loop: "Commit, Act, Compare, Repair"

Here is the cycle the team goes through, step-by-step:

Commit: The Team Leader makes a move based on the current notes.
Act: The move happens in the game.
Compare: The team looks at the result. Did the Simulator's prediction match reality?
- If yes: Great! The notes are confirmed.
- If no: This is a counterexample. The prediction was wrong.
Repair: The Critic identifies who wrote the wrong note.
- If the Observer misidentified the object, the Observer edits their notes.
- If the Simulator predicted the wrong physics, the Simulator rewrites its rule.
Regression Test (The Safety Net): Before the new note is accepted, the team runs a quick check against past moves. "If we change this rule now, does it break the logic we used 10 steps ago?" If it breaks old logic, the team knows they need to be more careful.

The Analogy: The Detective's Case File

Imagine a detective solving a mystery where the rules of the crime change every day.

The Detective (The AI Model): Has a fixed personality and knowledge base. They can't suddenly become a different person.
The Case File (The Workspace): A folder of whiteboards, sticky notes, and diagrams.
The Process:
- The detective makes a theory: "The butler did it."
- They test it. It fails.
- Instead of changing their personality, they go to the Case File. They cross out "The butler" and write "The gardener, but only on Tuesdays."
- They check the file to make sure this new theory doesn't contradict the alibi they wrote down yesterday.
- The file is now smarter, even though the detective is the same person.

The Results

The researchers tested this on ARC-AGI-3, a very hard benchmark of abstract reasoning games where the rules are hidden.

The Score: Their "Workbench" approach improved the score from 36% to 38.4% compared to the previous best method.
Efficiency: They didn't just get a higher score; they did it using 31% fewer moves. This means the agent was less "clumsy" and didn't waste time guessing randomly. It learned faster by organizing its notes better.

Why This Matters

This paper proves that you don't need to retrain a giant AI model to make it smarter in a specific situation. You just need to give it a better structured workspace to store its learnings, test its theories, and fix its mistakes in real-time.

It turns the "frozen" AI into a dynamic learner by treating its notes and code as the thing that gets trained, rather than its brain.

Technical Summary: Workspace Optimization

Problem Statement

Modern agents built on frontier language models (LLMs) often face a critical limitation: they cannot adapt their internal weights during an episode. Fine-tuning is too slow for online, single-episode adaptation, and in many deployment scenarios (e.g., API-based models or privacy-sensitive traces), weight access is unavailable. Consequently, the model remains fixed, yet the agent must still learn to solve complex, multi-turn tasks where the goal and rules are hidden within the environment.

The paper identifies a gap in standard agentic learning paradigms. Traditional reinforcement learning (RL) relies on updating a policy or value function (weight space) based on loss signals. However, when weights are frozen, the "trainable state" is undefined. The authors argue that the agent's workspace—the structured external substrate it reads, writes, and tests—should be the object of adaptation. This is particularly relevant for benchmarks like ARC-AGI-3, where agents must discover game mechanics, goals, and dynamics through interaction within a strict action budget, without offline data or the ability to rewind steps.

Methodology: Workspace Optimization

The paper proposes Workspace Optimization, a framework where a frozen-model agent adapts by editing a mutable, structured workspace rather than its parameters. This approach mirrors the computational structure of weight-space training but substitutes key components:

Artifacts replace parameters.
Evidence replaces training data.
Counterexamples replace loss functions.
Textual feedback replaces gradients.

The Trainable State

The agent is modeled as a tuple $(M, H)$ , where $M$ is a frozen language model and $H$ is a harness providing tools and a sandbox. The workspace $W_t$ at step $t$ consists of:

Programs ( $P_t$ ): Reusable, executable artifacts (e.g., observation parsers, dynamics simulators, strategies).
Logs ( $L_t$ ): Summaries, hypotheses, abandoned candidates, and unresolved questions.
Trace Data ( $D_t$ ): An append-only dataset of observations, actions, rewards, and counterexamples.

The learning loop operates as follows:

Action & Prediction: The agent reads $W_t$ and $D_t$ to select an action $a_t$ . It commits to a prediction (e.g., "moving left will result in state $z_{t+1}$ ").
Evaluation: Upon receiving the next observation $o_{t+1}$ , the harness compares the prediction against reality.
Feedback & Routing: If a prediction fails, the error is not a scalar loss but a counterexample routed to the specific artifact (interface) responsible for the failure. This solves the credit assignment problem by addressing which artifact to edit rather than how much to update a weight.
Repair & Regression: The responsible role edits its artifact (e.g., patching a Python function). Crucially, the harness maintains a regression set ( $R_t$ ) of past transitions. The new patch is replayed against this set to ensure it does not break previously solved cases before being accepted.

DREAMTEAM Architecture

The authors instantiate this framework in DREAMTEAM, a multi-agent harness for ARC-AGI-3. The system decomposes the agent into six roles, each owning a specific "surface" (typed slot) in the workspace:

Observer: Parses raw observations into structured state ( $z_t$ ) and owns the rendering logic.
Simulator: Tracks hidden state ( $h_t$ ) and owns the dynamics model (predicting next states).
Inductive Explorer (IE): Maintains a library of reusable strategies and sub-goals.
Transductive Explorer (TE): Proposes information-seeking probes when the world model is immature.
Critic: Audits artifacts, routes failures to their owners, and flags regressions.
Team Leader (TL): Arbitrates proposals and commits the final action.

The system employs a commit-then-retrodict loop. The Simulator commits to a dynamics program; if the next observation contradicts the prediction, the Simulator patches the code. The Critic ensures that patches are consistent with prior evidence via the regression set. Early in a game, the system favors probing (TE) to reduce uncertainty; as the world model stabilizes, control shifts to model-based planning (IE/TL).

Key Contributions

Workspace Optimization Framework: A formalization of adapting frozen-model agents by editing a structured workspace of typed artifacts. This recasts credit assignment as an addressing decision (which artifact to edit) rather than a gradient update.
DREAMTEAM: A multi-agent implementation of this framework, featuring a DreamerV3-inspired architecture where roles own observation, dynamics, strategy, probing, critique, and arbitration.
Efficient State-of-the-Art Performance: On the 25-game ARC-AGI-3 public set, DREAMTEAM achieves a 38.4% RHAE (Relative Human Action Efficiency), surpassing the previous protocol-matched baseline of 36%. Notably, it achieves this while using 31% fewer environment actions per game (444 vs. 643), demonstrating superior planning efficiency.

Results

Performance: Averaged over two independent runs, DREAMTEAM reached 38.4% RHAE on the ARC-AGI-3 public set, compared to Symbolica's Agentica SDK baseline of 36.08%.
Efficiency: The system required significantly fewer actions to solve levels. On successfully solved levels, DREAMTEAM averaged 54.1 actions per level versus 100.1 for the baseline.
Action Budget: The system stays ahead of a matched-budget human reference for the first ~5 hours of a 24-hour run, though the human eventually pulls ahead due to stronger cross-level transfer capabilities that the current system rebuilds at each transition.

Significance and Claims

The paper claims that Workspace Optimization opens a research agenda parallel to decades of weight-space learning, specifically for settings where models are fixed. By treating the workspace as the trainable object, the system makes adaptation explicit and executable: every prediction is a written commitment, every contradiction becomes a typed repair, and every repair is validated against prior evidence.

The authors emphasize that their results are bounded by time and cost budgets rather than system intelligence limits. They note that the methodology is designed for interactive settings where the model is fixed and learning must occur through the workspace. The paper does not claim to solve all ARC-AGI-3 challenges or to generalize to all interactive domains without further research, but it establishes a viable path for "test-time adaptation" that avoids the need for weight updates or offline training data.

The work distinguishes itself from prior test-time adaptation methods (like case banks or self-rewriting code) by using typed, named artifacts for failure routing, which sidesteps the open failure-attribution problem, and by enforcing regression checks to ensure consistency with historical evidence.