🤖 AI

TOM-SWE: User Mental Modeling For Software Engineering Agents

The paper introduces ToM-SWE, a dual-agent architecture that pairs a software engineering agent with a theory-of-mind partner to model user intent and maintain persistent memory, significantly improving task success rates and user satisfaction in both benchmark evaluations and a real-world study with professional developers.

Original authors: Xuhui Zhou, Valerie Chen, Zora Zhiruo Wang, Graham Neubig, Maarten Sap, Xingyao Wang

Published 2026-02-02

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Xuhui Zhou, Valerie Chen, Zora Zhiruo Wang, Graham Neubig, Maarten Sap, Xingyao Wang

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 "Forgetful" Coding Robot

Imagine you hire a brilliant but amnesiac robot assistant to help you build a website.

The Robot: It's incredibly smart at writing code, fixing bugs, and running tests.
The Problem: Every time you start a new conversation, the robot has no memory of who you are. It doesn't know that you hate long explanations, that you prefer using specific tools, or that you always want to test your code before you deploy it.
The Result: You have to repeat yourself constantly. "Make it shorter," "Use this library," "Don't ask me so many questions." The robot keeps guessing, often getting it wrong, which wastes time and frustrates you.

Current AI coding agents are like this robot: they are great at the technical work but terrible at understanding you.

The Solution: The "Mind-Reader" Partner (ToM-SWE)

The authors of this paper created a new system called ToM-SWE. Instead of just one robot, they built a two-person team:

The Builder (SWE Agent): This is the original coding robot. It focuses 100% on writing code, running tests, and fixing errors. It doesn't worry about your personality; it just does the heavy lifting.
The Mind-Reader (ToM Agent): This is a new, lightweight partner. Its only job is to study you. It watches how you talk, what you like, and what you've done in the past. It builds a "mental model" of your preferences.

How they work together:
Before the Builder starts coding, it asks the Mind-Reader: "Hey, what does this user like? Do they want short answers? Do they use Python or JavaScript? Did they mention a specific tool last week?"
The Mind-Reader checks its notes and says, "This user is a professor who likes concise answers and prefers using Vercel for hosting. Don't ask them too many questions."
The Builder then adjusts its plan and writes code that fits your style perfectly.

The "Mental Model" Analogy

Think of the Mind-Reader like a very attentive personal assistant who keeps a diary of your habits.

Session 1: You tell the system, "Make me a website." The Mind-Reader notes: User is a professor, likes academic styles, prefers Vercel.
Session 2 (Next week): You say, "Make me a website" again.
- Old Robot: "Okay, I'll guess a generic website."
- ToM-SWE: The Builder asks the Mind-Reader. The Mind-Reader says, "Remember last time? This is for a university project. Use academic fonts and host on Vercel."
- Result: The code is exactly what you wanted, even though you didn't say it again.

How They Tested It

The researchers didn't just guess this would work; they ran two types of tests:

The "Simulation" Test (Benchmarks):
They created a fake world where the AI had to talk to a "simulated user" (another AI acting like a human). They gave the simulated user different personalities (e.g., one who is very chatty, one who is very brief).
- The Result: The ToM-SWE team solved 59.7% of the tasks successfully. The best previous robot (OpenHands) only solved 18.1%.
- The "Satisfaction" Score: The simulated users rated the ToM-SWE team much higher (3.62 out of 5) because the team "listened" better and didn't annoy them with unnecessary questions.
The "Real Life" Test (Human Study):
They let 17 real professional developers use the system for three weeks on their actual, daily work.
- The Result: The developers found the Mind-Reader's suggestions useful 86% of the time.
- What they liked: The system would say things like, "You usually add tests for new functions, so I added them here," or "You prefer minimal code edits, so I kept the changes small."

Why This Matters

The paper claims that for AI to be truly helpful in software engineering, it can't just be a code generator. It needs to be a collaborator that understands human intent.

Old Way: You tell the AI what to do, and it guesses the rest.
New Way (ToM-SWE): The AI remembers who you are, what you like, and how you work, so it can anticipate your needs before you even ask.

Summary in One Sentence

ToM-SWE is a two-agent system where one agent writes the code and a second "mind-reading" agent remembers your personal preferences and habits, allowing the team to work with you much more efficiently and with less frustration.

Technical Summary: ToM-SWE: User Mental Modeling for Software Engineering Agents

Problem Statement

Recent advances in Large Language Model (LLM) based coding agents have enabled them to plan, edit, run, and test complex codebases. However, these systems face a fundamental limitation: they struggle to infer and track user intent, particularly when instructions are underspecified or context-dependent. Current agents typically operate in a stateless manner, treating each session as independent and lacking mechanisms to maintain persistent context about a user's evolving goals, preferences, and constraints. This leads to wasted effort, misunderstandings, and potentially unsafe outcomes in high-stakes settings. Furthermore, existing benchmarks like SWE-bench primarily assess technical problem-solving on well-specified tasks, failing to evaluate an agent's ability to sustain meaningful, long-horizon interactions with diverse users.

Methodology

To address these gaps, the authors introduce ToM-SWE, a framework that integrates Theory of Mind (ToM) reasoning into software engineering agents. ToM in this context refers to the ability to model a user's mental state (goals, preferences, intentions) based on instructions and interaction history.

Dual-Agent Architecture

The core innovation is a dual-agent architecture that separates concerns:

Primary SWE Agent: Focused exclusively on coding tasks (generation, debugging, execution).
Dedicated ToM Agent: A lightweight partner responsible for modeling the user's mental state.

The ToM agent operates in two complementary modes:

In-Session ToM: During active coding, it infers the user's underlying mental state (e.g., the "true" intent behind ambiguous instructions) by consulting interaction history and providing suggestions to the SWE agent.
After-Session ToM: Post-session, it processes interaction history to refine and update a persistent user model.

Hierarchical Memory System

The ToM agent utilizes a three-tier hierarchical memory system implemented as an external database:

Tier 1 (Raw Session Storage): Stores complete previous session histories.
Tier 2 (Session-Based User Model): Maintains per-session analysis, including session intent, interaction patterns, and coding preferences.
Tier 3 (Overall User Model): Aggregates cross-session patterns into preference clusters, interaction style summaries, and coding style summaries.

The SWE agent interacts with the ToM agent via two specific tools: consult tom (to retrieve relevant user mental state information during a session) and update memory (to trigger the ToM agent to process and update the memory hierarchy after a session).

Evaluation Framework: Stateful SWE Benchmark

The authors introduce the Stateful SWE benchmark, the first benchmark designed to evaluate agents in long-horizon, multi-session interactions.

Setup: It pairs 15 distinct developer profiles (derived from 453 real human-agent sessions) with 500 instances from the SWE-bench.
Simulation: Agents interact with an LLM-powered user simulator conditioned on specific profiles (varying in verbosity, question timing, and coding preferences).
Challenge: Agents must leverage previous interaction histories to track user mental states and adapt their behavior, rather than relying solely on the current instruction.

Key Contributions

ToM-SWE Framework: A novel dual-agent architecture that decouples coding execution from user mental modeling, allowing for specialized optimization and persistent user tracking without overwhelming the coding agent's context.
Stateful SWE Benchmark: A new evaluation suite that tests agents on their ability to adapt to different users over multiple sessions, moving beyond static, single-turn task resolution.
Empirical Validation: Comprehensive evaluation on both the new Stateful SWE benchmark and the existing Ambiguous SWE-bench, alongside a real-world human study.

Results

Offline Benchmark Performance

The proposed agent, ToMCodeAct (built on the OpenHands platform), was compared against the state-of-the-art CodeAct agent and a RAGCodeAct baseline (which retrieves raw history without explicit modeling).

Ambiguous SWE-bench: ToMCodeAct achieved a 63.4% issue resolution rate (using Claude Sonnet 4), outperforming CodeAct's 51.9% (+11.5% improvement).
Stateful SWE-bench: ToMCodeAct achieved a 59.7% resolution rate, a substantial improvement over CodeAct's 18.1% (+41.6 percentage points).
User Satisfaction: ToMCodeAct scored significantly higher on user satisfaction (3.62 vs. 2.57 for CodeAct), measured by a profile-conditioned user simulator evaluating preference alignment and communication.
Analysis: The study found that simply retrieving raw session data (RAG) was insufficient; explicit abstraction of user preferences into a mental model was critical. Additionally, a strong positive correlation ( $r=0.74$ ) was found between task resolution and user satisfaction, though ToM agents also received high satisfaction scores even when tasks failed, provided the process quality and communication were aligned with user preferences ("good-effort bonus").

In-the-Wild Human Study

A three-week observational study was conducted with 17 professional developers using a ToM-enhanced CLI for their daily, self-chosen coding tasks.

Acceptance Rate: Developers accepted or partially accepted ToM suggestions 86% of the time (174 suggestions across 209 sessions).
Utility: Feedback indicated that ToM suggestions helped explicitly write out rules users had in previous conversations, created accurate user profiles, and improved workflow efficiency.
Context Sensitivity: Success rates were highest for moderately underspecified queries with sufficient technical context (e.g., 92% for "Code Understanding") but dropped for extremely vague queries.

Significance and Claims

The paper claims that ToM-SWE demonstrates that effective human-AI collaboration in software engineering requires agents that can infer, maintain, and act on user-specific mental models over time.

Beyond Technical Capability: Strong coding capabilities are insufficient without the ability to model user intent and preferences, especially when instructions are high-level and underspecified.
Process Quality Matters: The results highlight that user satisfaction is not solely determined by task success (unit tests) but also by the quality of the interaction process, communication style, and alignment with user preferences.
Architectural Necessity: The dual-agent design is presented as a crucial mechanism to reduce context distraction for the coding agent while enabling specialized, persistent user modeling.
Practical Impact: The high acceptance rate in a real-world setting suggests that stateful user modeling is a viable and valuable enhancement for practical coding agents, potentially increasing developer productivity and reducing friction in interactive debugging and maintenance.

The authors remain modest regarding privacy and generalization, acknowledging that user modeling raises risks of manipulation or surveillance and that their profiles are derived from a specific subset of developers. They emphasize the need for responsible deployment, explicit consent, and user-controlled memory.