Test-Time Adaptation for LLM Agents addresses the fundamental challenge of deploying language model agents in novel environments they were not trained on. Introduced by Chen et al. at Salesforce Research (2025), this work proposes two complementary strategies – online syntactic alignment and deployment-time dynamics grounding – that enable agents to adapt to unseen websites, APIs, and interfaces at deployment without retraining.

LLM-based agents struggle when deployed in environments that differ from their training distribution. This challenge stems from two distinct failure modes:

Syntactic Mismatch. Environment-specific components like observation formats, HTML structures, API response schemas, and UI element naming conventions differ across deployments. The model's output distribution is biased toward formats seen during training.

Semantic Mismatch. State-transition dynamics – how actions affect environment state – are unique to each deployment target and only revealed through interaction. The model cannot predict how an unseen website will respond to clicks, form submissions, or navigation actions.

The first strategy addresses syntactic mismatch through a lightweight parametric adaptation:

• Learns a lightweight adaptation vector that biases the model's output token distribution
• Trains online using environment observations collected during deployment
• Enables rapid alignment with environment-specific response formats
• Minimal computational overhead – only a small bias vector is updated

The adaptation vector modifies the logit distribution:

$$p(a_t | s_t) = \text{softmax}(\text{logits}(s_t) + \mathbf{v}_{\text{adapt}})$$

where $\mathbf{v}_{\text{adapt}}$ is learned online from environment interactions to upweight tokens that match the deployment environment's syntax.

# Simplified online syntactic alignment
class SyntacticAlignment:
    def __init__(self, vocab_size):
        self.bias_vector = torch.zeros(vocab_size)
 
    def adapt(self, env_observations):
        # Learn token distribution bias from environment feedback
        for obs in env_observations:
            token_dist = compute_token_distribution(obs)
            self.bias_vector += learning_rate * (token_dist - self.bias_vector)
 
    def modify_logits(self, base_logits):
        return base_logits + self.bias_vector

The second strategy addresses semantic mismatch through a non-parametric world model built from exploration:

Persona-Driven Exploration Phase. Before executing the actual task, the agent enters an exploration phase where it systematically probes the environment's causal dynamics. Using different personas (e.g., 'curious user', 'systematic tester'), the agent:

• Clicks buttons and observes state transitions
• Fills forms and tracks responses
• Navigates pages and maps site structure
• Tests API endpoints and records behaviors

In-Context World Model. The exploration results are compiled into an in-context world model – a structured description of the environment's dynamics that is prepended to the agent's context during task execution. This gives the agent a causal understanding of how the environment responds to actions.

The two strategies are complementary and can be applied together:

Evaluated across diverse agentic benchmarks including function calling and web navigation:

• Both strategies show effectiveness across all benchmarks with minimal computational cost
• Dynamics grounding is particularly effective in complex environments where unpredictable dynamics pose the major obstacle
• On the WebArena multi-site split, dynamics grounding achieves significant improvements
• The approach requires no retraining – adaptation happens entirely at deployment time
• Computational overhead is minimal compared to the cost of the base model's inference

Published as a conference paper at ICLR 2026.

This work addresses a critical gap in the deployment of LLM agents: the difference between training environments and real-world deployment targets. By enabling agents to self-adapt at test time, it removes the requirement for environment-specific training data and makes agents more robust to the diversity of real-world deployment scenarios.

The persona-driven exploration approach is particularly notable because it mirrors how human users naturally explore new interfaces – clicking around to understand how things work before attempting specific tasks.

• Chen et al. (2025). Test-Time Adaptation for LLM Agents via Environment Interaction. arXiv:2511.04847
• Zhou et al. (2023). WebArena: A Realistic Web Environment for Building Autonomous Agents.

• Test-Time Compute Scaling
• Web Navigation Agents
• Domain Adaptation
• World Models for Agents