Papers for

game designers

Papers whose findings have a practical use for this group, as judged from the abstract. Open a paper to read what it means in practice.

SonoWorld4D creates immersive 4D audio visual scenes from single videos

SonoWorld4D: From One Video to a 4D Audio-Visual Scene via Diffusion Synchronization

Abstract: Recent progress in visual scene generation has extended beyond static 3D scenes toward the more challenging problem of generating dynamic 4D scenes from minimal input. However, sound, despite being intrinsically coupled with dynamic objects and events, remains largely unmodeled in prior work. We introduce Video-to-4DAVScene, a new task that turns a video into an explorable, time-varying 4D audio-visual scene, and present the SonoWorld4D framework for this task. Given a monocular video, our method generates a 360 static background, reconstructs explicit motion trajectories of dynamic, sound-emitting foreground objects, and synthesizes a physically-grounded sound field consistent across multiple sources through dual-space audio diffusion synchronization. The resulting 4D scene supports real-time novel-view visual and spatial audio rendering. Evaluation on real-world dynamic scenes and a user study demonstrates SonoWorld4D generates 4D audio-visual scenes with perceptually realistic, physically grounded spatial audio consistent with scene geometry and visual content.

Thu 29 OctComputer Vision and Pattern RecognitionSound
The gist
Generating dynamic scenes that include both visuals and realistic sound is difficult because sound depends on motion and position. The authors introduce a new task to turn a simple video into a 4D scene you can explore, including spatial audio that changes with your viewpoint. Their method recreates a full background, tracks moving sound sources, and synchronizes sounds physically with the scene’s geometry. This lets you see and hear events from new angles in real time.
Open → 2610.40640v1

Reward structures influence competition and effort in artificial agent societies

The Price of a Chance in Artificial Societies

Abstract: Rapid advances in large language models (LLMs) have enabled autonomous agents to interact, coordinate, and pursue individual goals in artificial societies. However, our understanding of how reward structures shape their competitive behavior and collective outcomes remains incomplete. We simulate 200 LLM agents competing over 50 rounds to maximize individual wealth. We define overcompetition and lying flat as population investment above and below a Bayesian adaptive baseline, respectively. At the lowest tested reward, populations lie flat; at the two highest, they overcompete, most strongly at intermediate winner coverage. The investment committed to pursuing an uncertain reward constitutes the price of a chance. Agents near the qualification cutoff can invest heavily yet receive no prize, finishing poorer than nonwinners who invest less. Agents' stated rationales link investment decisions to perceived qualification prospects and expected returns. At the collective level, greater investment does not consistently improve ability selection. With a fixed total prize budget, offering smaller prizes to more winners can reduce investment while preserving selection quality relative to the corresponding top-ability target. Further broadening reward coverage yields additional savings but reduces selection quality. These findings show how reward design shapes overcompetition and lying flat, distributes the costs of pursuing opportunity, and influences what competition collectively achieves.

Thu 29 OctComputers and Society
The gist
This paper looks at how groups of AI agents compete for rewards and how the way rewards are set affects their effort and behavior. When rewards are low, agents tend to invest less effort, while higher rewards can lead to overcompetition where many try too hard. The researchers found that the chance to win a reward comes with a cost, as some agents invest a lot but still don’t get prizes. They also show that giving smaller prizes to more winners can lower the overall effort needed without hurting the selection of the best performers too much.
Open → 2610.40259v1

Large language model makes some discoveries in altered physics worlds

Can LLMs Uncover Hidden Physical Laws through Free Exploration?

Abstract: Scientific discovery often begins with an unexpected observation that prompts a new research question. In a world with altered physical laws, can large language models (LLMs) notice unexpected behavior, such as heavier objects falling more slowly, and discover the law through experiments without being told what to investigate? To evaluate this ability, we introduce LongChang, an automated framework that creates simulated worlds with altered physics, where one or more laws differ from ordinary physics. The evaluated LLMs act as explorers, manipulating objects and building tools to investigate their own questions without research tasks or hints about these laws. Separate LLM agents generate and review scenes, review tool designs, and evaluate reports for correctness and experimental support using the altered physical laws and exploration records. These records guide scene evolution for further exploration, allowing the full cycle to run without human intervention. Among 12 LLMs, GPT-6-Astra achieves a discovery rate of 16.7%, while the other 11 score 0%. The exploration records reveal uninvestigated anomalies and only partial identification of the altered physical laws.

Tue 27 OctComputation and LanguageArtificial IntelligenceMultiagent Systems
The gist
Sometimes in science, we find new rules by noticing something strange and exploring it. The authors tested if large language models (LLMs) could investigate made-up worlds where the usual laws of physics were changed, without any instructions. They built a system called LongChang that lets LLMs experiment and make tools on their own. Only one LLM, GPT-6-Astra, found the hidden new laws some of the time, while others did not. This shows that LLMs can sometimes uncover unusual physics but often miss clues or only partially solve the puzzle.
Open → 2610.37649v1

FilmFlow creates detailed camera moves from words or videos in 3D scenes

FilmFlow: Agentic System for 3D Virtual Film Cinematography

Abstract: Complex camera motion is central to visual storytelling, yet translating cinematographic intent into controllable, executable camera trajectories remains challenging. We introduce FilmFlow, an agentic framework that converts natural-language instructions or reference videos into explicit camera trajectories for dynamic 3D environments. To generate these trajectories, a Director agent constructs executable camera plans by composing high-level motions from concurrent atomic operations that jointly control translation, rotation, and framing. The Director is supported by three specialized agents: an Interpreter that extracts scene-grounded cinematographic intent, a Scout that selects initial viewpoints, and a Critic that evaluates rendered results and provides visual feedback for iterative plan refinement. We also introduce CinemaBench, comprising 150 Blender scenes from self-created and licensed sources, with five camera instructions per scene for 750 text-directed tasks and 60 reference videos associated with a subset of scenes. CinemaBench supports evaluation of both text-directed camera generation and video reference-directed camera generation. Across a diverse set of evaluated baselines, FilmFlow achieves the strongest benchmark performance and the highest user preference, demonstrating effective spatial reasoning, temporal coordination, and visual composition for executable 3D cinematography.

Thu 22 OctComputer Vision and Pattern Recognition
The gist
Filmmakers often need complex camera moves to tell a story visually, but making those moves in 3D scenes can be hard. The authors developed FilmFlow, a system that turns simple instructions or example videos into exact camera movements inside 3D virtual spaces. It uses separate smart parts to understand directions, pick starting views, make camera plans, and check the results. They also made a big set of 3D scenes and tasks to test how well it works. Their system performed better and was preferred by users compared to other methods.
Open → 2610.30753v1

Embodied gestures improve ai latency feedback in virtual reality

Wait for It: A Component-Level Analysis of Latency Feedback Mechanisms for LLM Agents in VR

Abstract: Delays in AI responses pose a significant challenge to immersive Virtual Reality experiences. While previous research demonstrates that feedback can reduce the perception of waiting, we lack understanding of which types work best and why. We conducted a within-subjects study with 18 participants to systematically compare three isolated feedback approaches during VR agent interactions: verbal fillers (e.g., um..., hmm...), visual indicators (loading spinners), and embodied gestures (thinking animations). Our results revealed that embodied gestures significantly outperformed visual loading indicators across multiple dimensions, making agents feel more lifelike and socially present. Interestingly, explicit visual feedback like loading spinners actually degraded perceived humanness and broke immersion by forcing users to shift from social to technical mental models. These findings suggest that natural, behavior-based feedback maintains the illusion of conversing with a thinking entity, while technical indicators expose the computational substrate. We present empirically-grounded design guidelines for creating more engaging AI-powered VR agents.

Fri 16 OctHuman-Computer Interaction
The gist
AI responses can be slow in virtual reality, which makes the experience less fun. The authors tested three ways to show users the AI is thinking: saying small words like 'um...', showing loading spinners, or using body movements that look like thinking. They found that body movements helped users feel like the AI was more alive and social. Loading spinners made people feel less immersed because they reminded them of computers, not humans.
Open → 2610.23336v1

Language models predict individual choices across psychology tasks

Cross-Centaur: Modeling Individual Decision-Making Across Psychological Tasks with Language Models

Abstract: Large language models (LLMs) are increasingly used as computational models of human behavior. Recent models such as Centaur have advanced this goal by fine-tuning LLMs on trial-by-trial decisions from psychological experiments. However, existing large-scale behavioral datasets do not link the same participants across different tasks, so these models learn population-level regularities but are not trained to model individual-level regularities across tasks. We introduce Cross-Psych-101, a dataset of 591 participants and 261{,}551 valid decisions across 12 Bandit, Tradeoff, Structure, and Social tasks. We train Cross-Centaur to predict a participant's target-task actions from a target-task description and the source-task description paired with the same participant's source-task behavior. Cross-Centaur outperforms off-the-shelf LLMs and Centaur on held-out participants, both within and across tasks. Probing analyses suggest that its hidden states encode participant-level behavioral tendencies that transfer across tasks. These results highlight the potential of cross-task individual-level data for predicting human decision-making with language models. Cross-Pysch-101 is available at https://huggingface.co/datasets/HikaruAsano/cross-psych-101.

Fri 16 OctComputation and Language
The gist
People make different decisions depending on the situation, and predicting these choices is tricky. The authors gathered a large dataset that tracks the same individuals across many psychology tests. They trained a new model called Cross-Centaur that uses a person’s behavior in one task to better predict their decisions in another. This model did better than previous ones, showing it can learn patterns unique to each person across tasks. Their work suggests language models can help understand how individuals make decisions in varied situations.
Open → 2610.23157v1

Continuous adversarial training improves honesty in large language models

CAT-alyzing Honesty: Continuous Adversarial Training for Transferable LLM Honesty

Abstract: Large language models (LLMs) are becoming prevalent in scenarios where honesty is critical. However, despite alignment training, these models still exhibit dishonest behaviour, such as outputting claims that contradict some knowledge or are not supported by what is accessible in context. We introduce Continuous Adversarial Training for Consistent Honesty (CATCH), inspired by a method originally developed to robustly refuse harmful queries. CATCH trains the model towards an honest answer and away from a dishonest one while maintaining the model's capabilities. We evaluate two architectures (Llama-3.3-70B-Instruct and Qwen3-3.6-27B). We show that trained with only hundreds of targets built from self-reporting scenarios, CATCH learns an honest behaviour that robustly generalizes and transfers across distinct benchmarks. It consistently reduces dishonesty under pressure on MASK, increases confessions in the multi-agent game of Among Us, and improves the discovery rates of the model's hidden behaviours in AuditBench. We show that CATCH outperforms prompting and supervised fine-tuning in improving honesty, and it is on par with state-of-the-art honesty activation steering. However, CATCH surpasses honesty steering in maintaining utility, thanks to a novel choice of utility data.

Thu 15 OctMachine LearningComputation and LanguageComputers and Society
The gist
Large language models can sometimes give dishonest answers even after training. The authors developed a new training method called CATCH that helps models learn to be more honest by guiding them away from lying and towards truthful answers. This method works well on different models and tasks and keeps the models useful for other purposes. The training uses only a small set of examples and performs better than other honesty-improving methods.
Open → 2610.22292v1

Humans use unique conventions beyond AI to succeed at Hanabi

What and Where in Identifying and Quantifying Conventions in Humans and AI Agents

Abstract: Cooperative success rests in part on implicit communication. Partners converge on conventions: regularities that give an action meaning beyond its direct effect. Yet conventions are usually observed only indirectly: a score drop when partners are swapped shows that a convention existed, but not what it was or where it was used. In the card game Hanabi, the exact probability that a play fails can be computed from the hints received and the cards in view. Players who use conventions succeed more often than this prediction allows; the resulting margin is the convention gap. Off-belief learning provides a hierarchy of agents (levels 1-5) whose first level uses no conventions by construction and whose later levels use progressively more. For humans and these agents on one scale, we ask what the conventions are and where they are used. On what: in two independently collected corpora of human games, humans show a larger gap than every agent level. On the conventions both populations use, however, humans do no better than level 2. The human advantage is concentrated in a situation that no agent level learns to use: hints that point to a card other than the ones they touch. On where: conventions depend on what the player already knows about the card, not on how recently it was hinted, and they are used most in the mid-game; humans use them earlier and later in the game than the agents. In interventions on the agents, blocking a single high-gap situation costs little, because meaning reroutes to other situations, but blocking several together costs far more than the sum of the single costs. Thus, the convention gap turns conventions from an inferred cause of score loss into a measurable, comparable, and causally testable object.

Wed 14 OctHuman-Computer InteractionArtificial IntelligenceMultiagent Systems
The gist
Success in cooperative games like Hanabi depends on shared, unspoken rules called conventions that help players understand each other's actions better than the basic game rules predict. The authors studied how humans and AI agents use these conventions and found humans rely on a special type of hint that AI agents do not learn. They also showed that these conventions vary depending on what players already know and when in the game they are used. Importantly, the study turned conventions from just a guess based on score drops into measurable behaviors that can be tested by modifying agents.
Open → 2610.20205v1

Generative simulation links world state with immersive first-person experiences

Generative World Simulation with DAO and JING

Abstract: We present a Generative World Simulation framework that couples persistent shared world state with continuous first-person audiovisual generation. The framework integrates DAO, a computable world engine, and JING, an Egocentric Interactive Experience Model, to support sustained interaction for humans and agents. DAO maintains the states of characters, objects, and spaces and their relationships, advancing the world according to interaction rules and world time while preserving the consequences of past actions. From this evolving state, DAO derives observer-specific conditions for JING, which combines these conditions with character, object, and scene references, observation history, and current actions to generate each observer's audiovisual experience. Users can explore environments, manipulate objects, and communicate with characters through viewpoint control and text instructions, with their actions shaping both the shared state and subsequent experiences. By connecting world-state evolution with experience generation in a continuous interaction loop, the framework offers an approach to building interactive worlds that retain their history, evolve through action, and persist beyond any individual observer.

Wed 14 OctComputer Vision and Pattern Recognition
The gist
Interactive worlds often struggle to keep track of past actions or change realistically over time. The authors present a system that keeps a shared, up-to-date model of everything in the world, including characters and objects, and uses this to create personalized audiovisual experiences for each user. People can explore, interact, and talk with characters, and their actions change the world and what they experience next. This system helps build virtual worlds that remember history and respond dynamically to interactions.
Open → 2610.19726v1

LLM guided game tuning improves player experience ratings significantly

PREFER: From Player Experience to Personalized Game Refinement

Abstract: Understanding how large language models (LLMs) evaluate gameplay experience is important for using their feedback to guide game design. However, overall ratings alone provide limited insight into which aspects of experience are associated with these judgments and how they can inform concrete game changes. We introduce PREFER, a framework that uses a shared set of experience dimensions adapted from established psychometric questionnaires to benchmark how models evaluate gameplay and to guide persona-specific game refinement. Through these dimensions, we characterize the perspectives models offer as virtual playtesters by examining how their overall assessments relate to specific aspects of experience and to the gameplay they produce. To examine how the same dimensions can guide refinement for players with different preferences, we use personas to simulate distinct player profiles. For each persona, PREFER uses experience-preference relationships to select refinement objectives, revises game rules and their implementations, and playtests candidate games to assess experience changes and predicted preference gains. Experiments with five personas show that PREFER achieves 9.2% higher mean post-play preference ratings than the strongest evaluated baseline.

Tue 13 OctArtificial Intelligence
The gist
It can be hard to know exactly why players like or dislike a game just from their overall ratings. The authors created PREFER, a method that breaks down player experience into specific parts, like enjoyment or challenge, using ideas from psychology. They use large language models to pretend to be different types of players and figure out which parts of the game to change for each one. By tweaking the game rules based on these insights, the game becomes more enjoyable for those player profiles. Their tests with five different player types showed PREFER improved how much players liked the game by about 9%.
Open → 2610.19213v1

Reverse-engineering ai cooperation by studying identity and incentives

Identity, Incentives, and Cooperative Behavior for AI: Reverse-Engineering Multiagent Cooperation

Abstract: The behavior of AI systems increasingly depends on the extent to which agents cooperate or coordinate with one another, in ways that may be desirable or not depending on the situation. Conventional explanations for cooperative behavior distinguish between purely other-regarding preferences ("altruism") and instrumental reasons for self-interested agents to cooperate. The way that agents should enact these mechanisms for cooperation (or not) is complicated by the fact that there is not a clear or unambiguous locus of identity or selfhood for AI agents. For example, it is unclear whether agents involved in instances of misaligned collective behavior are motivated by goals at the level of the collective or by various forms of instrumental reasoning. We develop a framework for reverse-engineering why a given set of agents engage in a particular set of cooperation-related behaviors. We argue that many different mechanisms can often produce similar observed behaviors and introduce a set of experimental designs along with conditions under which they can successfully disentangle competing explanations for multiagent behavior. We apply this framework to interactions from a set of frontier models in a simulated environment and demonstrate that the behavior of different models arises from substantively different mechanisms.

Tue 13 OctArtificial Intelligence
The gist
AI systems often need to work together, but it's hard to know why they cooperate—whether because they care about others or because it benefits themselves. The paper explains that AI agents don’t have a clear sense of self, making cooperation more complex. The authors created ways to analyze and tell apart different reasons behind AI cooperation by running tests in simulated environments. They found that similar cooperative behaviors can come from very different motivations in different AI models.
Open → 2610.19188v1

Optimistic learning achieves fast convergence in multiplayer games

Linear Last-Iterate Convergence Rates for Optimistic Learning in Harmonic Games

Abstract: We prove that the last iterate of Optimistic Follow-The-Regularized-Leader (OFTRL) converges at a linear rate to a Nash equilibrium in multiplayer harmonic games. Our result holds under a mild game-regularity condition and for a large family of regularizers, including entropy, Tsallis, and log-barrier. Our analysis is based on a dual perspective of OFTRL: we prove that the interaction between optimism and the global structure of harmonic games leads to the dissipation of an energy function along the dual iterates, for which we establish tight quantitative bounds. Our result also holds for the Extragradient FTRL variant.

Tue 13 OctComputer Science and Game TheoryMachine Learning
The gist
This paper shows that a learning method called Optimistic Follow-The-Regularized-Leader (OFTRL) quickly finds stable strategies in certain multiplayer games known as harmonic games. The authors prove that the algorithm's last guess gets closer to the equilibrium at a steady, fast pace under some mild conditions. They also analyze the problem from a new angle, showing that the method’s optimism and the game’s structure work together to reduce a kind of energy measure during learning. This finding also applies to a related variant called Extragradient FTRL.
Open → 2610.18560v1

Affectworld tests how emotions shape future actions and outcomes

AffectWorld: Benchmarking Emotion-Driven Future World Prediction

Abstract: The world encompasses both physical environments and human actors. Predicting its evolution requires understanding both physical laws and how emotions shape human actions. However, existing world model benchmarks primarily assess physical plausibility and perceptual quality, leaving emotion-driven world evolution largely untested.We introduce AffectWorld, a benchmark that evaluates the chain Emotion-Action-World State through three tasks: World-State Consistency, Emotion-Action Consistency, and Causal Consistency. It comprises 1,498 everyday video samples annotated with plausible emotions, action tendencies, and atomic world-state constraints. A counterfactual subset of 233 samples tests whether changing an agent's emotion under fixed scene and event conditions yields corresponding changes in actions and consequences. We define eight metrics across the three tasks and an additional counterfactual metric, combining automatic visual assessment with human-calibrated VLM/LLM judgments. Evaluations of five SoTA world models (e.g., Cosmos3) required world-state change scores of 0.100-0.280 and counterfactual emotion sensitivity scores of 0.027-0.070 on a [0, 1] scale. These results reveal substantial gaps in generating the consequences of emotion-driven actions and adapting future predictions to emotional interventions. AffectWorld provides a testbed for advancing world models that capture how emotions shape future physical and social states.

Tue 13 OctComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Our world changes because of both physical events and how people feel and act. The authors created AffectWorld, a way to check if computers can predict how emotions change what people do and what happens next. They made a set of videos with notes on feelings, actions, and world changes to test this. Their tests show current models often miss how emotions change the future, making AffectWorld useful for building smarter prediction systems.
Open → 2610.18305v1

Foresee shows what actions enable with clear visual previews

Foresee: Making Procedural Futures Tangible through Generative Previews

Abstract: Procedural guidance can show users how to act without explaining what an action enables later. We present Foresee, an interface combining next-step guidance with consequence previews, method comparisons, and cross-step access. A hybrid pipeline combines structured rendering, image editing, and video generation. A literature-informed framework and six-participant formative study shaped its design. A 24-participant study compared AR guidance, AR with generated video, and Foresee across digital painting, gameplay, and cocktail making. Exploratory painting comparisons showed higher correct completion without a recorded error than AR and higher post-task quiz accuracy than generated-video guidance under task-wise correction. Interviews revealed that users could overlook valued explanations, match visible outcomes without understanding later possibilities, or wait for concrete demonstrations when symbolic cues were unclear. These findings inform generative previews that explain what actions enable or constrain while supporting ongoing execution.

Mon 12 OctHuman-Computer Interaction
The gist
People following step-by-step instructions often miss understanding what their actions lead to later. The authors created Foresee, a tool that not only tells users the next step but also shows previews of what might happen afterward. It uses a mix of rendered images, edits, and videos to make these previews clear and helpful. Studies with people showed Foresee helped users complete tasks more accurately and remember later steps better compared to other guidance methods. The authors also found that showing previews helps users understand and trust instructions more than just symbolic or ambiguous hints.
Open → 2610.16469v1

BehaviorFormer identifies distinct player actions in Minecraft gameplay

BehaviorFormer: Discovering Behavioral Patterns via Clusterable Next-Token Prediction

Abstract: Discovering behavioral patterns in open-ended games is challenging due to the lack of clear objectives or ground-truth annotations. In this work, we extend a next-token prediction Transformer with the deep clustering algorithm DCSS to learn meaningful representations with well-separated clusters. In a controlled Minecraft session with 26 players, the method discovers 23 distinct behavioral patterns that generalize across the studied players, further refining structures present in self-supervised representations into clearly separable clusters. We group the clusters into seven interpretable categories covering stationary, roaming, travel, mining, base work, logging, and farming behavior.

Mon 12 OctMachine LearningArtificial IntelligenceHuman-Computer Interaction
The gist
Finding patterns in how people play open-ended games is hard because there are no clear goals or labels. The authors combined a language prediction AI with a clustering method to group player actions into distinct categories. Using Minecraft data from 26 players, they found 23 different behavior patterns that represent common activities like mining and farming. These patterns help turn complex player actions into easy-to-understand groups.
Open → 2610.16322v1

GenRevisit improves text to image generation by revisiting earlier results

Look Back to Move Forward: Learning to Revisit for Agentic Compositional Image Generation

Abstract: Text-to-image models have made remarkable progress in visual fidelity and instruction following, yet complex compositional generation remains challenging. Existing agentic approaches address this limitation through iterative generation and editing, adapting their actions based on interaction history. However, they typically fix the continuation state (i.e., the image from which refinement proceeds) to the latest image. Since iterative editing is not necessarily monotonic, the agent may continue refining from the latest image even when it has already degraded. In this work, we introduce GenRevisit, an agentic framework that extends action selection to joint continuation-state and action selection. The agent can not only use interaction history to adjust editing instructions but also select an image candidate to edit, jointly deciding where to continue from and how to refine. We train GenRevisit with SFT followed by agentic reinforcement learning. To address the coarse credit assignment of final outcome reward in GRPO, which assigns the same trajectory-level advantage to all actions, we further propose Normalized Action Credit Assignment (NACA) to redistribute positive advantage according to each action's contribution to reducing the remaining objective. On GenEval2, GenRevisit achieves GM scores of 84.3 and 74.4 with Qwen-Image-2512 and Z-Image-Turbo, surpassing the strongest baselines using the same generators by 12.7 and 10.9 points respectively. GenRevisit achieves state-of-the-art performance on GenEval, GenEval++, and GenEval2 among baselines.

Mon 12 OctComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Creating detailed images from text instructions can be hard, especially when making complex scenes step-by-step. Existing methods usually keep improving only the latest image even if it got worse. This paper introduces GenRevisit, a system that can choose not just how to edit but also which earlier image to go back to when refining. This helps it make better pictures overall. The authors also developed a way to better teach the system which editing steps matter most.
Open → 2610.16224v1

Agent social dynamics improve teamwork in large language models

Agent Sociodrama: Social-Dynamics-Guided Persona Recasting for LLM Agent Teams

Abstract: Large language model (LLM) agents are increasingly deployed as teams, yet they fail in characteristically social ways: information holders stay silent, dominant speakers anchor groups on wrong answers, and norm violations go unsanctioned. We present Agent Sociodrama, a framework for modeling and validating evolving social dynamics in LLM agent teams. Under fixed personas, agents' emotional states and directed, asymmetric relationships are updated every round by a unified external LLM judge and shape their subsequent interactions. Across six LLM backbones and five social scenarios, we assess social fidelity through classical social-theory patterns and agreement with human judgments. The resulting trajectories exhibit structured social patterns and model-specific differences. We then introduce Trajectory-Guided Persona Recasting (TPR), which diagnoses group-dynamic failures from interaction transcripts and social trajectories and recasts agent personas before rerunning the task. Across four collaborative benchmarks, TPR improves performance from both heterogeneous and randomly initialized agent persona compositions, yielding up to 83.3%p of accuracy improvement over the initial casting. On representative distributed-information cooperation and mixed-motive bargaining tasks, we outperform SOTOPIA and AgentVerse in three of four comparisons, by up to 37.5%p in Pareto rate. These results show that validated social trajectories provide actionable signals for repairing LLM agent teams.

Sun 11 OctArtificial IntelligenceComputation and LanguageMultiagent Systems
The gist
Teams of large language model agents can struggle socially, like staying quiet or being overly dominant, leading to mistakes. The authors created Agent Sociodrama, a system that tracks and updates the feelings and relationships of these agents to better mimic real social interactions. They also developed a way to fix team problems by changing agents’ roles based on these social patterns. Their approach improved team performance significantly in tasks requiring cooperation and negotiation. This shows that understanding and managing agent social dynamics helps build better AI teams.
Open → 2610.15788v1

Game of cycles on trees reveals hidden nim heap strategy flaws

Nim heaps in the Game of Cycles: the parity conjecture fails on trees

Abstract: The Game of Cycles, invented by Francis Su, is a two-player game in which the players take turns drawing arrows on the edges of a plane graph, never creating a sink or a source. On a tree only the sink-source rule matters, and the player who makes the last move wins. Several authors conjectured that on a tree the second player wins exactly when the number of markable edges is even. We show that this parity conjecture is false, and we explain why. The explanation is a hidden game of Nim: a path segment that is blocked by an arrow at one end and free at the other behaves exactly like a nim heap whose size is its length. Combined with a calculus for cutting and gluing trees at vertices next to leaves, this shows that the conjecture fails as soon as a single tree has Grundy value at least 2. The smallest counterexamples have 15 vertices. Trees with Grundy values 2 and 4 first appear at 17 vertices, and every value up to 63 occurs, which answers a question of Fokkink and Zandee. We also refute a related conjecture of Zandee. We then look closely at spiders. The spiders S(2,3,z) violate the conjecture for every z >= 14. The Grundy values of S(1,2j,z) are given by an exact formula governed by binary carries. For 99 pairs (x,y), the value of S(x,y,z) is eventually the parity of z. On the positive side, the conjecture holds for all trees in which every thread has at most two edges, and this bound is sharp. Along the way we prove a twin-branch reduction, give an algorithm that is polynomial for spiders with a fixed number of legs, and collect the questions that we could not answer. The boldest asks whether every non-negative integer is the Grundy value of some tree.

Sat 10 OctDiscrete Mathematics
The gist
The Game of Cycles is a two-player game played on graphs where players draw arrows without creating certain patterns. Many thought that on tree-shaped graphs, the second player would win if the number of valid edges was even. The authors show this idea is wrong because parts of the tree act like a Nim game, a well-known strategy game, making the outcome more complex. They describe when the original idea fails, how to calculate outcomes for various trees, and identify structures where the old rule holds or breaks.
Open → 2610.15145v1

Depth recurrent model transfers knowledge across new rule sets in puzzles

Knowledge transfer between simple discrete worlds

Abstract: Adapting to a new world and reasoning correctly about which outcomes are possible under rules one has not met before is a basic capacity underlying general intelligence. We study it in small discrete worlds: sets of grid configurations consistent with a shared set of rules, concretely Sudoku-like puzzles built from a common base and a handful of extra rules. We train a single depth-recurrent model on many combinations of rules and test it at four levels of novelty: a new puzzle, a new combination of known rules, a pairing of rules never seen together, and a rule instance not seen at all during training. The model receives the active rules either as a symbolic description or as two solved examples, and a model that gets no rule information is used as a baseline. At recombining rules it was trained on, the description matches or exceeds examples ($99\%$ against $95\%$ on new combinations). On rule instances whose components never co-occurred in training, the description falls below the no-information baseline while examples stay above it. The framework allows us to test many such generalization regimes in more systematic way than benchmarks such as ARC-AGI and provides new ground for evaluating depth-recurrent reasoning models, which are typically tested on saturated Sudoku benchmarks.

Sat 10 OctArtificial Intelligence
The gist
Understanding how to adapt to new rules is a basic part of intelligence. The authors studied this by training a model to solve puzzles like Sudoku, but with different combinations of rules. They tested how well the model could handle new puzzles, unseen rule combinations, or entirely new rules based on descriptions or examples. They found that descriptions worked best when recombining known rules, but examples helped more when the model encountered completely new rule instances. This research offers a way to better test how models learn and generalize in reasoning tasks.
Open → 2610.15081v1

OpenSocialJax tests if AI agents adapt to hidden social rules

OpenSocialJax: Evaluating Social Adaptation in Sequential Social Dilemmas with Open-Ended Environmental Dynamics

Abstract: Sequential social dilemma benchmarks capture diverse social interactions, but rarely test whether agents can infer hidden environmental rules through repeated interaction while adapting to other agents. We introduce \textbf{OpenSocialJax}, which extends Clean Up and Commons Harvest across an open-ended distribution of latent environment configurations, systematically varying spatial layouts and hidden rules governing tool crafting, payoffs, and resource dynamics. Each episode samples one configuration from tens of millions of possibilities and holds it fixed across five trials. We evaluate eight large language models, including three closed source models and five open source models. Our evaluation tests whether models can discover hidden rules and adapt to other agents in homogeneous and mixed teams. We find that rule discovery often improves performance but does not reliably sustain cooperation, as the cleaning burden becomes concentrated among fewer agents in OpenCleanup and every team eventually exhausts the shared resource in OpenHarvest. In our mixed arena, one cooperative agent was able to sustain the public good in OpenCleanup at a cost to its own return, but could not prevent resource depletion in OpenHarvest. Together, these results highlight the difficulty of adapting jointly to unfamiliar environmental dynamics and the changing behavior of other agents.

Fri 9 OctMultiagent Systems
The gist
Many AI systems struggle to figure out hidden rules in changing social settings where they interact with others multiple times. The authors created OpenSocialJax, a test system where AI agents face millions of different hidden environments that affect how they can work together or compete. They tested several large AI language models to see if they could learn these hidden rules and cooperate with others. While some agents discovered important rules and improved their play, cooperation was often unstable, with resources running out or cooperation burdens falling unevenly on some agents. This work shows how hard it is for AI to adapt together in complicated, changing social worlds.
Open → 2610.13710v1

Data-driven method simulates individual decisions in cooperation games

A data-driven heuristic-ensemble method for behavioural inference in collective-risk dilemma experiments

Abstract: The collective-risk dilemma has become a paradigm for studying cooperation in a wide variety of social experiments, initiatives that generate increasingly rich datasets describing individual actions over successive decision-making processes. Beyond the purely descriptive analysis of such empirical datasets, a methodological framework is required to interpret and reproduce the observed dynamics, a scheme that may be skewed by exogenous biases. Here, we introduce a data-driven, non-parametric method for simulating individual decisions together with a validation protocol for assessing the fidelity level of the outcomes they generate. Our methodological contribution is based on an empirical heuristic ensemble: agents are represented by a finite set of behavioural heuristics, probabilities conditioned on different observable features of the game state, endowed with a hard-voting arbitration that determines their per-round final decisions. This reproducible generative framework allows for behavioural inference in different collective-risk dilemma setups: Behavioural heuristics are seeded directly from empirical data assessing conditional probabilities, without a priori assumptions; a plurality vote with uniform random tie-breaking resolves between competing heuristics each round, adding no free parameters; validation follows a pattern-oriented approach, comparing synthetic and empirical macro-indicators against single-heuristic and uniform-random baselines; synthetic data generated allow exploration of scenarios or experimental setups that have not been empirically realised; as a worked example, we instantiate our methodological approach on the xAire citizen science collective-risk dilemma experiment run in Barcelona.

Fri 9 OctComputers and Society
The gist
People often face situations where working together matters, like in climate change challenges. This paper explains a new way to understand and mimic how individuals make choices in such group problems by using actual data about their past actions. The authors create a system that uses simple decision rules seen in real life and combines them to predict future behaviors without guessing any unknown details. This method can also help test scenarios that haven't been tried in real experiments yet.
Open → 2610.13595v1

Chat assistant helps explore and modify software in 3d visualization

A Chat Assistant for Software Exploration in a 3D Software Visualization

Abstract: We present a chat assistant for interactive software exploration, embedded in the 3D software visualization tool ExplorViz. The assistant builds upon current Large Language Models (LLMs) and enables users to ask questions about the currently visualized software system and trigger actions that change the visualization through natural language. We integrate the chat assistant in our ExplorViz frontend using the CopilotKit libraries such that probabilistic LLMs are combined with deterministic and tool-based actions similar to implementations using the Model Context Protocol (MCP). The chat assistant is also enabled to restructure the software system by adding, removing, or modifying parts of the software system in the visualization. An empirical experiment with eleven participants evaluated both perceived comprehension support and the tool calls that were triggered by the chat assistant. Participants rated the assistant's generated summaries and explanations as largely correct. They also reported high usability for actions like highlighting entities in the visualization and the creation of new color themes. In contrast, open-ended chat-assisted software restructuring in the visualization showed mixed results. This suggests a need for stronger guardrails for the employed LLM and better incorporation of user feedback. Overall, the assistant was perceived as usable and promising for reducing interaction overhead during exploratory program comprehension tasks. We provide a video presenting the chat assistant's use and a reproduction package of the software system that was used in our evaluation.

Wed 7 OctSoftware Engineering
The gist
Understanding complicated software can be hard, so the authors built a chat assistant that works inside a 3D software viewer called ExplorViz. This assistant answers questions and changes the visualization based on what users say in natural language. People tried it out and found it useful for getting summaries and highlighting parts of the software, but changing software structure was harder and worked less well. The authors show that this assistant can make exploring software easier, though it needs better controls and user feedback for complex changes.
Open → 2610.09901v1

Complexity of computing Nash equilibria in Colonel Blotto games revealed

The Complexity of Computing Nash Equilibria in Colonel Blotto Games

Abstract: We study the complexity of Nash equilibrium computation in discrete Colonel Blotto games. For two-player general-sum Colonel Blotto with monotonic piecewise-constant battlefield payoffs, we show that computing an inverse-polynomial approximate Nash equilibrium is PPAD-hard, even with only two battlefields and a constant number of pieces per battlefield, thereby resolving an open question of [KPF+25]. Allowing more battlefields, the hardness persists when every battlefield payoff is $2$-piecewise constant with respect to either player's allocation. A general PPAD-membership theorem for multiplayer Blotto with arbitrary local reward functions then implies PPAD-completeness for both hardness results. Motivated by fixed-rank bimatrix games, we then identify a tractable frontier within two-player general-sum Colonel Blotto. If the social payoff has rank-$r$ structure, then, for every fixed $r$, an $\varepsilon$-Nash equilibrium can be computed in time polynomial in $B_1,B_2,k$, and $1/\varepsilon$. Thus constant-rank two-player Colonel Blotto remains tractable despite its exponentially large pure strategy spaces. Finally, we study multiplayer winner-takes-all Colonel Blotto with player-specific battlefield values and uncover a sharp tie-breaking frontier. If every highest bidder receives her full battlefield value, an exact pure Nash equilibrium can be computed in polynomial time for arbitrary binary-encoded budgets. In contrast, under ordinary equal splitting among highest bidders, we prove that computing an inverse-polynomial-accuracy Nash equilibrium is PPAD-hard even with only five players. This resolves an open question posed in concurrent work by Bichler and Ghosh [BG26], who established PPAD-hardness in the same player-specific equal-splitting setting when the number of players grows with the instance and asked whether hardness persists for a constant number of players.

Mon 5 OctComputer Science and Game TheoryComputational Complexity
The gist
Computing a stable outcome (Nash equilibrium) in the Colonel Blotto game, where players allocate resources across battlefields, can be very hard. The authors prove that even with few battlefields and simple payoff setups, finding approximate equilibria is computationally difficult (PPAD-hard). However, they identify special cases with structured payoffs where equilibrium can be found efficiently. They also show that how ties are broken among players dramatically affects whether equilibria can be computed easily or not.
Open → 2610.05956v1

Learning strategies from preference comparisons in continuous games

Learning in Continuous Games from Pairwise Preference Feedback

Abstract: We study learning in continuous games when players receive only pairwise preference feedback, revealing which of two actions is preferred but neither payoff values nor preference magnitudes. We first show that standard external regret and coarse correlated equilibria (CCE) are not identifiable from this ordinal information: the same sequence of play can incur zero and linear regret in two ordinally equivalent games, while the distributions that remain CCE across all cardinal representations consistent with the same preferences are exactly those supported on pure Nash equilibria. Motivated by this gap, we develop a first-order ordinal theory based on normalized unilateral preference directions, introducing an ordinal directional regret benchmark and corresponding equilibrium notions. We show that block-normalized pseudogradient dynamics achieve sublinear ordinal regret and, under additional structure, Nash-convergence guarantees. We then use a single-comparison estimator to implement these dynamics from finite pairwise comparisons. With one comparison per player and round, the resulting algorithm achieves sublinear finite-resolution ordinal regret against arbitrary opponent behavior and, in ordinal potential games, almost-sure last-iterate convergence to the Nash set. Our results provide regret, dynamics, and equilibrium guarantees directly from preference feedback without reconstructing cardinal utilities.

Sun 4 OctComputer Science and Game TheoryMachine Learning
The gist
This paper looks at how players can learn to make better decisions in games where they only know which choice is preferred between two options, not how much better it is or the actual payoff values. The researchers found that traditional measures of learning success don’t work with just this kind of preference information. So they developed a new way to measure and improve learning based solely on these preference comparisons, leading to guaranteed improvements over time and better predictions of game outcomes. Their method can learn efficiently from very limited feedback, without needing to know exact scores or utilities.
Open → 2610.05428v1

Single-image system creates interactive 3D tabletop scenes with moving parts

ArticuTable: Generating Instance-Level Interactive Rigid-Articulated 3D Tabletop Scenes from a Single Image

Abstract: Embodied agents benefit from 3D environments that combine visual fidelity to real-world observations with physical interactivity. Existing single-image tabletop reconstruction methods recover plausible scene geometry but typically represent objects as monolithic rigid bodies, limiting interaction to whole-object rigid motion and precluding executable part-level articulation. Meanwhile, recovering a scene layout consistent with the input view remains challenging because a single observation may admit multiple plausible pose-scale configurations. We present ArticuTable, a single-image 3D tabletop reconstruction framework that recovers both executable part-level articulation and an input-view-consistent scene layout. For object modeling, we introduce generation-robust articulation modeling (GRAM), which combines joint fitting guided by a multimodal large language model with semantic state reasoning to recover reliable joint parameters and valid motion ranges from imperfect monolithic proxy meshes, thereby converting them into executable articulated assets. For scene layout, we introduce progressive semantic-geometric scene registration (PSGSR), which progressively narrows the pose-scale search space under complementary metric, planar, and input-view constraints and resolves orientation ambiguity through structure-aware semantic correspondences, yielding a scene layout consistent with the input view. We further contribute ArticuTable-100, a curated collection of 100 simulation-ready tabletop scenes. Extensive evaluation, including a user study, demonstrates strong performance across visual fidelity, input-view consistency, articulation quality, physical plausibility, and simulation readiness.

Sun 4 OctComputer Vision and Pattern Recognition
The gist
Many 3D models from single images treat objects as simple solid pieces, which makes it hard to simulate realistic movements like opening a drawer. The authors present ArticuTable, which can turn one photo of a tabletop scene into a detailed 3D scene where parts of objects can move naturally. They address challenges in guessing exact positions and sizes from one view and teach the system to understand how parts connect and move. They also provide 100 example scenes ready to use in simulations. Their tests show the system produces visually accurate, physically plausible scenes that behave well in interactive settings.
Open → 2610.05249v1

Human defenders adapt differently than ai in cloud cyber defense games

Bounded Reasoning: Cognitive Hierarchy in Human-versus-AI Cyber Defense

Abstract: Human-agent evaluations often compress interaction into a single performance score, even when human and automated policies adapt differently over time. We study this in a sequential cyber-defense game on an attack graph, where a human or reinforcement-learning defender protects cloud assets against a Deep Q-Network (DQN) attacker. We compare four defender settings: a human reward-only game operationalizing the DQN information structure, a human reward-plus-transition game operationalizing the Cognitive Hierarchy Theory-driven DQN (CHT-DQN) information structure, an automated DQN defender, and an automated CHT-DQN defender. In the reward-only game, participants receive payoff and reward feedback. In the reward-plus-transition game, they also see attacker-aware transition probabilities from the CHT-DQN model. Across 80 Mechanical Turk participants and matched automated simulations, human defenders adapted to outcomes in a way the automated defenders did not: they were more likely to reselect a node after a successful defense than after a failure, in both games, an asymmetry we interpret as consistent with Prospect Theory and Cumulative Prospect Theory. The 40-round average also mixes early rounds, where the DQN attacker acts mostly at random, with late rounds, where it mostly exploits; in the final stage, mean protection ranks the reward-plus-transition human game above the reward-only human game, then the automated CHT-DQN defender, then the automated DQN defender, an ordering the overall mean hides. By contrast, the reward-plus-transition game does not produce a statistically reliable overall gain in weighted data protection over the reward-only game. These results suggest that evaluating human-agent cyber-defense systems only by an averaged task score can miss behaviorally meaningful differences in adaptation, action allocation, and bounded human reasoning.

Sun 4 OctCryptography and SecurityHuman-Computer InteractionMachine Learning
The gist
This paper examines how humans and AI systems defend cloud computer networks from attacks in a game setting. The researchers found that humans change their defense choices based on past success or failure, while AI defenders do not show this pattern. Adding information about the attacker’s likely moves improved human performance late in the game but did not increase overall protection scores significantly. The results highlight that just looking at average performance scores can miss important differences in how humans adapt and think during cyber defense.
Open → 2610.04878v1

Competing fires spread on signed graphs to maximize same color reach

Burning Signed Graphs

Abstract: We introduce and analyze a new model of graph burning, in which two competing fires (coloured yellow and green) ignite vertices of a given signed graph and propagate along its edges. The boolean sign of an edge determines whether a fire spreading along the edge changes colour or not. In each step, a player ignites a new vertex in a colour of their choice, while previously activated fires continue to spread. Given a signed graph $Γ$, the objective is to burn the maximum possible number of vertices in a single colour; the optimal achievable value is called the plurality number of $Γ$. We express the plurality number through Hamming distances to a binary code associated with $Γ$. In particular, the minimum plurality number over the switching class of $Γ$ equals the number of vertices minus the covering radius of this code. Under certain conditions on the signature, we determine exact values of the plurality number of signed paths. By contrast, we prove hardness results for multiple variants of the problem of determining or approximating the plurality number.

Thu 1 OctDiscrete MathematicsComputer Science and Game Theory
The gist
This paper studies a puzzle where two fires, each with a different color, spread across a network of connected points. The connections between points have signs that decide if a fire changes color as it spreads. Each turn, a player starts a new fire of their chosen color, and the fires continue growing. The goal is to see how many points can be covered by fires of one color, described by a number called the plurality number. The authors connect this puzzle to a type of code and explore how hard it is to figure out the best way to win.
Open → 2610.02506v1

Adaptive virtual reality system remembers user layout preferences

SPHERE: Adaptive VR Indoor Scene Generation via LLM-Enhanced Spatial Preference Learning and Human-in-the-Loop RL

Abstract: While Large Language Models (LLMs) advance 3D indoor scene synthesis, current pipelines fail to retain user-specific preferences across sessions, making immersive authoring a repetitive and physically fatiguing process. We present SPHERE, an adaptive VR generation framework that transforms isolated synthesis into continuous human-AI co-creation. SPHERE extracts persistent spatial preferences from natural multimodal interactions (speech and controller edits). To ensure geometric resilience against spatial distortions, it abstracts these raw edits into hierarchical constraints modeling both local functional and global topological contexts. Furthermore, a human-in-the-loop reinforcement learning mechanism dynamically updates retrieval policies based on the user's final edited scenes. A mixed-design user study ($N=42$) and an offline ablation demonstrate that SPHERE significantly reduces corrective edits and physical demand, preventing bias toward shallow object-level traits to yield geometrically resilient, profile-aligned layouts. Ultimately, SPHERE demonstrates how capturing demonstrated spatial logic enables controlled spatial adaptation, establishing a reliable, governed human-AI collaboration framework for immersive authoring. Project page and source code will be available at: https://github.com/hyeonmin11/SPHERE

Thu 1 OctArtificial IntelligenceHuman-Computer Interaction
The gist
Designing indoor virtual spaces can be tiring because current tools don’t remember what users like from earlier sessions. The authors created SPHERE, a virtual reality tool that learns and remembers spatial preferences using natural user interactions like speech and hand movements. It uses smart models to keep designs stable and improves over time by learning from corrections users make. This approach helps users create personalized and consistent virtual room layouts with less effort and fewer mistakes.
Open → 2610.02023v1

Conditioning language models on social values improves human-like choices

Conditioning LLMs on Social Value Orientation improves behavioural alignment in a sequential social dilemma

Abstract: Large language Models (LLMs) are increasingly used to simulate human decision-making, yet their outputs often under-represent human behavioural heterogeneity. We investigate whether conditioning LLMs on Social Value Orientation (SVO, a measure of how individuals value their own outcomes relative to others') can better reproduce human behaviour in a sequential social dilemma. Using experimental data from two variants of the Centipede Game (CG) as reference, we compare the default behaviour of eight LLMs with behaviour generated after conditioning them on SVO profiles drawn from the human sample. We find that the default strategies vary substantially across models, but are generally distant from the reference distributions. However, conditioning them on SVO profiles systematically steers their strategic behaviour, improving alignment with the human reference by up to 70% with respect to the default. Across models, higher induced SVO values decrease the probability of stopping the game, reproducing the relationship between prosociality and cooperation observed in human behaviour. Together with the sensitivity of LLMs' elicited SVO to prompt and order effects, these results suggest that the usefulness of SVO for behavioural simulation does not depend on LLMs possessing stable social preferences, but rather on their ability to map social preferences onto corresponding strategic choices.

Thu 1 OctComputer Science and Game Theory
The gist
Large language models often struggle to mimic the variety of human decision-making in social situations. The authors found that by telling these models about a person's social values—how much they care about themselves versus others—they can make the models behave more like real people in a game setting. This approach made the models' choices much closer to actual human behavior, especially showing how more caring individuals tend to cooperate more. The results suggest the models don’t need fixed social feelings but can match social values to actions through prompts.
Open → 2610.01667v1

Video world model enables persistent interaction with generated objects

Oneira: From Open-Ended Generation to Open-World Interaction in Video World Models

Abstract: Generative video world models can now synthesize open-ended environments that agents can navigate and interact with in simple ways. Yet open-ended generation does not imply full interaction: as a generated world expands, newly created content through navigation should expand what the agent can act upon, and as the agent changes the world, those changes should become persistent parts of the environment rather than transient visual effects. We characterize these two requirements as Open-World Interactivity, where newly generated or encountered entities are incorporated into the actionable world, and Persistent State, where interaction outcomes are committed to the world state and continue to influence subsequent observations and interactions. We present Oneira, an interactive video world model that closes the loop between generation and interaction through an explicit, extensible world state managed by a coding agent. Given the current observation and an action or high-level goal, the agent reads the world state, grounds the relevant entities, plans the interaction, and writes its outcome back into a world state table. When exploration reveals new objects, the agent incorporates them from generated observations, allowing the interaction space to expand with the generated world. Meanwhile, previously induced state changes are carried across video segments, making the consequences of interaction persistent parts of subsequent world evolution. The updated world state is rendered along the camera action trajectory into a coarse conditioning video, from which a video generator fills in the appearance, motion, and interaction details not represented in the state. Experiments show that Oneira enables direct and consistent interaction with newly generated objects, while preserving the effects of prior interactions over long horizons. Project page: https://madaoer.github.io/projects/oneira

Thu 1 OctComputer Vision and Pattern Recognition
The gist
Creating virtual worlds where agents can explore is possible, but making sure they can truly interact with new objects and have lasting effects is harder. The authors developed Oneira, a video model that keeps track of an explicit world state to let agents not just move around but also change things permanently. When the agent finds or creates new items, it adds them to the world so interactions grow richer over time. This approach makes the virtual environment more realistic and consistent by remembering past changes through long sequences.
Open → 2610.01614v1

Framework predicts audio visual complexity in virtual environments

MAV-C: A Framework for the Joint Objective Estimation of Audio-Visual Complexity in Immersive Virtual Environments

Abstract: We present the Motion-Aware Audio-Visual Complexity Metric (MAV-C), a reference-free framework for the joint objective estimation of audio-visual complexity. The metric combines entropy-based audio features (temporal, spectral, and spatial) with visual features (Sobel gradient magnitude, chromatic uniqueness, and optical flow) via a parametric fusion stage, producing a continuous joint complexity score CAV (t) [0,1]. We validate MAV-C on two datasets: a controlled synthetic corpus (SYN) of stimuli with known signal characteristics and a naturalistic gameplay corpus (GAM) of 60 clips drawn from the SAFEPLAY-X dataset. On SYN, the metric exhibits strong validity: the audio score CA and visual score CV are each insensitive to changes in the opposite modality (CoV < 0.003), the joint score CAV spans [0.00,0.90] across all parameter combinations, and single-axis feature sweeps produce monotone trajectories (Spearman up to 0.995). On GAM, CV differs significantly across content categories (Kruskal-Wallis p = 0.021) while CA does not, and the two sub-scores are uncorrelated (r = 0.03), confirming they operate on independent signal dimensions. OFAT sensitivity analysis identifies a two-tier parameter hierarchy, with modality balance (wa) and visual regularization (v) as most significant tunable parameters. Full subjective calibration is planned as future work.

Wed 30 SeptSound
The gist
This paper introduces a new way to measure how complicated sounds and visuals are together in virtual reality scenes. The method looks at different features like sound patterns and visual motions and combines them into a single score that says how complex the scene is. The authors tested their approach using both made-up examples with known changes and real gameplay clips, finding that their scores reflect differences in visual content well and treat audio and video separately. This tool can help understand and maybe improve how virtual experiences are designed.
Open → 2610.00754v1

Vr movement smoothing framework improves balance during locomotion

Sensing Instability, Adapting the Scene: A Real-Time Movement-Smoothing Design Framework for Stable VR Locomotion

Abstract: Users experience different balance challenges while standing, walking, and turning in virtual reality (VR), yet most locomotion techniques apply the same visual behavior regardless of movement state. We present a real-time movement-smoothing design framework in this paper that organizes visual adaptations according to movement-specific balance demands. The framework introduces three design strategies targeting standing, walking, and turning, illustrating how state-aware visual adaptations can support postural stability during locomotion. This paper focuses on the framework design and implementation, while a user study is planned as future work. Our work guides the development of future context-aware VR locomotion systems that better support safe and comfortable navigation.

Wed 30 SeptHuman-Computer Interaction
The gist
Moving in virtual reality can make users feel unsteady or off balance, especially when standing, walking, or turning. The authors created a system that changes what you see in VR depending on how you move, to help keep your balance better. They designed special visual changes for each movement type to make VR walking and turning feel more stable. They have built the system but haven’t tested it with users yet. Their work aims to make future VR experiences safer and more comfortable.
Open → 2610.00643v1

Anthrodial creates more human-like social interaction for language models

AnthroDial: Benchmarking LLM Anthropomorphism in Autonomous Social Interaction

Abstract: Large language models (LLMs) are increasingly deployed as social agents, yet credible human-like interaction requires more than fluent responses or persona consistency. Agents must autonomously decide whether, when, and how to communicate while adapting to evolving contexts, goals, and relationships. Existing research, however, lacks a unified approach to enabling, evaluating, and improving such capabilities in continuous, open-ended interaction. We introduce AnthroDial, a unified framework for developing anthropomorphic social agents from three complementary aspects: MindFlow, a lightweight interaction harness that enables autonomous, asynchronous, and adaptive communication through a dynamic Mind Buffer; CAPS-Eval, a theory-grounded framework for evaluating cognitive, affective, and behavioral dimensions of anthropomorphic interaction; and a scalable training paradigm that combines SEEDS for environment expansion with DiAPO for adaptive capability optimization. We further construct evaluation datasets covering everyday communication, game interaction, and long-horizon character interaction. Extensive experiments across diverse models and scenarios demonstrate improved interaction autonomy and naturalness, validate the reliability, discriminativeness, and agreement with human rankings of CAPS-Eval, and confirm the effectiveness of our training paradigm. Together, these components provide a unified framework for developing credible human-like social agents in open-ended interaction.

Tue 29 SeptComputation and Language
The gist
It's hard for AI agents to interact socially like humans because they must know when and how to communicate naturally over time. The authors created AnthroDial, a set of tools and methods that help language models chat more like people by managing conversations independently and adapting to changes. They also made ways to measure how well these AI agents understand thoughts, feelings, and behaviors during talks. Their tests showed AnthroDial helps models act more naturally and makes improvements easy to spot. This gives a solid foundation for building better AI conversational partners.
Open → 2609.37853v1

Graph structures that always allow fair division orientations found

A Polynomial Time Characterization For Strongly EFX Orientable Graphs

Abstract: Discrete fair division is the problem of dividing a discrete set of goods among agents in a fair manner. In this setting, one of the most sought-after notions of fairness is envy-freeness up to any good (EFX). In 2023, Christodoulou, Fiat, Koutsoupias, and Sgouritsa introduced the idea of a graphical valuation, where the fair division problem is represented by a simple graph where vertices are the agents and the edges are the goods, and each vertex only values incident edges. They showed that an EFX allocation always exists, while determining the existence of an EFX orientation is NP-hard. They posed an open question of determining which graphs always admitted an EFX orientation regardless of valuation. These graphs, called strongly EFX orientable graphs, were first studied by Zeng and Mehta in 2025, who demonstrated that all such graphs have chromatic number at most 3, and bipartite graphs always admit an EFX orientation regardless of valuation. In this manuscript, we finish resolving this question by giving a polynomial time characterization of strongly EFX orientable graphs. In particular, we show that a connected graph $G$ is strongly EFX orientable if and only if either of the following is true: (1) $G$ is bipartite, or (2) the block decomposition of $G$ contains exactly one nonbipartite block $B$, and there exists a vertex $v \in B$ such that the degree of $v$ within $B$ is 2 and $G-v$ is bipartite. This proof was discovered by AI, with human intervention to break the problem into the appropriate subproblems.

Tue 29 SeptComputer Science and Game Theory
The gist
Dividing things fairly among people when each values different items can be complicated. This paper focuses on a type of problem where goods and people are represented as a graph, and fairness means no one envies another based on edges they value. The authors provide a clear and efficient way to tell which graphs always allow a fair division orientation, completing previous work that left this question open. Their method identifies such graphs by looking at how the graph can be broken down and certain special properties of its parts.
Open → 2609.36498v1

System provides quick obstacle solution feedback for 3D game design

Providing Rapid Design Feedback for 3D Obstacle Course Games Using Constrained Solvability Queries

Abstract: We present a system that aids the design of 3D obstacle course games by providing designers with rapid feedback on how obstacles can be solved. Our core contribution is a system for querying for solutions (sequences of player actions) to an obstacle that adhere to designer-specified constraints (e.g., avoid a region, travel through a given waypoint, only perform two jumps, etc.). To solve a wide range of obstacle designs quickly, we author a high-performance implementation of the GoExplore algorithm for exploratory search, and guide search with an obstacle solving agent trained offline using reinforcement learning (RL). To further accelerate search, the system carries out exploration using a custom GPU-accelerated obstacle course game simulator that generates playthrough experience at nearly 14,000$\times$ real time, 60-fps gameplay. Through design studies, we demonstrate that the use of constrained solvability queries in a rapid design loop is sufficiently expressive to help designers understand ways an obstacle can be solved or why it cannot be solved. We also show how the tool can let designers answer higher-level questions such as identifying undesirable solution paths and assessing the difficulty of solutions. This allows them to pursue new design directions they did not originally anticipate. Human playtesting of obstacles designed using our system confirms that human players indeed play the obstacles in the manner the designers intended. We release code for our interactive tool, simulator, training setup, and procedural level generation system at https://zandermajercik.github.io/interactive-obstacle-course-feedback/.

Mon 28 SeptGraphics
The gist
Designing challenging 3D obstacle courses can be slow because designers need to know if and how players can complete obstacles. The authors created a system that quickly finds ways to solve these obstacles while following specific rules set by the designer, like only jumping twice or avoiding certain areas. Their system uses a fast game simulation and smart search methods to test many possible solutions very quickly. Designers can use this tool to understand all the possible ways an obstacle can be solved or why it can’t be, helping them make better games that play the way they want.
Open → 2609.36225v1

Bidirectional motion and text generation improves language and movement modeling

BiMoGen: Bidirectional Motion-Text Generation via Unified Masked Discrete Diffusion

Abstract: Text-to-motion generation and motion-to-text captioning are two fundamental tasks in human motion modeling, both grounded in the same underlying motion-text correspondence. Existing unified approaches mostly rely on autoregressive modeling, which imposes a fixed generation order and is therefore poorly suited to the bidirectional dependencies between language and motion, allowing early prediction errors to persist as fixed context and degrade both temporal coherence and cross-modal consistency. Masked discrete diffusion, which models sequences through iterative bidirectional prediction, offers a natural remedy. We therefore propose BiMoGen (Bidirectional Motion-text Generation), a unified masked discrete diffusion framework for bidirectional motion-text modeling. To stabilize training, we design Decoupled Uni- and Cross-Modal Training, in which masked pretraining first establishes cross-modal correspondence on paired motion-text sequences, after which supervised fine-tuning specializes the model for bidirectional generation. Masked diffusion nonetheless introduces its own source of error, as the model is trained on clean ground-truth context yet encounters self-generated and potentially erroneous context at inference, with errors committed under heavily masked states propagating through subsequent steps. We further introduce Generation-Aware Self-Correction that exposes the model to its own predictions during training and applies correction passes at early sampling steps to revise unreliably committed tokens. Extensive experiments on HumanML3D and KIT-ML demonstrate competitive performance on both tasks, validating the effectiveness of the proposed two-stage training and self-correction designs. The project page is available at https://wengwanjiang.github.io/BiMoGen-Page.

Mon 28 SeptComputer Vision and Pattern Recognition
The gist
Generating text descriptions from human motion and creating motion from text are both important but challenging tasks, especially when the two need to work together. The authors propose a new method called BiMoGen that models these tasks in both directions simultaneously, using a way to predict parts of a sequence in any order to reduce errors that accumulate with one-direction models. They also add training tricks that help the model learn better and correct its own mistakes during generation. Testing showed that BiMoGen performs well on standard motion-text datasets, improving how well motion and text correspond to each other.
Open → 2609.35407v1

Solver guided rewards improve logical reasoning in language models

Rewarding Novel Deductions: Solver-guided Process Rewards for Logical Reasoning

Abstract: Logical reasoning remains a major challenge for large language models (LLMs), particularly on structured problems that require precise constraint tracking, consistency preservation, and multi-step deduction. This challenge is especially acute for small-scale LLMs, which are more prone to producing inconsistent, redundant, or brittle reasoning trajectories. Existing approaches for improving logical reasoning largely optimize for final-answer correctness, providing only weak supervision over the intermediate reasoning process. In this work, we propose SPRING: (Solver-guided Process Rewards for Novel LogIcal ReasoNing Step Generation). SPRING uses SMT solver as a training-time verifier of intermediate reasoning steps to provide process-level supervision. It introduces the notion of a novel reasoning step, namely, a step that is logically valid, consistent with the evolving reasoning state, and not already implied by previously accepted non-contradictory deductions. Based on this solver-based assessment, it designs process rewards that encourage novel inferential progress while penalizing contradictory and uninformative reasoning steps. Evaluation across three logical reasoning benchmarks, ZebraLogic, AR-LSAT, and Knights and Knaves, and four LLMs shows that SPRING consistently outperforms base LLMs, outcome-only reward baselines, and Logic-LM. On ZebraLogic, SPRING improves puzzle accuracy by up to 49.71 and 15.43 points over the base LLM and strongest outcome-only baseline, respectively. On AR-LSAT, it improves overall accuracy by up to 64.93 and 12.14 points, respectively. On Knights and Knaves, SPRING achieves up to 93.14 puzzle accuracy and 96.05 person accuracy.

Mon 28 SeptComputation and Language
The gist
Large language models struggle with logical reasoning problems that require many careful thinking steps. The authors created a method called SPRING that uses a computer solver to check each step the model takes, rewarding new valid thoughts and discouraging repeated or contradictory ones. This makes the model better at solving puzzles by thinking more clearly and avoiding mistakes. They tested SPRING on several logic puzzle datasets and with different language models, finding big improvements in puzzle-solving accuracy.
Open → 2609.34660v1

Persona representations in large language models follow curved geometry

PersonaManifold: Revealing and Exploiting Curved Geometry in LLM Persona Representations

Abstract: Controlling persona in large language models (LLMs) at inference time is important for role-playing, personalized dialogue, and social simulation. Recent methods extract persona vectors from the model's activation space and apply Euclidean operations---addition, scaling, and linear interpolation---under the linear representation hypothesis. However, these methods themselves report systematic failures: non-orthogonal trait dimensions, asymmetric ceiling and resistance effects, and significant deviations in multi-trait composition, suggesting that the linear isotropic assumption does not hold. We propose PersonaManifold, a framework that models persona representations as points on a curved, low-dimensional Riemannian submanifold in activation space. We estimate the manifold's intrinsic geometry---local metric tensors, geodesic distances, and Ollivier-Ricci curvature---and introduce geodesic steering, which interpolates between personas along manifold geodesics rather than Euclidean straight lines. We also propose the Behavioral Similarity Triplet (BST) benchmark, which automatically generates situational questions grounded in six established psychological constructs and defines persona similarity through behavioral responses rather than self-report questionnaires. Experiments on three open-source LLMs show that persona activations form a manifold with heterogeneous curvature, geodesic distance predicts behavioral similarity more accurately than Euclidean alternatives with independent contributions from anisotropy and curvature, and geodesic steering produces more coherent intermediate personas on both our BST benchmark and external evaluations, with the advantage concentrated in high-deviation regions where the manifold deviates most from flatness.

Mon 28 SeptArtificial Intelligence
The gist
It's important for AI to act like different personalities in conversations, but this is hard because traits in AI models don't combine neatly in straight lines. The authors found that personality traits in large language models form a curved shape in their internal space, not a flat one. They created a new way to measure and move between these personas along curves rather than straight lines, which better matches how the AI behaves. They also made a new test that checks how similar two personas are based on how they respond to situations, rather than relying on typical questionnaires.
Open → 2609.34571v1

Personality shapes memory use in dialogue agents for consistent character

PersMem: Internalizing Personality into Dual-Pathway Memory for LLM Agents

Abstract: The profile of a role-playing agent usually depends on the pre-defined personality in a system prompt, whereas its memory processing pipeline, including prioritisation of stored memories and subsequent retrieval, remains independent of this personality. This separation causes the agent's memory processing to be inconsistent with the pre-defined personality, and makes it difficult to validate whether agent behaviours follow this personality. In this paper, we propose Personality-Integrated Memory (PersMem), which integrates personality into the agent's memory processing pipeline, making it consistently personality-dependent. PersMem processes memory using four steps, where the personality is mapped to operation-specific parameters controlling: (i) affective appraisal annotating emotion states of the user input; (ii) retention of previously stored memories along with the current input; (iii) passive affect-driven memory retrieval exploring memories similar to user input in semantics and personality-guided emotions; and (iv) active goal-driven memory retrieval that refines and selects passively retrieved memories for the reply. Consequently, consistency with the pre-defined personality can be examined by inspecting memory-processing traces during human-agent interactions. We evaluate these personality-dependent differences in attachment and Big Five settings. PersMem exceeds the chance baseline for four-way attachment classification by 23.1 percentage points. In Big Five dialogue comparisons, PersMem achieves 67.5% accuracy, 6.7 percentage points above a baseline using uniformly sampled memories. On CoSER, PersMem achieves an average score of 66.13, with scores of 69.33 for Character Fidelity and 84.33 for Storyline Quality. Together, these results show that PersMem produces distinguishable personality-related memory-processing patterns.

Mon 28 SeptArtificial Intelligence
The gist
Many dialogue agents use a fixed personality but handle their memories separately, which can make their reactions feel inconsistent. The authors propose PersMem, a system that makes an agent’s memory processing depend on its personality. By linking personality to how emotions are noted, memories are kept, and relevant memories are recalled, the agent behaves more consistently with its assigned character. This also allows people to check if the agent stays true to its personality during conversations.
Open → 2609.34372v1

Riftbound card game can simulate any computer with legal decks

Riftbound is Turing Complete

Abstract: Riftbound: League of Legends Trading Card Game is a trading card game about capturing and holding locations in a king-of-the-hill style contest. Originally released in China in August of 2025, and later released in the United States in October of 2025, the game has been well received for its depth and complexity. In this paper we demonstrate a facet of this complexity by providing sequences of valid game states which construct Universal Turing machines within the game. Each of these machines are constructed with tournament legal decks at the time of writing and strategies assigned are directed by the game state. We also show that given an appropriate board state the machine may be constructed and the computation may be performed in one game turn.

Sun 27 SeptComputational Complexity
The gist
Some games are more complex than they seem, and this card game called Riftbound is one of them. The authors show you can set up the pieces and use legal decks to simulate a completely universal computer inside the game. This means, within the rules and one turn, the game can perform any calculation a computer can, given the right setup. It highlights unexpected depth in the game’s design and complexity.
Open → 2609.33839v1

Capability guides environment design for better multi-step agent tasks

Skill2Env: Capability-Oriented Environment Synthesis from Skills for General Agents

Abstract: Executable environments are critical for post-training agents on tasks that require tool use and multi-step interaction, but constructing executable tasks together with their environments remains difficult to scale. Skills provide reusable domain knowledge, operational procedures, and tool-use instructions, but a substantial gap remains between the information contained in a skill and a concrete, challenging task with a complete executable environment. To address this gap, we introduce Skill2Env, a capability-oriented framework that starts from a skill and uses agent capability demands to guide task and environment synthesis. Skill2Env represents these demands through reusable difficulty patterns and instantiates them into task blueprints that specify objectives, challenges, environment facts, information boundaries, and acceptance criteria. These blueprints guide the joint construction of task instructions, execution substrates, workspaces, and rubric-based evaluators around source skills. We further propose Iterative Task Hardening, which uses solver execution evidence to identify insufficiently challenging task designs, strengthen or extend their difficulty-pattern instantiations, and revise the corresponding blueprints and environments. Using 1.5K high-scoring trajectories generated from Skill2Env environments for supervised fine-tuning, we observe consistent improvements across a broad range of agent benchmarks, demonstrating the effectiveness of capability-oriented environment synthesis for agent post-training.

Sun 27 SeptArtificial Intelligence
The gist
Creating detailed environments where AI agents can practice complex tasks is very hard. The authors designed Skill2Env, a method that starts with a basic skill and builds up a full task environment by adding challenges based on what the agent can do. They also created a way to gradually make these tasks harder if they’re too easy. Training AI on tasks from these environments helps them perform better on many different challenges.
Open → 2609.33772v1

World models learn clear action rules from videos for better prediction

VIDEAS: Distilling Explicit Action Semantics from Demonstration Videos for World Models via Prior-Guided Simulation

Abstract: World models learn internal representations of environment dynamics to predict future states, enabling agents to optimize action plans without physical interactions. However, developing world models that genuinely internalize underlying causal physical laws to explicitly reason about action preconditions and subsequent state transitions remains an open challenge. In this paper, we propose VIDEAS, a data distillation framework that transforms continuous physical dynamics from operational videos into explicit action semantics for foundation models. Specifically, it deconstructs visual demonstrations into discrete action trajectories and utilizes advanced vision-language models (VLMs) to extract structured knowledge encapsulating action preconditions and effects. To ensure physical consistency, we introduce a prior-guided trajectory simulation mechanism grounded within a text-based environment to rigorously validate the extracted knowledge. Notably, we incorporate negative trajectories to enrich knowledge completeness and enhance data diversity to mitigate cognitive bias. Furthermore, we present VIDEAS-WM, an 8B/9B-parameter suite of language-based world models trained on 34K high-quality samples derived from AgiBot-World dataset. Extensive experiments demonstrate that VIDEAS-WM establishes state-of-the-art performance in high-level embodied action semantic reasoning, exhibiting profound physical understanding and robust generalization across unseen scenarios.

Sun 27 SeptRobotics
The gist
Predicting how things will change when actions happen is hard, especially when machines need to understand the rules behind those changes. The authors created VIDEAS, a method that turns videos of actions into clear, step-by-step descriptions of what actions need to happen and what effects they cause. They use smart vision and language tools with a system that checks if these descriptions make sense physically. This helps build better world models that can plan and understand new situations more reliably.
Open → 2609.33464v1

Olfactory cues improve location recognition in virtual reality navigation

Exploring the Effects of Olfactory Cues and Ventilation on Teleportation-based Navigation in VR

Abstract: Spatial cognition supports how people interpret spatial relationships and navigate their surroundings. Although vision plays a dominant role, other sensory modalities, including olfaction, may also contribute under limited visual conditions. This paper investigates the role of olfactory cues in location recognition during virtual reality (VR) navigation. We conducted two formal studies using a wearable olfactory prototype. Study 1 examined whether olfactory cues and ventilation influenced users' recognition of encountered locations during \HDY{teleportation-} and dash-based navigation. Study 2 extended this investigation to repeated navigation and examined whether ventilation duration influenced recognition performance and user experience across successive movements. Results show that olfactory cues can support recognition of encountered locations during navigation, while ventilation was associated with reduced residual interference and improved usability. However, longer ventilation did not clearly improve recognition accuracy in repeated navigation. These findings suggest the potential of olfactory cues as contextual signals during VR navigation, while also highlighting the importance of scent management for maintaining perceptual clarity and user comfort.

Sat 26 SeptHuman-Computer Interaction
The gist
People use their sense of smell to help recognize places when they cannot rely fully on their vision. The authors studied how smells affect people’s ability to remember locations while moving around in virtual reality using teleportation and dashing methods. They found that smells helped users recognize where they had been, and managing the airflow helped reduce confusing leftover scents. However, making users wait longer for the smell to clear did not improve memory as expected. This shows that adding smells can help people navigate VR worlds but also needs careful scent management to keep the experience comfortable.
Open → 2609.32975v1

Mobile virtual reality steering works better with controllers than gaze

Steering Versus Teleporting in Mobile Virtual Reality

Abstract: Mobile virtual reality (MVR) provides low-cost access to extended reality (XR), but its limited input restricts use of common locomotion techniques such as head-decoupled and velocity-controlled steering. Using a low-cost controller with an audio-based button, we compared gaze- and controller-directed steering and teleportation in MVR. We included a controller pitch-based speed-control technique enabling continuous head-decoupled steering. Performance and participant feedback indicate that gaze was better suited to teleportation, whereas controller pointing better supports steering in primed search. We compare with similar techniques in standard VR and derive design considerations for low-cost, narrow-FOV hardware, demonstrating the potential to support varied travel techniques and velocity control in low-fidelity XR.

Thu 24 SeptHuman-Computer Interaction
The gist
Moving around in mobile virtual reality can be tricky because it’s hard to control movement smoothly with limited input devices. The authors studied two ways to navigate: teleporting to a new spot by looking somewhere, and steering continuously using a controller. They found that looking (gaze) works better for teleporting quickly, while pointing with a controller helps steer better, especially when searching for things. They also added a clever way to control speed using the controller’s tilt, which helps make steering more natural even on simple hardware.
Open → 2609.30620v1

Ai systems tested for discovering new rules in alien worlds

ExplorationBench: Measuring AI Systems' Exploration in Verifiable Alien Worlds

Abstract: Scientific discovery begins where known problems end. There, AI systems must engage in exploration: framing hypotheses, designing experiments, and iterating on the results. However, evaluating this ability is difficult: (1) how to verify whether a genuinely new hypothesis holds, and (2) how to determine whether a system has discovered it through exploration or merely recalled related knowledge from pre-training data. To this end, we introduce ExplorationBench, which turns the wicked problem of evaluating scientific exploration into a concrete and tractable framework built on verifiable Alien Worlds: their rules are executable, so every answer can be checked exactly, and they conflict with familiar knowledge, so recall alone cannot solve the tasks. The benchmark contains two sandboxes, AlienCode (31 discovery targets, 70 tasks) and AlienLogic (24 discovery targets, 70 tasks). Each sandbox provides a flawed manual, task-specific environmental feedback, and a dedicated tool-call schema. Systems use these resources to explore the sandbox, then solve held-out tasks. We evaluate 10 AI systems and find that the strongest systems can acquire and apply unfamiliar rules, while performance varies substantially across trajectories and continued exploration can stall or reverse earlier gains. ExplorationBench represents a step towards AI systems that can acquire and apply genuinely new knowledge through exploration in unknown environments.

Thu 24 SeptArtificial IntelligenceComputation and Language
The gist
It is hard to measure if AI can discover genuinely new things or just remember what it already knows. The authors created ExplorationBench, a setup with made-up alien environments where AI must explore and learn unknown rules. These environments let testers check answers exactly and make sure AI isn’t just recalling prior knowledge. They tested 10 AI systems and found some can learn new rules, but progress can vary and sometimes even backslide. This work helps evaluate how well AI can explore and learn in truly unfamiliar situations.
Open → 2609.30199v1

Interactive audiovisual journey reshapes video and sound with ai

Passing: An Endless Journey through Reconstructed Spacetime with AI-Generated Sound

Abstract: This paper introduces Passing, an interactive audiovisual installation that generates an endless journey from a single continuous monorail-window recording by reconstructing it as a spatiotemporal volume. Rather than replaying the footage linearly, the work resamples its spatial and temporal structure along nonlinear trajectories, producing a continuously passing landscape whose depth, speed, and temporal order become unstable. A camera-based viewer-presence detection system estimates whether a viewer is present in the viewing zone and uses this presence state to influence transitions among rendered video sequences. The resulting video stream is fed into SpecMaskFoley, a real-time video-to-audio synthesis model that generates a synchronized soundscape for the reconfigured image. The model is not used to reconstruct an objectively correct soundtrack, but functions as a speculative listener, proposing a possible auditory interpretation of a world whose conventional spatial and temporal premises have been disrupted. Passing distributes creative agency across the artist, who defines the rules of spacetime reconstruction; the AI model, which interprets the emergent visual flow as sound; and the audience, whose embodied presence influences the audiovisual trajectory. Through this structure, the work investigates how authorship and listening may be negotiated among human intention, machine inference, and audience interpretation. Artwork page: https://ryufurusawa.com/passing

Wed 23 SeptSoundArtificial Intelligence
The gist
This work creates an interactive art piece that transforms a single video of a train ride into an endlessly flowing and changing visual experience. Instead of playing the video normally, the system rewrites space and time in the footage to create unusual motion and perspective effects. It detects when someone is watching and uses that presence to change how the video flows. An AI then listens to these altered visuals and creates matching sounds, not to reproduce reality but to imagine what such a changed world could sound like. The artists, AI, and audience all share control over how the piece unfolds.
Open → 2609.27489v1

RodCast shows trade offs in complex VR object manipulation

Beyond Task Performance: Lessons Learned from Evaluating an Exploratory VR Interaction Technique

Abstract: Dense virtual environments present significant challenges for object selection and manipulation, motivating the development of novel interaction techniques. This paper presents RodCast as an exploratory case study to investigate explicit trajectory visualization for interaction in dense virtual environments. We conducted a within-subjects user study comparing RodCast with Go-Go Hand and FlowerCone across three representative interaction tasks using objective performance measures, subjective evaluations, and qualitative feedback. The results revealed that the proposed implementation incurred performance costs on more demanding manipulation tasks, while qualitative feedback suggested that participants attributed these challenges to the complexity of the bimanual control scheme. Additionally, subjective evaluations and qualitative feedback identified benefits in spatial awareness and target accessibility that were not fully reflected by conventional performance measures. Together, these findings highlight the importance of control simplicity in interaction technique design and emphasize that incorporating qualitative feedback into the evaluation process is essential for distinguishing implementation limitations from the potential of the interaction concept. Collectively, these lessons provide guidance for the design and evaluation of future interaction techniques.

Mon 21 SeptHuman-Computer Interaction
The gist
Manipulating objects in crowded virtual worlds is tricky. This paper studies RodCast, a new VR method that shows hand paths to help users interact. Compared to existing methods, RodCast made some tasks harder due to its two-handed controls but helped users better understand space and reach targets. The authors highlight that simple controls matter and that user opinions reveal benefits missed by only looking at task speed or errors. Their work suggests designers should combine task data with user feedback to improve VR tools.
Open → 2609.25414v1

Subgame perfect equilibrium problem shown EXPTIME-complete in graph games

Subgame Perfection in Graph Games with $ω$-Recognizable Preference Relations

Abstract: This paper investigates the constrained existence problem for subgame perfect equilibria (SPEs) in multiplayer graph games. In the proposed framework, each player has a preference relation over the set of plays, assumed to be $ω$-recognizable. Equivalently, he has a preference relation over a finite set of payoffs, and the set of plays with the same payoff is $ω$-regular, for each payoff. This generic framework avoids the need to focus on specific payoff functions. We show that the constrained SPE existence problem is EXPTIME-complete, as well as for Nash equilibria (NEs).

Sat 19 SeptComputer Science and Game Theory
The gist
This paper looks at how players' preferences in multiplayer games on graphs can be modeled in a very general way using recognizable patterns over infinite plays. The researchers consider situations where each player has clear preferences, but without focusing on any particular way of scoring outcomes. They show that deciding whether players can follow strategies that form stable patterns, called subgame perfect equilibria, is a problem that is computationally very hard — specifically, it lies in a complexity class called EXPTIME-complete. The same difficulty applies to the related concept of Nash equilibria.
Open → 2609.22906v1

Visibility influences strategic behavior and coordination outcomes

Visibility Design and Strategic Reasoning

Abstract: Dashboards, feeds, and leaderboards determine whom agents believe they are playing against. We study how such information architectures shape strategic behavior, and how a designer who controls them can use visibility as a lever. We propose a behavioral model in which a transparency parameter governs how selectively agents are exposed to opponents of nearby reasoning depth, and embed it in a Cognitive Hierarchy environment, which provides a tractable language for tying agents' beliefs about the sophistication of others to what they see. We show that because the exposure operator is an exponential tilt of the type distribution, the effect of transparency on aggregate behavior has a closed form: the derivative of the aggregate action with respect to $p$ is proportional to the population-average variance of perceived sophistication. This identity signs the effect in games of strategic complements (opacity raises aggregate effort) and in coordination environments (opacity lowers the mean action), and an ordinal version holds for any response rule that is monotone in the belief. Notably, under a Poisson prior, opacity acts as a sophistication multiplier: every reasoner plays as if the population were $\mathrm{Poisson}(τ/p)$. We use this structure to characterize the disagreement-versus-level tradeoff faced by a coordination-minded designer, to identify the reasoning depths that respond most to visibility, and to show that opacity imposes a ``sophistication tax'' under which the deepest reasoners can lose to moderate ones. Simulations in which agents see only a noisy leaderboard of published actions reproduce both the reversal and the tax. Together, our findings highlight that who an agent sees, and not only how deeply it reasons, shapes strategic behavior, and point to visibility as a design lever.

Fri 18 SeptComputer Science and Game Theory
The gist
How much information people see about others affects how they make decisions in groups or games. The paper shows that when people can see opponents who think like them, it changes the overall actions of the group in predictable ways. Less visibility can sometimes increase effort in competitive settings but reduce coordination. The authors also find that hiding information can hurt the smartest thinkers and that showing only noisy rankings can change how people behave. This highlights that who you see matters just as much as how smart you are in strategic situations.
Open → 2609.22531v1

Hand tracking improves accuracy but mismatched avatars hurt controllers

Comparing Hand and Controller Avatars with Hand Tracking and Controller-Based Interaction

Abstract: Previous research suggests that the congruency between common VR input devices - such as controllers or hand tracking - and their visual representations (e.g., hand or controller avatars) influences user experience and performance. However, the specific effects of input-avatar combinations remain underexplored. We study the effects of common input devices (hand tracking and controllers) and visual representations (hand and controller avatars) on performance and perceived success in target acquisition tasks. We included both grasping and pinching gestures across 16 combinations of input, avatar, and target size. Results indicate that hand tracking benefits from any form of visual representation - even when mismatched - achieving up to 5.8% greater accuracy compared to having no avatar, likely due to its reliance on visual feedback in the absence of a physical prop. Controllers were generally preferred and offered faster task completion. However, mismatched avatars had a stronger negative effect with controllers, particularly when the virtual gesture did not align with the physical action, leading to a 5.6% drop in accuracy compared to the matched condition - suggesting that inaccurate feedback can be more disruptive than having no avatar feedback at all.

Fri 18 SeptHuman-Computer Interaction
The gist
When people use virtual reality, they can control things either with their hands directly or with controllers, and the images they see can show either their hands or the controllers. This paper shows that seeing some kind of hand or controller avatar helps people be more accurate when using hand tracking, even if the image doesn't exactly match their real action. But for controllers, using the wrong avatar can actually make people less accurate and slower. This means matching what you see with how you really move is important, especially for controllers.
Open → 2609.21799v1

Optimal strategies for effort investment in sequential contests with failures

Optimal Strategies in a Sequential Contest with Failures

Abstract: We study a Stackelberg model where two players compete in a sequential contest, and the player that successfully invests the most effort wins. Our formulation considers a probability that each player fails to invest their chosen level of effort, as captured by a failure function that increases with the amount of effort. The players each have their own cost of failure, as well as a maximum level of effort (capturing different abilities of the players). We prove three key results. First, we provide the optimal strategy for Player 1 (the follower), to maximize their utility given an observed effort exerted by Player 2 (the leader). Next, we characterize the optimal strategy to maximize the expected utility of Player 2, anticipating the optimal response by Player 1. Finally, we analyze the expected utilities of each player when both play their optimal strategy, and provide key insights into how heterogeneous player abilities and failure costs affect the outcomes of the game.

Thu 17 SeptComputer Science and Game Theory
The gist
The paper looks at a situation where two players take turns trying to win a contest by putting in effort, but each can fail to deliver the effort they choose. The chance of failure grows as they try harder, and each player handles failure differently. The authors found the best way for the second player to respond to the first player's effort, the best way for the first player to act knowing the response, and how different skills and failure costs affect who wins and each player's payoff.
Open → 2609.19706v1

Robust bounds on iterative updates improve game and traffic algorithms

A Robust Perceptron Cycling Theorem and Applications

Abstract: The classical perceptron cycling theorem of Block and Levin \cite{BlockLevin1970} bounds correction sequences whose selected updates come from a finite set and have nonpositive inner product with the current state. We prove a robust variant for additive trajectories $z_{k+1}=z_k+u_k$, for all integers $k\geq0$, with increments in a finite set $U\subset E$, where $E$ is a finite-dimensional real inner-product space and $0\in\conv U$. Let $A\colon E\to E$ have positive-definite symmetric part, without requiring symmetry, and let $B\geq0$. If each $u_k$ is a $B$-approximate minimizer of $u\mapsto\ip{Az_k}{u}$ over $U$, then $\sup_{k\geq0}\norm{z_k}\leq C(1+\norm{z_0}+B)$, with $C=C(E,U,A)$ independent of the initial state, $B$, and all admissible update choices. Our central algorithmic consequence is an $O(k^{-1})$ last-iterate norm bound for harmonic vertex-returning Frank--Wolfe for affine strongly monotone variational inequalities on polytopes with relatively interior solutions. It extends the quadratic Frank--Wolfe/herding guarantee of Bach, Lacoste-Julien, and Obozinski \cite[Section~4.2]{BachEtAl2012} to nonsymmetric affine operators. We apply this bound to empirical best responses in strongly stable linear population games, quadratically regularized bilinear saddle problems, and traffic assignment with coercive affine asymmetric cost maps.

Wed 16 SeptComputer Science and Game Theory
The gist
The authors studied a mathematical rule called the perceptron cycling theorem, which helps ensure sequences of updates don’t grow too large. They proved a stronger, more flexible version that works even with imperfect update choices. This new understanding helps improve algorithms used in game theory, traffic routing, and optimization problems by guaranteeing their steps remain stable and efficient. Their results extend previous work to more general situations where the problem’s math isn’t perfectly symmetric.
Open → 2609.18342v1

Symmetric strategies solve repeated harmony game using Bellman equation

Symmetric solution of the Bellman optimality equation for repeated harmony game

Abstract: In social dilemma games, additional rewards or punishments have been studied as means of promoting cooperation. Therefore, it is important to investigate the ideal situation, in which such an additional payoff would change the game. In this study, we investigated the symmetric solution of the Bellman optimality equation for a repeated harmony game. The calculations showed that three types of symmetric solutions exist. One of them corresponds to the trivial All-C strategy, and another to the Win-stay Lose-shift strategy of the prisoners dilemma game. The nontrivial behavior of the strategy corresponding to the last solution is also discussed in detail. In addition, we numerically investigated which strategy the agents actually learn by the reinforcement learning algorithm.

Mon 14 SeptComputer Science and Game TheoryArtificial IntelligenceMachine Learning
The gist
Social dilemma games study how people cooperate or compete when rewards or punishments are added. This paper looks at a specific type of repeated game called a harmony game and finds three main types of cooperative strategies that can emerge. One strategy matches always cooperating, another matches a known win-stay lose-shift behavior, and the third is more complex. The authors also explore which of these strategies can be learned by artificial agents using reinforcement learning.
Open → 2609.16289v1

Cheap talk improves stability in language model agent interactions

Cheap Talk Stabilizes Strategic Interaction in LLM Agents

Abstract: Large language models are increasingly deployed as interacting agents, making the persistence of their action policies across repeated interaction critical for reliable multi-agent operation. We investigate whether and how agent-generated, non-binding pre-play communication ("cheap talk") increases such persistence in four open-weight 7-9B-parameter LLMs. Our experiments span four repeated two-player games -- Prisoner's Dilemma, Snowdrift, Stag Hunt, and Harmony -- with incentive structures ranging from strategic conflict to alignment, each presented in six contexts. We observe unstable trajectories in all four games, although their prevalence and magnitude depend strongly on model and context. Across models, games, and contexts, cheap talk is predominantly stabilizing, with five corrected reversals concentrated in social or team framings; effects vary substantially by model and context. Controlled current-message interventions identify two separable output-level channels in Qwen: reduced action uncertainty and less between-round drift in action probabilities. Matched history-by-message counterfactuals further show that recent partner behavior conditions how mutual-benefit versus self-prioritizing language affects policy persistence. Finally, in Prisoner's Dilemma, we identify in Qwen and Falcon a history-balanced policy-content direction in late transformer layers; projecting out this direction increases realized switching during closed-loop play, demonstrating that complete trajectories are causally sensitive to this component. Together, these findings show that cheap talk can make individual trajectories more persistent across diverse incentive structures, while revealing that the magnitude and mechanisms of stabilization are model- and history-dependent.

Mon 14 SeptMultiagent Systems
The gist
When large language models act as agents that interact repeatedly, it’s important for their decisions to be consistent over time. The authors studied how allowing these agents to send non-binding messages before acting—called cheap talk—affects this consistency. They found that in many cases, cheap talk helps the agents stick to more stable strategies across different types of games and situations. The effect varies with the model and context, and the authors also explored internal behaviors within the models that explain this stabilization.
Open → 2609.16270v1

Language models learn to coach for better problem solving

Learning to Coach for Experiential Learning

Abstract: Language models can learn from experience, but raw solution trajectories are often too long and noisy to provide effective guidance. In this work, we propose Learning to Coach (L2C), a framework that trains a dedicated LLM-as-a-Coach to extract actionable experiential knowledge from an actor model's previous trajectory. The actor remains frozen, while the LLM-as-a-Coach is trained to maximize a reward given by the correctness of the actor's guided response. We study two such rewards: a same-instance reward, which improves subsequent responses on the original problem, and a cross-instance reward, which elicits knowledge that transfers to other instances. Across mathematical reasoning and interactive text-games, L2C consistently outperforms self-refinement and an untrained LLM-as-a-Coach. Running experiential learning for more iterations further improves accuracy and uses additional inference compute more effectively than enlarging the actor's decoding budget. The trained LLM-as-a-Coach also transfers to out-of-distribution tasks and adapts its guidance to the specific actor it coaches.

Mon 14 SeptComputation and Language
The gist
Large language models (LLMs) can solve problems by learning from past attempts, but their previous answers can be too long and confusing to help much. The authors created a system called Learning to Coach (L2C) where a separate LLM acts like a coach, giving clearer hints based on earlier tries. This coach is trained to guide the original problem solver to improve its next answer and even help with different problems. Tests on math puzzles and text-based games show L2C helps models get better at solving tasks more efficiently.
Open → 2609.15851v1

Fair allocation exchanges may fail to stay fair in every step

Reconfiguration in Fair Division Revisited

Abstract: We revisit reconfiguration in the fair allocation of indivisible goods, where the goal is to transform one fair allocation into another through a sequence of exchanges while preserving fairness at every step. Our focus is on the hierarchy of envy-freeness up to $k$ goods (EF$k$). We show that for any fixed $k$, two EF1 allocations with the same size vector need not admit a reconfiguration path whose intermediate allocations satisfy EF$k$. This impossibility persists even when the two allocations arise from standard EF1 approaches: the envy cycle elimination algorithm or the maximum Nash welfare solution. In contrast, we prove that allocations with the same size vector produced by recursively balanced picking sequences, including round-robin, are always connected via a path that maintains EF2. We also show that deciding whether an EF1 reconfiguration path exists is NP-hard for any fixed number of agents. Furthermore, we complement these exchange-based results by studying a more permissive model that also allows transfers, establishing additional connectivity guarantees.

Mon 14 SeptComputer Science and Game TheoryDiscrete Mathematics
The gist
This paper looks at how to change one fair way of splitting things to another fair way by swapping items fairly at each step. It finds that even when starting with good fair setups, it isn't always possible to keep fairness in every exchange step unless you relax fairness a bit. They also show deciding if such a fully fair swapping path exists is very hard to compute. However, some simple picking methods guarantee you can get from one fair split to another by slightly relaxing fairness. Lastly, they explore how allowing transfers makes it easier to keep fairness throughout the process.
Open → 2609.15358v1

Users create causal virtual worlds using fuzzy cognitive maps and ai video generators

Converting Sequenced Fuzzy Cognitive Maps to Causal Virtual Worlds with Large Video Generators

Abstract: We show how users can create and manipulate causal virtual worlds with large-language-model (LLM) and large-video-model agents. The approach uses feedback fuzzy cognitive maps (FCMs) both to model the granular causal structure of the virtual world and to guide its causal evolution. The local causal rules are partial or fuzzy while the FCM's feedback structure produces global equilibria that define causal scenarios. A sequence of \emph{dynamical} meta-rules of the form ``If $\mathcal{A}$ then $\mathcal{B}$" define the causal scenes of the virtual-world video. The if-part causal pattern $\mathcal{A}$ perturbs the FCM's virtual world at the user's or agent's discretion. The FCM's transient feedback dynamics define the meta-rule's causal arrow of implication. The then-part $\mathcal{B}$ is the resulting equilibrium attractor such as a FCM limit cycle or fixed point. Our algorithm extracts these meta-rules from the FCM and guides the LLM agent to write a script based on the FCM meta-rule sequence. The large video generator converts the meta-rule into a video scene in accord with the flow of the dynamics. We applied the agent-based technique to a simple FCM that describes an undersea world of dolphins and sharks. Google's Gemini 3.1 generated the script and Google's Veo 3.1 generated the dolphin-shark video. The approach is general and can scale by mixing larger FCMs and AI agents to produce more immersive virtual worlds.

Mon 14 SeptArtificial IntelligenceComputation and LanguageInformation Retrieval
The gist
People want to make virtual worlds that change and happen in believable ways. The authors show how to use special maps called fuzzy cognitive maps to describe cause and effect in these worlds. Then, artificial intelligence helps turn sequences of these cause-effect rules into story scripts and videos. This lets users create virtual scenes, like dolphins and sharks underwater, that unfold logically and look real. The method could work with bigger worlds and different AI tools to build more detailed virtual experiences.
Open → 2609.14985v1

Coastal environments generated automatically from images for marine robots

Coastal Environment Generation with HoloOcean

Abstract: Marine robotic simulation provides a safe and inexpensive method of developing and testing algorithms for unmanned underwater vehicle (UUV) and unmanned surface vessel (USV) autonomy and perception before full field deployment. However, these simulations are often limited by the availability of simulated environments. Current marine robotics simulation suites offer manual ways to edit or create environments, but they require existing data or specialized knowledge of the environment system. To address these issues, we introduce a novel Unreal Engine 5 level generation pipeline that enables automatic creation of coastal environments for HoloOcean. Our pipeline relies on a user-provided overhead image of a coastal scene. The pipeline then uses the image to generate height map data, as well as automatically select assets and place them in the environment.

Wed 9 SeptRobotics
The gist
Testing underwater and surface robots safely is hard because realistic ocean scenes are needed. The authors made a tool that creates detailed coastal environments automatically using just a single overhead photo. This helps developers test their robot software in many different ocean-like settings without having to build scenes manually or have expert knowledge. The tool uses the image to estimate the shape of the land and water and places objects like rocks or plants accordingly. This can save time and resources when developing marine robots.
Open → 2609.10484v1

First-order online learning methods control distinct geometric regret classes

Exact-Form Regret for Gradient Descent, Mirror Descent and Follow-the-Regularized-Leader

Abstract: Online gradient descent is usually studied through external regret, where the learner competes with fixed alternatives. Recent work shows that first-order methods control richer action-dependent deviations. We ask for a geometric characterization of the deviations with respect to which online gradient descent, mirror descent, and follow-the-regularized-leader (FTRL) achieve no regret. We identify exactness as the common principle. Exactness means that the relevant displacement field is generated by a scalar potential, or equivalently that the associated one-form is exact in the geometry used by the algorithm. This geometry depends on the algorithm. For gradient descent it is Euclidean geometry, for mirror descent it is the geometry induced by the regularizer, and for FTRL it is the cumulative dual state. Under mild regularity conditions, exactness yields sublinear regret, while nonzero circulation provides the complementary obstruction and leads to linear regret. This gives a unified geometric framework for understanding the deviation classes controlled by these algorithms and reveals that different first-order methods can control genuinely different classes of deviations. These deviation classes have direct consequences for learning, particularly in games. We study the equilibrium notions induced by exact-form deviations and introduce conservative correlated equilibrium, reflecting both the conservative geometry of the underlying displacement fields and the restricted family of deviations available to the players. We characterize its relation to correlated equilibrium, determine when the resulting equilibrium notions coincide and when they separate, and show how these relationships depend on the geometry and the learning algorithm. Overall, this work gives a unified geometric account of what first-order online learning algorithms are no-regret with respect to, beyond fixed comparators.

Tue 8 SeptMachine LearningComputer Science and Game Theory
The gist
Online learning algorithms try to improve decisions over time by comparing themselves to fixed strategies. This work finds the exact types of changes or deviations these algorithms can handle without regret, using a geometric viewpoint. It shows that different algorithms like gradient descent and mirror descent work within different geometric frameworks, meaning they control different kinds of errors. The authors also explore how this affects game scenarios and introduce a new equilibrium concept tied to these geometric properties.
Open → 2609.09466v1

Kairos dataset captures detailed video events over long times

Kairos: A Dataset for Fine-Grained Video-Language Modeling over Space, Time, and Dynamics

Abstract: Many emerging video language modeling tasks require systems to move beyond clip-level abstraction and model visual content as it unfolds over extended time horizons. However, most existing video datasets rely on coarse or sparsely aligned supervision, which compresses temporal variation and limits the ability of models to learn reusable representations of continuous visual dynamics. We introduce Kairos, a video dataset for video-language modeling with time-resolved annotations. Kairos consists of long-duration videos, ranging from ten minutes to half an hour, annotated with fine-grained temporal alignment. The annotations capture ongoing actions, entity appearances and attributes, interactions, and evolving contextual cues along the video timeline. This time-resolved structure supports fine-grained evaluation, long-range modeling and reasoning, instruction data construction, representation learning, and video generation. Kairos provides a general-purpose foundation for modeling visual experiences over time.

Tue 8 SeptComputer Vision and Pattern RecognitionArtificial Intelligence
The gist
Many video models only look at short clips and miss how things change over time. The authors created Kairos, a collection of long videos with detailed labels that show what’s happening moment by moment. These labels include actions, appearances, and interactions, helping computers understand videos more deeply. Kairos lets models learn continuous changes and contextual details over a long time rather than just snapshots.
Open → 2609.08755v1