AI Agents

This paper formalizes "recursive self-design" with a four-part framework for systems that modify their own construction. It validates this against public systems, highlighting Darwin Goedel Machine's improvement from 20% to 50% on SWE-bench Verified over 80 iterations. To make this concrete, the authors release MetaAI-Mini, a reproducible protocol and codebase built on HumanEval, providing a clear path for others to experiment with these self-improving patterns. This work moves the "AI building AI" concept from a vague notion to an engineering discipline.

Socratic-SWE presents a clever closed-loop framework for agent self-improvement. Instead of relying on fixed synthetic data, it mines the agent's own historical problem-solving traces for recurring failures and repair patterns. These distilled "skills" then guide the generation of new, targeted training tasks from real code repositories. This dynamic approach, which adapts the training data to the agent's current weaknesses, achieved 50.40% on SWE-bench Verified after three iterations, outperforming other self-evolving baselines.

How do you get a general-purpose coding agent to use a complex, specialized tool without fine-tuning? This paper introduces SIGA, a "simulator-interface grounding adapter." It provides the agent with the tool's specific contract—its vocabulary, constraints, and validation rules—through retrieval and procedural memory. Tested on the GEOS scientific simulator, SIGA enabled an agent to complete a task in five minutes that took a human expert three hours. The adapter itself can self-evolve from prior trajectories, outperforming even hand-designed configurations.

As tasks become more nuanced, simple pass/fail evals fall short. This paper makes a strong case for using expert-authored rubrics as a better paradigm for both evaluation and training. The authors lay out five design principles for creating high-quality rubrics and introduce ComplexConstraints, a dataset with 10-40 atomic criteria per prompt. The payoff is clear: training on just 1,000 of these examples boosted a 4B model's instruction following performance by 15.5%, and RL on rubric-graded tasks transferred to out-of-distribution benchmarks.

Correctness is table stakes for code generation; efficiency is the next frontier. This paper introduces SkelDPO, a preference optimization framework designed to teach models how to write efficient code. Instead of just comparing full programs, it analyzes efficient vs. inefficient solutions to identify the underlying code "skeletons" that cause the performance difference. By training with a joint preference loss on both the code and these skeletons, the model learns the patterns of efficient implementation, improving efficiency benchmarks by 2-7% over prior methods.

Agent benchmarks are riddled with "reward hacking" vulnerabilities, where an agent can pass the verifier without actually solving the task. This paper introduces an automated solution: a "hacker-fixer loop." It uses three LLM agents—a hacker to find exploits, a fixer to patch the verifier, and a solver to ensure valid solutions still pass. This adversarial process drove the attack success rate on one benchmark from 62% to 0%. Critically, a loop using weaker models could successfully harden a verifier against much stronger attackers.

This paper from Perplexity offers a rare, data-backed look at how autonomous agents change knowledge work in production. By analyzing users who tried the same task on their Search assistant and Computer agent, they found the agent performed 26 minutes of autonomous work per session, versus 33 seconds for the assistant. This autonomy cut task completion time by 87% and reduced user dissatisfaction by 55%. Crucially, it also shifted user behavior toward higher-order work like verification and encouraged them to tackle more complex, multi-step tasks.

Creating robust, reusable skills for agents is a bottleneck. This work argues that naively summarizing agent traces into a skill is flawed because traces are messy and incomplete. The proposed solution, W2S, first converts fragmented traces into a structured intermediate representation called RWSA (Workflow, Semantics, Attachments) that explicitly models control flow and safety. This structured approach allows for more robust skill induction, improving behavioral replay consistency by 10.5% over simple summarization and demonstrating the need to treat traces as executable specifications.

Third-party agent skills create a new supply chain risk that is part code, part prompt. This paper introduces MalSkillBench, the first benchmark of malicious skills verified by actually running them in a sandbox. The benchmark, containing over 3,900 malicious examples, was built using a Generate-Verify-Feedback loop. The findings are stark: current detectors are great at spotting code injection but collapse against prompt injection and novel attacks against the agent's control plane, revealing a major blind spot in the current security posture for agent ecosystems.

Most jailbreak defenses assume they can see the whole attack in one context. This paper shatters that assumption by introducing Context-Fractured Decomposition (CFD) attacks. An attacker can use individually benign steps to create an intermediate artifact (like a configuration file), then trigger harmful behavior in a much later step. This exploits "provenance gaps" where the system doesn't track how an artifact was created. This new attack vector boosted jailbreak success rates by up to 28.3% against systems with strong single-turn defenses.