ToM2Vec Teaches LLM Agents to Model Their Partners in Latent Tokens

Researchers have proposed ToM2Vec, a way to teach LLM agents to form a theory of mind (ToM) of their partner not as a text description, but through a fixed budget of continuous reasoning tokens. The method was tested in five families of environments: Overcooked-AI, multi-party negotiation, Decrypto, Hanabi and Collab Escape/Capture. It consistently outperformed the base model and a set of trained and prompt-based competitors. The authors also showed that the approach transfers to partners from unfamiliar model families, including the proprietary GPT-5.4.

Why text is a poor way to store uncertainty

Successful cooperation depends on how accurately an agent represents what is going on in its partner's head. The key word here is "uncertainty": a partner can actually be in several states at once. They may not know where a needed card is, may be pursuing a different goal, or may simply have made a mistake. A good ToM must hold several such hypotheses at the same time.

The text space in which LLM agents operate is a poor fit for this. Language easily describes a single state: "the partner thinks they are holding a red five." Expressing a distribution over possible states in coherent text is much harder. The model usually picks one version and builds all its further planning on it. If that version is wrong, the whole chain of actions goes off the rails.

Training on someone else's thoughts

The authors move reasoning about the partner into a hidden continuous space. The agent receives a fixed number of ToM tokens, which are vectors rather than words. During training, these tokens are supervised with the partner's real thoughts. The tokens learn to abstract those thoughts and match them, in effect compressing another agent's reasoning into a compact representation.

At test time, each agent generates its own ToM tokens. They serve as a condition for the agent's own thoughts and actions: first the agent forms a hypothesis about the partner, then it thinks and acts with that hypothesis in mind. The token budget is fixed, so the cost of this step is predictable, and the context does not bloat with long text reasoning about someone else's intentions.

Five environments and one proprietary partner

The set of environments is deliberately diverse. It includes pure cooperation (Overcooked-AI, Hanabi), as well as competition and mixed motives (multi-party negotiation, Decrypto, Collab Escape/Capture). In all of these settings, ToM2Vec showed a consistent gain over the base model and competing approaches.

The main results of the work:

• The latent form of reasoning is critical: quality drops when the same reasoning is expressed in text.
• The training generalizes to families of partner models not encountered during training.
• The unfamiliar partners include the proprietary GPT-5.4.
• Improvements show up in cooperative, competitive and mixed scenarios.
• The comparison covered both trained and prompt-based baselines.

A separate part of the analysis addresses whether the tokens really encode ToM, rather than just hints tailored to a specific game. The authors tested this directly: with ToM2Vec tokens, the agent answers questions about the partner's beliefs, desires and next actions better. This supports the claim that the tokens hold a model of the other agent, not quirks of the task.

What to change in the architecture of agent systems

For those building multi-agent systems, the work offers several practical takeaways. First, explicit text "reflection about the partner" can be a weak link: if it breaks the probabilistic picture, it is worth trying a latent channel with a limited budget. Second, supervising with the partner's thoughts, rather than only game outcomes, provides a richer training signal for an agent's social intelligence. Third, the transfer to GPT-5.4 suggests that an agent can be trained on some models and deployed alongside others, including closed ones, without retraining for each partner.

The limitations are also clear. Latent tokens are harder to read and debug than a text chain of reasoning. For products where the auditability of an agent's decisions matters, developers will have to balance accuracy against transparency. But for tasks where speed and coordination quality matter more than explainability (game bots, negotiation agents, robots in a shared workspace), the approach looks like a viable candidate. The next question is how it will behave with human partners, whose thoughts will not so easily make it into the training set.