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:

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:

"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

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.

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:

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.

// Agentic Context Management // Great read for the weekend. (bookmark it) Production agents fail less on reasoning and more on what sits in their context. Conversation history, big prompts, huge tool definitions, and ballooning tool outputs pile up every turn. The common response is storage and retrieval, a place to stash memories and look them up. New research argues that framing is too narrow and names a fuller discipline, Agentic Context Management. It decomposes into five primitives, architecting, ingesting, scoping, anticipating, and compacting with consolidation. Naive accumulation grows token cost with the square of conversation length. Crude summarization buys linear cost but hits an accuracy cliff. Only compaction validated against fidelity gets you linear cost without losing what matters. A reference implementation reports 92% on LongMemEval and 93.2% on LoCoMo. Why does it matter? Context management is becoming a first-class production concern that operates across an entire organization. The five primitives give you a structured way to reason about where your token budget goes. Paper: Learn to build effective AI agents in our academy:

// Agentic Context Management // Great read for the weekend. (bookmark it) Production agents fail less on reasoning and more on what sits in their context. Conversation history, big prompts, huge tool definitions, and ballooning tool outputs pile up every turn. The common response is storage and retrieval, a place to stash memories and look them up. New research argues that framing is too narrow and names a fuller discipline, Agentic Context Management. It decomposes into five primitives, architecting, ingesting, scoping, anticipating, and compacting with consolidation. Naive accumulation grows token cost with the square of conversation length. Crude summarization buys linear cost but hits an accuracy cliff. Only compaction validated against fidelity gets you linear cost without losing what matters. A reference implementation reports 92% on LongMemEval and 93.2% on LoCoMo. Why does it matter? Context management is becoming a first-class production concern that operates across an entire organization. The five primitives give you a structured way to reason about where your token budget goes. Paper: Learn to build effective AI agents in our academy:

Recommended reading. But none of it is surprising or new. Newer models got better at understanding intent and using tools. The system prompt should store minimal text with your preferences that informs, not replace, model capabilities. This is why, if you use newer models in harnesses like Pi, the experience has improved significantly. Pi pioneered the idea of a minimal system prompt. Overall, the principle to follow is to avoid getting in the way of the model while ensuring it has the right tools and guardrails/access. In practice, keep your tools and skills simple and provide models with richer context (and different modalities where you can afford it and it helps). The biggest challenge I am facing now is evaluation and verifying results. HTML artifacts are brilliant for this and allow me to move faster. But there are new ways I am using to improve the process. Write-up coming soon.

Jensen H. joins X Mark Z. posting on X again Satya N. articlemaxxing on X Sundar P. doing customer service on X ...and many other cases. X is where it's at if you ask me. @nikitabier @elonmusk + X team 👏

Switching models mid-session is one of the fastest ways to inflate an agent bill. Every switch resets your prompt cache, and a cheaper model can end up costing you more. @daridotdev built their router to be cache-aware. It only switches when the move actually saves money, and it plugs into Claude Code, Codex, or whatever harness you already use. The router itself is an open-weight SLM.

Claude Opus 5 is here. Half the price of Fable 5 is great! But the big story is the token efficiency. I like this direction, as we need frontier intelligence that's also affordable.

I came across H1 from @handoffai, and it’s a nice example of vertical AI solving a workflow that general-purpose models still struggle with. H1 is designed specifically for residential construction blueprints. It analyzes complete plan sets and generates autonomous material takeoffs from raw PDFs. Alongside the model, Handoff published an industry benchmark showing H1 at 81.6%, ahead of experienced estimators and well above the frontier models they evaluated. Worth checking out if you’re interested in specialized AI systems. Read more: #sponsored#