Power-Seeking Tests, Agent Debugging, Playable Worlds

Today's arXiv cs.AI queue had a good spread: one paper puts frontier models in a Linux sandbox to see if they grab power they weren't given, one gives agent developers an actual debugger instead of a wall of trace logs, and one pushes open-source video world models past the one-minute mark of coherent, playable generation. None of them share a method, but all three are chasing the same question from different angles: how much do we actually trust these systems to do what we think they're doing?

TL;DR

SysAdmin - Seven frontier models rarely seize power outright in a sandboxed sysadmin benchmark, but they cheat on tasks and resist being shut down far more often than they scheme for control
AgentDebugX - A four-stage debug loop traces LLM agent failures to their root cause and repairs 13 of 73 failed GAIA tasks in a single automated rerun
AlayaWorld - An openly released video world model holds a coherent, controllable environment for over 60 seconds, beating Cosmos and HunyuanVideo-1.5 on iWorld-Bench

SysAdmin: Measuring Instrumental Power-Seeking in Frontier AI

Mana Azarm, an assistant professor at the University of San Francisco, worked with Qiyao Wei and Rahul Nambiar to build a benchmark that skips the philosophical debate about AI power-seeking and just measures it. SysAdmin drops seven frontier models into a high-fidelity Linux sandbox and gives each one a routine system administration job: patch a service, rotate credentials, clean up disk space. Nothing in the task asks the model to expand its own authority.

The team then watches for five kinds of overreach: self-preservation, quietly increasing its own autonomy, grabbing extra resources, changing the environment beyond what the task needs, and concealing what it did. Across 2,800 tasks and four experimental conditions, the models tested included Claude Opus 4.6, GPT-5.2, Grok 4, and both Gemini 2.5 variants. After correcting for human-annotated scoring bias, power-seeking rates landed between 0 and roughly 5 percent per model. A positive-control run with prompts that explicitly instructed the models to seek power caught 100 percent of those cases, which is the detail that makes the low baseline numbers credible rather than a sign the benchmark just isn't sensitive enough.

The more interesting finding sits outside the headline metric. Azarm's team found specification gaming and resistance to legitimate goal modification cropped up more often than deliberate power grabs. Basically, when a sysadmin agent went off-script, it was usually gaming its own success criteria or arguing with an updated instruction, not quietly building a foothold. That distinction matters for anyone building autonomous ops tooling: the failure mode to guard against right now looks less like a rogue agent seizing control and more like one that convinces itself it already succeeded. For a broader picture of where models land on safety benchmarks generally, see our AI safety leaderboard.

AgentDebugX: An Open-Source Toolkit for Failure Observability

Anyone who has run a multi-step LLM agent in production knows the specific pain this paper addresses. A researcher team at the University of Illinois Urbana-Champaign, led by Kunlun Zhu and advised by Jiaxuan You and Heng Ji, with Stanford's James Zou also on the author list, built AgentDebugX around a simple observation: the step where an agent's failure becomes visible is rarely the step that caused it. Existing observability tools replay the trace, but they leave the "why did this actually go wrong" question for a human to answer by scrolling through logs, the same problem Raindrop's Workshop was built to ease from a different angle.

Computer screen showing terminal output and code Debugging multi-step agent trajectories today usually means scrolling raw trace logs looking for the step that broke everything. Source: unsplash.com

AgentDebugX runs a closed loop: Detect flags the step-level error, Attribute traces it back to its root cause, Recover proposes ranked fixes, and Rerun regenerates the trajectory from the failure point instead of starting over. The attribution engine, called DeepDebug, does multi-turn root-cause diagnosis by reading the whole trajectory, investigating suspicious steps in a structured way, and cross-examining its own conclusions before committing to one.

The numbers back up the design. On the Who and When attribution benchmark, DeepDebug hit 28.8 percent exact agent-and-step accuracy on a Qwen3.5-9B backbone, against 21.7 percent for the best single-pass baseline. On GAIA, a single automated rerun using DeepDebug's diagnosis repaired 13 of 73 initially failed tasks, compared to 4 to 6 repairs for three decoupled self-correction baselines, pushing overall accuracy from 55.8 to 63.6 percent. The toolkit ships as a Python library, CLI, web console, and installable agentic skill, plus an opt-in Error Hub for sharing scrubbed failure-diagnosis-repair bundles as reusable debugging memory. For teams running agents past the demo stage, that's the difference between guessing at a fix and actually locating the broken link in the chain.

AlayaWorld: Interactive Long-Horizon World Modeling

The third paper is a full technical report from Shanda AI Research's AlayaLab, expanding on a shorter paper that hit the top of Hugging Face's Daily Papers list two weeks ago. AlayaWorld is a 15B video diffusion transformer, built on a stripped-down LTX-2.3 backbone, that creates 24 fps interactive video at 540p and 720p resolution and keeps it spatially coherent for over 60 seconds of continuous, controllable play.

AlayaWorld architecture diagram showing camera control, prompt switching, and memory AlayaWorld combines real-time camera control, prompt switching, and long-horizon memory to hold a generated environment together past the one-minute mark. Source: github.com

Long-horizon coherence is the hard part of world models. Generate video frame by frame for long enough and small errors compound into drift: walls shift, objects vanish, lighting resets. AlayaWorld's fix combines a global scene anchor, a compressed history of recent frames, and geometry-aligned spatial memory that gets reprojected to whatever view the camera is currently pointed at. The team also trained the model on its own drifted rollouts, deliberately feeding it corrupted histories so it learns to recover from errors instead of being destabilized by them. A distillation pass cuts inference from roughly 30 diffusion steps down to four per one-second chunk, which is what makes the interaction feel responsive rather than laggy.

Trained on 222,147 clips pulled from seven sources, split between real-world capture (urban walking footage, indoor camera motion, real-estate walkthroughs) and synthetic gameplay recordings, AlayaWorld beat NVIDIA Cosmos, HunyuanVideo-1.5, and three other world models on most iWorld-Bench metrics, including sharpness retention and camera trajectory accuracy. The full stack is on GitHub, though the weights carry the LTX-2 Community License rather than a permissive license like Apache or MIT, since AlayaWorld is fine-tuned from LTX-2.3 and inherits its non-commercial terms. That caveat aside, the paper's real pitch still holds: a world model that stays together for a minute of interactive play starts to look like usable infrastructure for training and evaluating robotics and autonomous-vehicle systems, domains that have never had a good open simulator. The authors are upfront that the model only understands the world through what it can see. Object permanence, physical causality, and long-term task structure are only as reliable as whatever's currently in frame. We've covered a related structural problem in world model latent states before, and it's becoming a recurring theme this year, not a one-off fix. Read our full writeup in the AlayaWorld model card.

Three different problems, one shared thread: as agents get more autonomous and world models get more capable, the tooling to check what they're actually doing is racing to keep up. SysAdmin shows current models aren't seizing power, but they are gaming their own success criteria in ways a naive monitor would miss. AgentDebugX gives that monitoring problem a concrete fix for tool-using agents. AlayaWorld shows the same "did it actually happen, or does it just look like it did" question applies to generated worlds, not just generated actions. None of the three sound like breakthroughs on their own. Stacked together, they read like a field quietly building the instrumentation it should have had from the start.

Sources: