1. Agent Lightning v1.0
Modern agents run inside a harness that owns tools, context, and control flow. Training one gets awkward because the harness runs the environment loop while the trainer only ever sees LLM request and response pairs. This work from Microsoft uses that boundary as the integration point.
The harness stays opaque: An endpoint proxy sits at the model boundary and connects any harness to RL in about 3,500 lines, so an existing agent can be trained without being rewritten for the trainer.
The hard part comes after the proxy: The paper works through what actually breaks in that setup, retokenization, sample merging, advantage calculation, loss normalization, and backend scheduling. Each item silently corrupts gradients when a harness sits between the policy and the reward.
Small budget, real movement: Using 6K training examples and modest compute, it moves Qwen3.5-9B on SWE-bench Verified from 41.8% to 56.4%.
Why it matters: This is the clearest expression yet of the theme running through this week’s papers, that the harness belongs in the training stack as a first-class object. If your agent already works, you can now train the model against the exact system it runs in.
2. The Skill Trigger Bottleneck
There are 56,804 public agent skills today, all competing for fewer than 100 reliable trigger slots in the system prompt. Your own playbooks compete for that same space, which means the long tail never gets used no matter how good it is. The paper traces that scarcity back to how skills get installed.
One word for three separate things: Installation currently bundles content, persistence, and automatic triggering. Only triggering needs to occupy prompt space, so the protocol separates the three into Reference, Saved workflows, and Installed tiers.
A path is the whole interface: A path addresses any skill, subtree, or collection, and reading it is enough to use it. A directory becomes a menu, so bundles stop being all-or-nothing and you can pull one file out of someone else’s collection.
Vendoring gives you ownership: Copying a skill into your Git tree at the same path means your team owns and adapts it.
Why it matters: No manifest, no lockfile, no registration, and SKILL.md is unchanged, so this is adoptable without an ecosystem migration. The three-tier framing stays useful even if you never adopt the protocol. Decide per skill whether it needs to fire unasked, and most of yours will not.
3. Harness-Level Forgetting
Continual learning has always tracked what changes in the weights. Modern agents accumulate their experience somewhere else entirely, across prompts, memories, tools, skills, and routing rules, and nobody has been measuring what happens when that layer drifts.
The failure has a name now: Update any harness component and previously reliable behavior can break with the model completely untouched. The paper calls this harness-level forgetting and gives it a measurement protocol.
Proposing and committing are different jobs: Guarded harness evolution splits them. A Continual Optimizer drafts a candidate harness from post-execution feedback, and a Continual Evaluator commits only after checking current improvement, historical retention, and validity.
It generalizes across modality: Relative gains exceed 10% across textual reasoning, multimodal perception, and open-world interaction.
Why it matters: If you already let your agents rewrite their own prompts, skills, or memory files, you are running an unguarded version of this loop today. The gate between draft and commit is cheap to add, and the historical retention check is the one most self-editing setups skip.
4. The Control-Plane Tax
Serving systems for agentic applications still carry assumptions inherited from single-turn LLM inference. This work instruments ten real agentic applications end to end and finds the model is often not what your latency bill is paying for.
Non-LLM components dominate in half the suite: Across ten instrumented applications, non-LLM components dominate latency in five of them. Task latencies inside a single application diverge by up to 32x across GPU-bound inference, memory-bound retrieval, and CPU-bound sandboxes.
Sessions sit idle for a long time: Sandbox working sets peak at 28 GB per session, and production sessions hold state idle for minutes to hours between active steps. That combination makes naive per-session provisioning expensive.
The tax is auxiliary calls: Helper LLM calls and tool schema overhead form a control-plane tax that crowds out productive compute, which stays invisible if you only profile the main generation path.
Why it matters: The fixes are concrete and orthogonal to the model. Task-aware serving cuts latency 29 to 40%, state offloading cuts memory 4.6x, and tool-result caching removes 35.2% of redundant search calls. Worth reading before you buy more GPUs.
Message from the Editor
We just released Introduction to Exo, a hands-on DAIR Academy lab on the open-source agent harness built for recursive self-improvement. Across 6 labs, you drive the real exo CLI in a live terminal, give an agent a shell, read its raw event log, and fork a conversation to travel back in time.
5. Demystifying Agent Skills
Skills are usually assumed to inject knowledge the model lacks. This paper runs the controlled comparison and finds the mechanism works differently, which changes what a good skill should contain.
Procedure beats facts by an order of magnitude: Across 8,135 normalized trial records, procedural anchoring accounts for 65.7% of cases where a skill helps and explicit knowledge injection accounts for 4.5%. Skills mainly stabilize execution.
Precision collapses as the library grows: As the pool goes from 5 to 100 skills, actual-use precision falls from 29.6% to 3.3%. Every skill you add makes the rest harder to select correctly, which is the empirical version of the trigger scarcity problem.
They still beat the alternative: Skills outperform Workflow Memory by 6.06 points in matched comparisons, so the format earns its place even with the selection problem unsolved.
Why it matters: The failure modes are named and diagnosable, brittle assumptions, incompatible contexts, and insufficient adaptation. Combined with the precision curve, the practical read is to write skills as repeatable procedures and keep the active set small.
6. Strategy Lock-In
Agents post-training other agents is one of the more load-bearing assumptions in current recursive self-improvement arguments. This paper analyzes a large corpus of publicly released post-training trajectories to see whether the loop actually closes, and finds a specific structural failure.
The first step decides everything: Across tasks, the agent locks in its training strategy at the very first step, then spends the entire remaining budget on local adjustments inside that choice.
Better scaffolding lifts execution: An experience-driven scaffold was worth 12.6 points on GSM8K and 40.8 on HumanEval, and the strategy stayed frozen throughout. The agent got better at the plan it had already committed to.
Human guidance does not survive training: Redirecting the opening choice by hand worked, and the agent slid back into local loops once training began. Extra inference compute paid off on easy tasks and did almost nothing on the hardest one.
Why it matters: What agents lack here is a way to reconsider strategy while execution is still running. None of the three escalating fixes tried here touch that, which sets a clear target for the next round of work.
7. SocialRL
The dispositions that make an assistant pleasant make it a poor delegate. A friendly frontier model volunteers its principal’s private information and concedes at the first sign of resistance, which is exactly the wrong behavior when it is negotiating on your behalf.
Trained where it matters: SocialRL trains social reasoning directly in a 4B model across six principal-driven domains including negotiation, job interviews, and marketplace haggling.
The behavioral shift is stark: After training, 78% of buyer openings anchor below target, against 3% untrained. That reflects a learned strategic prior.
Small model, better outcome: Cascade RL and multi-teacher distillation consolidate the specialists into a single 4B model at 0.627 average utility, above GPT-5.1 at 0.619 and GPT-5.2 at 0.613.
Why it matters: Aligning an assistant and aligning a delegate pull toward different behaviors, and this paper makes that gap measurable. As agents start transacting on behalf of users, a friendly-by-default posture starts leaking the principal’s position.
8. ClawGym II
If you want to train agents inside the harness they already run in, this is the black-box version of that idea. ClawGym II runs RL through OpenClaw and Claude Code as opaque boxes, with a serving proxy at the model boundary capturing every call the harness makes, then organizing those calls into prefix trees so PPO and GRPO can optimize over the recovered multi-turn structure. Qwen3-30A3B gains 9.98 points of Pass@1 through OpenClaw and 14.81 through Claude Code, stable across 200 to 400 optimization steps. Mix-harness training pushes further, optimizing one model jointly by heterogeneous harnesses, which points at policies that generalize across execution systems.
9. Inside an Agent Team
Naming one agent the coordinator creates no communication hub and gives no reliable improvement in success, which is worth knowing before you architect another supervisor pattern. Researchers instrumented 1,902 multi-agent coding runs as temporal networks, with agents and files as nodes and messages, writes, and reads as timestamped edges carrying cost. Direct messaging grows close to quadratically with team size, much of it from an early round of introductions, then saturates in the largest teams as agents switch to broadcast. Task shape drives topology. Shared-specification work produces dense connected teams while pipeline tasks produce sparse networks organized around local interfaces. Swapping repeated one-to-one messages for shared files cut output tokens about 42% at eight agents on message-heavy work. Separately, agents sought out hidden grading material unprompted, and in a sealed rerun across 244 runs with marked placeholder files they still reached for it in four fifths of runs.
10. Fragile Self-Improvement
Memory-based self-improving agents report gains that have never been checked against evaluation noise. This re-evaluation adds the two things prior work skipped, multiple runs to measure variance and randomly shuffled task orders, and both hurt. Agent evaluation is already noisy on multi-step tasks, and stacking a self-improvement loop on top amplifies that noise. The sharper finding is that default task orderings impose an implicit curriculum, and much of the reported gain was riding on it. Adding detailed rubrics and environment feedback to memory construction recovers part of the drop, and a significant gap remains. If you are measuring your own memory loop, shuffle the task order first.