Journal club week 41, 2026.

Three papers this week, each about what a system should do with the information in front of it. The first releases ten real, months-long relationships between people and an AI companion and asks whether models know when the past matters. The second builds interactive worlds where the state lives in a game engine and a distilled video model only paints the picture. The third re-examines cross-tokenizer distillation and finds that the strictest alignment already carries nearly all of the useful signal.

Two of them share a result shape I keep seeing lately: giving a model more signal, whether more retrieved context or more supervision coverage, does not reliably help, and pooled scores can hide that.

RealCompanion: Benchmarking Human Understanding from Reasoning over Longitudinal Real-World Conversations

Arman Behnam, Sunglyoung Kim & Liangwei Yang, arXiv, 2026. arXiv:2610.01780

Benchmarks for conversational memory have mostly been built from generated dialogs, and generated dialogs are written around the facts they test, so nearly every message in them needs the past. RealCompanion replaces that setup with ten real relationships between people and an AI companion app: 27,218 messages over spans of 36 to 120 days, released with consent and anonymized by rewriting. Each person gets five files (the conversation, a profile of stated facts, a persona of inferred traits, chat test items built from messages the person sent verbatim, and authored questions). Every label cites the messages it rests on, and the chat labels carry a stage-by-stage reasoning trace that was checked against the conversation.

The headline numbers reframe what conversational memory is. On a random sample of messages, 3.4% need anything outside the current thread, and when one does, the required message sits a median of 2,157 messages back. Looking only at the most recent messages recovers the required one in 95.9% of all probes, but for the probes that need memory at all the share drops to 2.2%, so a pooled retrieval score mostly reports the mix of the corpus. BM25 does better on the distant items (hit@5 of 0.248) and still misses three in four. The decision of whether to retrieve at all looks worse. A detector reading the probe and its three preceding messages separates memory-needing probes from others at an AUROC of 0.530, close to chance. Framing effects are large: labeling the same ten retrieved messages as "memories" instead of "earlier turns from this chat" raises memory use by 10 to 14 points, even on probes that need nothing, and supplying ten unselected messages pushes the misfire rate from zero to 60.8%.

The third finding is about persona reconstruction. Three agent systems (Claude Opus 5.5, Codex GPT-5.6-sol, and Gemini 3.8 Flash via Antigravity) each read a full history and wrote the persona file. All three reach F1 between 0.69 and 0.70 while processing between 18M and 546M tokens, a 31-fold cost spread for the same score. Precision of 0.56 to 0.59 against recall of 0.86 to 0.89 means each system recovers most of the released file and then adds roughly seventy to eighty extra claims per hundred it gets right. The systems also agree with each other (0.86 to 0.88) more than either agrees with the ground truth file, so the extra claims are systematic, not noise.

Relevance

If you build or evaluate memory layers for chat products, this paper resets the base rates. The scarce and difficult decision is when to retrieve, not how, and neither a detector nor the models themselves make that decision well on real messages. The relabeling result is also a direct warning for prompt design: the heading you put above a retrieved block changes behavior by double-digit points. And because every label cites its evidence, the corpus lets you contest any item, which generated benchmarks cannot offer.

AgentGarten: Code Worlds for Evolving Agents

Jiawei Chi et al., arXiv, 2026. arXiv:2610.12374

AgentGarten splits an interactive world into two parts. A simulator or game engine holds the state and executes rules written as code, and a neural renderer turns the geometry the engine exports (depth maps or surface normals) into the visual observations the agent sees. Because the state never passes through the video model, rendering errors cannot accumulate in the world, and a recorded trajectory can be re-rendered in a different style or from a different camera without changing what happened. New worlds are scene programs, and a coding agent can build one from a single image or a text description, checking its own work with test rollouts and collision queries.

The renderer is the technical core. Starting from a pretrained bidirectional video model (Cosmos 3-Nano), the authors adapt it to geometry conditions, convert it to block-causal generation, and distill it into a few-step real-time model with a method they call Adversarial Forcing. Two pieces matter. Exact replay recomputes the history encoding block by block with the same attention calls used at sampling time, so gradients reach the computation that writes the KV cache and the recomputation matches the rollout bitwise; a full-sequence FlexAttention second pass, by contrast, diverges from the rollout by 3.99% relative error. The adversarial piece adds real-data supervision with an exact R1/R2 penalty that avoids the double-backward pass fused attention kernels do not support. The finished renderer produces 36.5 frames per second on one H100, including condition encoding, four denoising steps, decoding, and host transfer.

On top of this they run foundation-model agents that see only rendered frames, act through short Python programs, and after each round of games write playbooks that the next round's agents inherit. In the hide-and-seek environment from OpenAI's 2019 self-play study, hiders built shelters by round 4 and seekers used ramps by round 10, where the original study needed roughly 25 million and 100 million training episodes for the same milestones. The authors are careful that this compares two learning paradigms rather than the sample efficiency of one method: their agents arrive with web-scale knowledge and the task is grounding it in closed-loop control from pixels. The same four-round loop improved outcomes in four more worlds, from two cars swapping ends of a one-lane bridge (71 seconds in round 1, 41 in round 4) to herding sheep and operating a quarry loader.

Relevance

Environment quality is the bottleneck for training agents, and this is a clean way to get fidelity and visual range at once: the engine guarantees the state, the renderer supplies appearance, and any simulator that exports depth or normals can plug in. The playbook results suggest that for pretrained agents, written experience passed between rounds can substitute for a large fraction of RL sample counts, which changes the economics of building practice environments. The exact-replay construction is also reusable on its own for anyone distilling autoregressive video models.

Rethinking Cross-Tokenizer On-Policy Distillation: From Alignment Coverage to Supervision Reliability

Bingxi Hou et al., arXiv, 2026. arXiv:2610.08448

On-policy distillation lets a student learn from its own sampled outputs, with a teacher scoring the prefixes the student reaches. Doing this across model families means aligning two tokenizers, both at the sequence level (token boundaries differ) and at the vocabulary level (the distributions live over different token sets). The recent direction in the literature has been to recover more and more of the supervision that strict token alignment excludes. This paper asks whether that recovery helps, across three teacher-student pairs (Qwen2.5-7B-Instruct to Llama-3.2-3B-Instruct, Granite-4.1-8B to Phi-4-mini-instruct, and Granite-4.1-8B to Qwen2.5-7B-Base) on math and code benchmarks.

The measurements say the strict part already carries the signal. Strict 1:1 token groups cover 85.57 to 96.98% of student-generated tokens even where static vocabulary overlap is as low as 39.49% by Jaccard, and at strictly aligned positions the shared vocabulary holds 99.69 to 99.90% of the teacher's probability mass on average. Restricting the reverse KL to a student-selected top-16 shared tokens per position keeps at least 96% of the accuracy gain of full shared-vocabulary distillation, and it beats all four cross-tokenizer baselines tested (ULD, Extended ULD, GOLD, SimCT) on all three pairs. Adding the excluded signal back, as an MSE loss on span log-probabilities over mismatch groups, gives complete supervision coverage and lowers accuracy at every one of 18 tested positive weights, by 0.27 to 1.20 points.

The gradient diagnostics are what make the negative result convincing. At checkpoints from strict-only training, the span-loss gradients have near-zero or negative cosine with the strict gradients, consistently below a split-half reference computed within the strict loss itself. Meanwhile the ratio of span to strict gradient norms grows over training, so a fixed weight on the span loss gives it increasing influence over time. The extra supervision is not merely unhelpful; it increasingly pushes against the part that works.

Relevance

If you distill across tokenizers, this is directly usable guidance: the strict objective on the shared vocabulary, cut to a small student-selected top-k support, is cheap and sufficient, and structural-recovery machinery may subtract value rather than add it. The broader point generalizes past distillation. Coverage of an alignment or a vocabulary is a structural metric, and this paper shows it can move in the opposite direction from learning value, with gradient agreement as a cheap diagnostic for telling the two apart before you run the full training sweep.

Final notes

The RealCompanion relabeling experiment stayed with me. Calling a block of retrieved messages "memories" instead of "earlier turns" changes how often a model invokes the past by ten to fourteen points, with no change in content. Anyone who has tweaked a RAG prompt template has seen smaller versions of this, but seeing it measured cleanly on real conversations makes it harder to wave away.

AgentGarten's exact replay is a good reminder that numerical details are not details. Two attention implementations with the same mask differ by 3.99% in recomputed latents, enough to corrupt a gradient path, and matching the execution structure block by block brings the error to zero. And the cross-tokenizer paper earns its negative result by measuring gradients rather than stopping at an accuracy drop, which is the part of the paper I would most like to see other groups copy.

All posts