New research from Google DeepMind. (bookmark it) SkillSmith treats model weights as an additional modality the LLM reads natively. The augmented model ingests existing prefix weights alongside rich text describing how a capability relates to a target, then directly outputs new prefix weights that manifest that skill. Skill composition becomes an inference-time operation instead of a training run. The team calls this instruction-steered parametric synthesis. The gains exceed what text-only and weight-only adaptation reach on their own. Paper: Track more trending AI papers in our academy:

// Persistent Workspaces for Long-Lived Claude Code Agent Teams // Four issues to be aware of: > Working state vanishes when a terminal closes and the team cannot be resumed. > Compaction condenses the conversation and blurs each agent's working detail. > Decisions and operations get trapped in compacted chats, which accumulates as agentic technical debt. > Every handoff needs another long prompt. ATWZ is a filesystem operations layer built around Claude Code's native Agent Teams. Each agent gets a workstation directory holding its working state alongside the skills, hooks and scripts that maintain those files. The team backs up periodically so knowledge survives compaction, and a single command restores the whole team after the process ends. Agents also send documents to one another inside the workspace, which replaces most of the handoff prompt writing. Paper: Track more trending AI papers in our academy:

If you maintain an AGENTS.md or a CLAUDE.md, this is worth a read. (bookmark it) 288 gold-test evaluated runs across Claude Code and Codex, 17 real tasks from 3 repositories, with context-injection strategy as the only variable. Correctness does not move on either agent. Equivalence testing bounds any effect to at most 10 to 15 percentage points. A failure-mode triage explains why. Agents fail on implementation skill, feature design, pattern selection and exact wiring, rather than on repository knowledge a markdown file could supply. A manipulation probe confirms it, since the real AGENTS.md never converted a near-miss into a pass on either agent. Borderline task difficulty is agent-specific with Spearman rho of 0.75, so single-agent studies draw tasks from different informative bands and reach opposite conclusions. That explains a lot of the contradictory prior evidence. Paper: Track more trending AI papers in our academy:

Neat work on long-horizon agents. Splitting a hard task across agents is typically how standard multi-agent work. The usual design lets them exchange findings only at phase boundaries, through staged handoffs or synchronized rounds, so communication and work stay mutually exclusive. AgentRadio breaks that constraint with an asynchronous message-passing layer. Three primitives, threads, messages, and waiting for mentions. The last one runs as a background task, surfacing a teammate's discovery without interrupting foreground work. On SWE-Atlas QnA, a single Claude Code agent on Opus 4.6 resolves 32.3% of tasks. Four agents wired through AgentRadio resolve 62.1%. That also beats a single Claude Code agent running the newer Opus 4.8 at 57.2%. Rubric-level analysis shows the gain growing with task difficulty, which points at mid-course correction as the mechanism rather than raw parallelism. Paper: Track more trending AI papers in our academy:

New research from Microsoft. This one is on training computer-use agents at scale. Recent pipelines generate synthetic environments in bulk, which moved the bottleneck from how many exist to what is inside each one. Echoverse compiles specifications into stateful applications whose tasks are graded against the application's own database, then runs a co-evolution loop that reads every graded rollout twice. Once as repairs to the environment, its tasks and its verifier. Once as training signal for the model. On the same domains, shallow environments pushed live-site accuracy below the base model, from 80.0 down to 75.0. Deep ones raised it, 80.0 to 85.0 and 48.0 to 65.0. Repairing a single environment lifted the model trained on it from 16.2% to 38.5%. Across twelve environments, a 9B model went from 36.5% to 67.1% on fourteen evaluation splits, within fourteen points of the much larger frontier model that taught it. They release four environments as a benchmark with applications, seed data and grounded graders. Paper: Track trending AI papers in our academy:

Very interesting paper on recursive self-improvement. The whole stack is released. Machine learning engineering gives recursive self-improvement a concrete, executable testbed. OpenMLE is an open full-stack system for that research, spanning verifiable task environments with execution feedback, operator learning, and long-horizon search. On top of it the team post-trains Frontis-MA1, a 35B meta-evolution agent aligned around four atomic program-evolution operators. Draft, Improve, Debug, Crossover. The same four operators are trained through execution-grounded SFT and RL, then composed into long-horizon search, so learning and evolution run in one loop. On MLE-Bench Lite under a 12-hour per-task budget on a single RTX 4090 capped at 12 GB VRAM, Medal Average climbs from 39.39% to 60.61% over the base model, reaching 71.21% with asynchronous search and benchmark-independent experience priors. That exceeds GPT-5.5 with Codex and approaches GPT-5.6 Sol and the 2.8T Kimi K3. With the framework fixed, swapping in the trained model raises Match-SOTA from 50% to 70%. With the model fixed, swapping in the search framework raises it from 20% to 50%. Paper: Learn to build effective AI agents in our academy:

"Intelligence too cheap to meter" battle is on! Given that DeepSeek-V4-Flash-Preview is already great for agentic tasks, there is no doubt this new checkpoint must be an absolute beast. 20+ point jump on TerminalBench-2.1! 1M tokens - in ($0.14) | out ($0.28). Insane price!

Opus 5 - Build a photorealistic ThreeJS app that zooms continuously through nine powers of ten, from a leaf on a branch down to the single magnesium atom at the centre of a chlorophyll molecule.

We have to be careful to not offload our understanding to agents. I think there is also a good opportunity to build agentic applications that encourage deeper understanding. For example, coding agents might make developers faster at the task in front of them. But this could leave them unable to extend the code afterward. Here is what they find in this work: 54 students built a website with either an agent that edits their code or a chatbot where they write the code themselves. Understanding was measured two ways, through comprehension questions and through an extension task performed with no AI at all. Agents helped with initial completion and hurt comprehension enough that users could not extend their own work. The damage traces to specific interaction patterns. Copy-and-paste prompting and auto-accepted edits both correlate with lower comprehension, which makes this a harness design problem rather than a verdict on coding agents. Students reported weaker understanding and still preferred the agent because it was quick and easy. The authors point at dissuading low-effort prompting, generating more readable code, and promoting active engagement. Paper: Track more trending AI research papers at

Finally a good paper testing if file-system based memory for LLM agents is worth it. First, what does this look like? Deployed agents keep long-term memory as a folder of markdown files they read and reorganize with ordinary file tools. Two assumptions had never been checked. That an agent can keep a growing store organized as memories accumulate, conflict, and go stale. And whether the organization pays for itself. Organized stores roughly halve retrieval cost when the material is large. No agent in the study converted organization into better answers, and in the growth study the store degraded for every management agent except the strongest one. Changing the tool set alone reshapes the memory store as strongly as swapping the model. Paper: Track more trending AI papers in our academy:

AI tutors are something else when using voice agents. (🔊sound on) Just built this math tutor with Fable 5. Voice powered by Grok Voice Think Fast 2.0. This is rough, but just imagine how much better this will get with newer models.

// The agent is its own best speculator // Agents spend a large share of wall-clock time waiting on tool results. Speculation hides that latency by predicting and pre-executing the next call, but external draft models and cached traces are modeling a different policy, so they miss too often to help. New research from UC Santa Barbara and LinkedIn unifies both roles in one model. It runs in agent mode to solve the task and in speculator mode to predict its next tool call from a partial trajectory, fully reusing the prefix KV cache. Joint agent-speculator reinforcement learning derives speculation targets from the agent's own rollouts and alternates updates between the two modes, which keeps dual-mode training from degrading task success. Next tool-call Hit@1 rises from 44.1 to 61.2 for Qwen3-4B and from 48.9 to 66.3 for Qwen3.5-4B, with agent task success preserved. Paper: Learn to build effective AI agents in our academy:

Super interesting new work from NVIDIA. (bookmark it) They suggest building agents as Python objects. Very cool idea and I think it could a lot with agent reliability. More below: Agent development today spreads across prompt templates, tool schemas, callback code, and workflow graphs. NOOA replaces all four with one abstraction. An agent is a Python object. Its methods are the actions the model can take, its fields hold state, its docstrings are the prompts, and its type annotations act as contracts. A method whose body is "..." gets completed at runtime by a validated LLM loop. A method with a normal body stays deterministic Python. That single convention puts the boundary between probabilistic and deterministic behavior right in the source. Agent behavior becomes testable, traceable, and refactorable with the same tools you already use on the rest of your codebase. NVIDIA reports six model-facing ideas combined on one surface, including pass-by-reference over live objects and model-callable harness APIs for context and events, evaluated on SWE-bench Verified, Terminal-Bench 2.0, and ARC-AGI-3. Paper: Learn to build effective AI agents in our academy:

// Unfolding Sub-Agents for Long-Horizon ML Engineering // Watch a single agent work a machine learning engineering task for six hours you see issues like context fills with stack traces, dead experiments, and half-finished runs, and the strategic thread disappears under the noise. Matryoshka Agent splits that work across two levels. > An Orchestrator holds compact long-horizon exploration state and issues strategic instructions. > Sub-Agents run concrete solution attempts against the environment through a standardized tool interface and report back. This new paper contributes an efficient training paradigm for the hierarchy, so the structure is learned rather than prompted, with results across diverse model types and scales. Paper: Learn to build effective AI agents in our academy:

After a few more hours, I think I've figured out Opus 5. Opus 5 is trained to be more agentic than anything I've used. All Claude 5 models are like that. So what changes? The way to interact with Opus 5 or contextualize it won't work the same way as with other models. It loves exploring, so it doesn't need much guidance for it. Unique preferences, artifacts, and references compliment it well and enable cleaner and more effective exploration and execution. Now that it can explore more effectively on its own and understand intent better, the best thing to do is to get out of its way (e.g., it doesn't need examples of your preferences; a clear high-level description of it works best). It's truly agentic in that sense. A good first step to provide better context for Opus 5 is to distinguish between what's situational and what needs persistence. Regardless, persistent system prompts and CLAUDE.MD needs to stay lightweight. Remove memories and tool descriptions from these. CLAUDE.MD is also a great place to tap into progressive disclosure by linking command/skills to it. On the situational side, agent skills and auto-memory can leverage progressive disclosure and the improved ability of the model to use its external context/knowledge. Conflicting and unnecessary instructions, which are common at this layer (mainly to ensure reliability), are going to throw off this model easily. That's the biggest change I had to make. Simple, clean, and clear prompts and skills work best. I had to clean a lot of my skills and system prompts. The way I prompt remains the same (usually clear and well-scoped). MCP tool descriptions are also more descriptive and have been deduped from the system prompt. Anthropic released a guide on the new rules for context engineering, which was helpful here. I started to test the recommendations and created a little artifact with the things that worked along the way. This might feel like a lot of work. Believe me, it has been frustrating. But I think we can expect future frontier models to become more agentic and smarter at figuring out the right context/gaps. The best thing to do is to prepare for that now. @bcherny mentioned that Opus 5 is their least prompt-injectable model yet. I am not sure if that was something they intentionally trained for or if it emerged based on how it was trained, which is to be extremely agentic in nature and more direct in execution.

Replit just launched Replit Design. Looks amazing! Designing is hard, and AI agents tend to generate mostly generic stuff. This will help tremendously. I like that Replit Design acts as a thoughtful design partner and suggests more personalized designs for your apps.

On benchmarking long-context agentic instruction following. Agent benchmarks mostly reward reaching the answer. This new benchmark measures whether the agent reached it the permitted way, which is the question enterprise deployments care about. If you ship skills files, policy documents, or long system prompts, you have been trusting that they actually bind agent behavior. But how are you measuring all of this? Surge AI built a benchmark to actually check this. HANDBOOK.md places a standard operating procedure of 20 to 124 pages in context and grades whether it governed every action across an extended tool-use horizon. 65 tasks, five domains, ten fictional companies. Each task runs in a self-contained company environment with a file workspace plus mock email, chat, calendar, issue-tracking, and commerce services exposed over MCP. Every task mutates one of ten base handbooks, altering the specific rules and thresholds that grading turns on, so memorization does not help. Grading is fully deterministic and two-sided. 824 programmatic criteria check that required actions occurred and that prohibited actions did not. Paper: Learn to build effective AI agents in our academy:

You can now use Claude inside After Effects. Higgsfield's new MCP connector lets Claude work inside your actual AE project. It can build compositions, set keyframes, write expressions, and run the repetitive ExtendScript work for you, and everything it makes becomes an editable AE scene. More creative tools should work this way: an assistant that does the routine work while you keep full manual control. Try it here: