A week that opens with a sentence that made my hair stand on end: Dario Amodei declaring that open source models are dangerous and must be limited or blocked. Anyone who has followed me for a while knows how much open source matters to me, and in the deep dive I explain why I remain baffled, disappointed and worried: the move reminds me of Bill Gates, who in the late nineties used to say that Linux was a dangerous system. My thesis, as a European citizen, is that I see no alternative to open weight models, and that our contribution travels along two paths: local inference, the way antirez does it with DS4, and the optimization of harnesses and the surrounding software, which is where I am betting everything, with GLM, Ollama and OpenRouter, and which brings me back to my old fixation with multi-model setups. So much so that on the podcast I cut 90% of my Anthropic subscription. In the links section you’ll find the surrounding themes: Fable 5 returning after the export controls, the new Sonnet 5, Nano Banana 2 Lite and the Thinking Machines interaction models, Anthropic’s drug discovery and DeepSeek’s DSpark. Happy reading.

My agenda

Podcast:

• On Saturday “US AI and open source policy makes my hair stand on end” came out: I cut 90% of my Anthropic subscription after the Fable move and Dario Amodei’s words. Listen

• Our projects Lince.sh and AntiVocale (Google Play, GitHub), by now you know them well. Also take a look at Agent ready skills, which I talked about on June 24 at AIConf.

• We’re thinking of doing short weekly lives on YouTube and X, around lunchtime, to show you practical things about our projects, personal agents and different uses of AI.

On my own:

• Finally a quiet period for my public speaking. After all, summer has arrived, but we’re already working on September.

• As soon as the videos from the conferences of the past few months come out, I’ll point you to them, because I’d love your feedback.

Open source as a danger? Amodei’s thesis, and why I don’t share it

Anyone who follows the podcast knows I already covered it there too, but I really can’t open this edition with anything other than Dario Amodei’s words, when he declared that open source models are dangerous, cannot be left unrestricted and must be limited or blocked. Anyone who knows me, in person or because they’ve followed me for a while, knows how important open source is to me. And although I can see the problems, and the dangers of handing such a powerful technology to everyone without regulation, I can only remain baffled, disappointed and worried by anyone who wants to put a limit on open source.

I said it on the podcast and I’ll repeat it here: this statement reminds me, in a striking way, of Bill Gates, who in the late nineties used to say that Linux was a danger to cybersecurity and security in general.

I even understand Amodei when he observes that open weight models are only partially an open source version, because they don’t tell us everything about the models. But it is surely better to know something and to be able to control something, rather than dealing with the black box of fully closed source models like Anthropic’s.

If we add to this the American policy, increasingly invasive and dominant in choosing which models can be “exported”, in their words, and therefore usable outside United States citizens, I think it is a duty, as a European citizen, to start thinking about how Europe and the rest of the world can protect themselves. From this point of view, I see no alternative to using open weight models. And I think it is important that European researchers and developers start asking themselves what contribution they can give to the open source world.

It is difficult, today, to contribute to generating new models: it takes capital and long-term planning, and Europe, unfortunately, is far behind on both, with the possible exception of Mistral, which in any case remains decisively further behind than the Chinese models.

The possible paths, then, even while using Chinese-style models, are two. The first is the one antirez, and others with him, are pursuing: optimizing local inference. His DS4 project is very promising and is becoming well known in the community of those who want to run local inference, but it requires hardware that not everyone has.

There is then a second possible contribution: optimizing the harnesses and all the surrounding software around these models, while using them through remote inference. Right now I’m relying on GLM and on Ollama in the cloud, as well as on OpenRouter. GLM is an extremely powerful model, and probably the one among open weight models that, on coding, comes closest to the performance of the main closed source models like Anthropic and OpenAI; as an early adopter I have a discounted invite to try it. Ollama and OpenRouter, on the other hand, let you use and try many different models.

Why is being able to use different models important? Anyone who read last week’s newsletter knows I talked about using multiple models to achieve similar or better results than larger monolithic models. It’s an idea that has fascinated me since the days of my wise-agents PoC, and that today I find again in projects like Sakana’s Fugu or Hermes’ Mixture of Agents (MoA).

In the coming weeks and months I’ll devote much of my experience to figuring out whether, and how much, mixing multiple models can be a viable path at the engineering level. From me, as usual, you’ll know everything: I’ll talk about it here and I’ll release as open source the software I produce.

Links that caught my attention this week

Redeploying Fable 5

It’s the most direct connection to today’s deep dive. Fable had been interdicted precisely by the export control policy I mentioned, and now it’s back, with an updated safety classifier and a framework shared with Amazon, Microsoft and Google to classify the severity of jailbreaks. Good that access has been restored. The lesson, though, remains: if a model can disappear by political decision, the open weight insurance policy is not an option, it’s a necessity.

Claude Sonnet 5

Sonnet 5 closes the gap with Opus 4.8 at much lower prices, and you can feel it. The Sonnet family opened the agentic era, and this version makes a clear leap on planning, tool use and coding. I use it every day, and as a model it’s excellent. I’m still left with the doubt from the deep dive: it remains a closed black box, and that limits how much I can build on top of it in a way that’s truly mine.

Nano Banana 2 Lite

Google is pushing the accelerator on low-cost media generation: Nano Banana 2 Lite generates images in a few seconds for a handful of cents, and Omni Flash brings conversational video editing at accessible prices. The theme for me is another: when components become this cheap and fast, it makes more and more sense to compose multi-model pipelines, the thread I talked about in the deep dive and that I’ll devote the coming weeks to.

Inside Thinking Machines’ Interaction Models

This one I find truly fascinating, and it connects to two themes of mine. The two-model scheme, a fast one for conversation and a slow one for reasoning, is the fast path and slow path pattern I was talking about. And then they move interactivity inside the model instead of pasting it on the outside with a harness of small components. It’s a direction that aligns with where I think the agentic world is heading.

Anthropic launches AI drug discovery program

Anthropic enters drug discovery, and does so focusing on neglected diseases that the market ignores. As a story, it’s a nice one. And it fits into a thread I believe in: scientific research is fertile ground for agents, because a molecule either works or it doesn’t, and it’s where results are verifiable that AI gives its best. The irony, after the deep dive, is that it’s precisely Anthropic, the black box par excellence.

DeepSeek open sources DSpark

I’ll close with a link that speaks straight to the deep dive. DSpark is DeepSeek’s open source speculative decoding, and it speeds up inference by up to 85% without changing the model’s output. It’s exactly the kind of contribution I was talking about: not generating new models, but optimizing the surrounding software, the harnesses, the inference. That it comes from DeepSeek, and in open source, reinforces the point: the open ecosystem is working precisely on the pieces that matter.

This is the week I come back to an idea I’ve been chasing for years, ever since two years ago I was trying it out with a PoC called wise-agents: getting multiple small, specialized models to work together instead of handing everything to a single giant brain. Back then it was too early, today I find it everywhere. In the deep dive I line up the milestones, from Karpathy’s council to OpenRouter’s Fusion Router, all the way to Sakana Fugu, which presents itself as a model but underneath is a multi-agent system. My thesis is that the unit of measure has shifted from the single model to the team and whoever directs it, and that with a good multi-model harness much of those results are already within our reach. Not by chance Simone Basso, in the interview you’ll find in the agenda, puts it better than I do: the model is a commodity, the harness is the asset. In the links section, the surrounding themes: the White House slowing down GPT-5.6 (and here the frontier held hostage by politics comes back), Liquid AI’s on-device little model, OpenAI’s Jalapeño chip, computer use on Gemini Flash, fine-tuning MoEs with NVIDIA, Apple’s price hikes on RAM, and Mercury 2 generating a thousand tokens per second. Enjoy the read.

My agenda

Podcast:

• New interview with Simone Basso (CTPO WeRoad): why “the model is a commodity, the harness is the asset” and how they actually apply it at European scale. Inside, also the 150 AI licenses given to the whole company (not just the devs) and the real ROI of coding agents, Anthropic’s 8x seen by someone who measures it.

• On Saturday “Physical AI: VLA vs World Model” came out: with Vittorio from Cyberwave we figured out why you build a software agent in two hours and a physical one in two years. Listen here.

• Our projects Lince.sh and AntiVocale (Google Play, GitHub), you know them well by now. Take a look also at Agent ready skills, which I talked about on June 24 at AIConf.

On my own:

• On June 24 I was in Milan as a speaker at AIConf. Thanks to everyone who attended and gave me feedback on my talk. You can find the slides, the feedback form and all the links here, and I’ll soon add the video of the talk as well.

• On Tuesday the 30th at 8pm I’ll do a live on X and YouTube with Ivan Fioravanti. Topic: personal agents, Hermes and GBrain. Follow along... there might be some surprises.

Multi-model and multi-agent systems: two years ago it was too early, now we’re here

Two years ago I was getting my hands on a PoC called wise-agents. The idea I was chasing was this: a multi-agent system in which many small models divide the task and orchestrate among themselves to solve complex problems, instead of handing everything to a single giant model. It worked in fits and starts, and it was clearly too early, the models of the time couldn’t keep up. But the intuition, two years on, I now find everywhere.

The first to make it popular, months ago, was Karpathy with llm-council: you ask a question, the whole council answers, each model reads the others’ anonymized answers and ranks them by quality, and a chairman synthesizes the final answer. Anonymized on purpose, so no model roots for its own brand. He himself says he won’t support it (”code is ephemeral now”), but the toy caught on, and from there a fair number of implementations have sprung up, more or less professional.

Then OpenRouter came along to bring it into production with its Fusion Router: up to eight models answer in parallel with web access, a judge compares the answers (compares them, doesn’t merge them: consensus, disagreements, gaps, blind spots) and your model synthesizes. It’s solid, but with a limitation I feel I should point out, it was designed and tested mostly, perhaps only, on deep research. Outside that use case it’s still terrain to explore.

And finally comes Sakana Fugu, which is the most interesting move because it flips the perspective. Fugu presents itself as a model, you use it as if it were a single LLM, but under the hood it’s a multi-agent system: an orchestrator that understands the request, builds the agentic scaffold on the fly and routes the work to a team of specialized models. And the numbers are there, SOTA on SWE-Bench Pro, Terminal Bench, LiveCodeBench, GPQA, even Humanity’s Last Exam. There’s already an open reproduction too, OpenFugu, which defines the heart of the system with a phrase that stuck with me, “a policy over models”, and measures +107% over the best single worker.

The point I want to bring into focus is exactly this. There’s a lot of talk about orchestration, and rightly so, orchestration is the concept that ties together Karpathy, OpenRouter and Fugu. But underneath they’re all multi-agent systems: not a better model, but multiple agents, often different models, that divide the work and reassemble the pieces. It’s a change in the unit of measure: the interesting object is no longer the single model, but the team and whoever directs it.

And here I come back to my fixation, the harness. Because if you think about it, much of this result is possible if you use a good harness, supporting different models and vendors for agents and sub-agents. That’s why lately my attention has shifted to harnesses and to how to have the right context and tools to support advanced, multi-agent workflows and loops with well-defined long-term goals. It’s the orchestration, the scaffolding around the models, that makes the difference, not just the model, especially when the result we measure isn’t that of a chatbot interaction, but a complex task accomplished over hours of work.

Lastly, I’ll stress again that these systems are at their best where the answers are comparable and verifiable. Where there’s a verifier, on code or on math, the judge has something solid to hold on to. On more blurred terrain the gain is there, but it’s less guaranteed. It’s not a flaw, it’s just the perimeter within which it pays off most today.

Two years ago it was too early. Now the idea is mature, the models can keep up, and the question is no longer which model to choose, but how to make them work as a team.

The links that caught my eye this week

The White House asks OpenAI to slow down the release of GPT-5.6

Here I find, almost photocopied, last week’s discussion about Fable and Mythos. The frontier becoming hostage to a political decision, complete with government approval client by client, is no longer an isolated case, it’s a pattern. And every time it happens, my thesis on open weights as an insurance policy gets stronger.

Liquid AI releases LFM2.5-230M

A 230-million-parameter model that its own authors advise against for heavy reasoning, but that flies on instruction following, extraction and tool use. It’s exactly the kind of specialized worker I talked about in the deep dive: not the all-rounder, but the right piece for a precise task inside a multi-agent system, and on-device to boot.

Jalapeño: OpenAI’s new chip

Two things strike me. The first is the complete vertical integration, from products to models down to the silicon: OpenAI wants to control the whole stack. The second, even more interesting, is the tape-out in nine months accelerated by their own models, which leads straight back to the theme of recursive self-improvement. The perf-per-watt numbers, though, I’ll wait for on real silicon.

Computer Use comes to Gemini 3.5 Flash

That computer use is landing in a small, fast model like Flash is already notable, but the part I really watch is another: user confirmation on sensitive actions and an automatic stop in case of prompt injection. It’s the permissions and governance problem I’ve been repeating for months, and the one we work on with Lince. Without those controls, you don’t put long-horizon computer use into production.

Speeding up fine-tuning with NVIDIA NeMo AutoModel

Making MoE fine-tuning accessible with a single import line, and bringing within reach models that were previously out of scale, is the kind of unflashy work that nonetheless feeds everything else. If we really want multi-agent systems with workers fine-tuned specifically for their piece, we need exactly tools like these, that lower the barrier to entry.

Apple raises Mac and iPad prices over the memory chip shortage

Seemingly boring news, but there’s a short circuit that makes me think. Unified RAM is precisely what makes Apple the best machine for local inference, and now it’s the memory chip shortage, driven by AI, pushing prices up. The AI boom makes the hardware you need to bring it home more expensive, a friction on the hybrid future I talk about often.

Inception Labs’ Mercury 2 beats Google’s DiffusionGemma

I’ll close with a model that speaks straight to the deep dive. The headline is speed, a thousand tokens per second thanks to diffusion, but the detail that makes my ears perk up is that it’s explicitly pitched for multi-agent systems. It makes sense: when you multiply the calls between agents, latency adds up, and a worker this fast changes what becomes feasible.

This is the week I finally tackle the Fable saga head on, the one I had deliberately left hanging in the past issues while waiting for the dust to settle. Now the dust has settled, and not in the way I’d hoped: the White House has cut off access to Fable and Mythos, and for us Europeans the message is a heavy one. In the deep dive I start from here to get to my thesis: in a world where American frontier models can be taken away from us by political decision, open weight models become far more than a technical alternative, they are the only form of independence we have left. DeepSeek, MiniMax, GLM and Kimi are in great shape, and I’ll tell you why GLM 5.2 has been my favorite for usage experience for months. In the links section you’ll find the themes that round out the picture: OpenAI preparing GPT-5.6 and cutting prices while Anthropic is in trouble, Midjourney surprisingly building a full-body ultrasonic scanner, Factory 2.0 and software factories, the autonomous research agent Sakana Marlin, the path to ASI according to DeepMind, and loop-driven development that puts down in writing the thread of last week’s deep dive. Enjoy the read.

My agenda

Podcast:

• New episode of Risorse Artificiali: Paolo clones his own voice locally and for free, and from now on he no longer trusts a voice message. Listen.

• In the same episode: the Fable withdrawal, Codex 5.5 vs Opus 4.8 and why we no longer look at the code we write with agents.

• Our projects Lince.sh and AntiVocale (Google Play, GitHub), you know them well by now.

On my own:

• I was in Catania as a speaker at Coderful, one of the best organized conferences with the best content I’ve seen recently. You can find my slides here; as soon as it’s available, you’ll find the video there too.

• On June 24 I’ll be in Milan as a speaker at AIConf.

When the frontier is held hostage by politics

The Fable saga, which I’ve been following for a couple of weeks and which until now I hadn’t wanted to make the deep dive about because it felt too early to draw conclusions, has reached the point I feared. The White House has cut off access to Fable and Mythos, and the serious part isn’t so much the block itself, but the intention behind it: apparently the idea was to ban it only for non-American citizens. Then, struggling to tell them apart one by one, Anthropic ended up shutting off the taps for everyone. If that’s the right reading, the message is a heavy one, especially for us Europeans: the gap with the United States, instead of narrowing, risks becoming even more pronounced.

And so the question becomes a single one: if American frontier models can be taken away from us overnight by political decision, what do we build on? My answer, right now, is clear: open source models, or to be precise open weight. They seem to me the best alternative, and perhaps even the only one, given that on the European front Mistral is still well behind the state of the art. The beauty of open weights is exactly this: you hold the weights yourself, no directive can revoke them with the stroke of a pen.

The good news is that the alternative really does exist, and it’s in fine form. DeepSeek, MiniMax, GLM, Kimi are all excellent options, and over the past few weeks they’ve released new versions one after another. DeepSeek just closed a $7.4 billion round that crowns it China’s most valuable AI startup, and Kimi K2.7 Code pushes on agentic coding with a one-trillion-parameter MoE. They’re also great for local inference, which I talk about often, but they remain interesting as models regardless of where you run them.

And here a circle closes that I had left open just a couple of weeks ago. When I was talking about the local trend and hybrid architectures, I had tossed out a prediction: since we were starting to see governments banning the use of the most powerful models, we might soon need them for real. Well, here we are. Having models of this caliber running on our own machines is no longer just a matter of cost or privacy, it’s a form of technological independence.

Out of all of them, the one I want to spend a few words on is GLM. Version 5.2 has been called “Opus level”, SOTA in other words. Not the absolute best, that spot still belongs to GPT-5.5 for now, but by a truly slim margin, and in any case a model capable of handling long and complex tasks. For me it’s already the primary model for Hermes Agent and the fallback for coding, though I suspect it’ll soon become one of the primaries there too. I particularly like using it with a minimal, extensible harness like Pi.

I’ve been using it since last November, and I’ve always found it among the best open source models. Careful, I’m not talking about innovation: there DeepSeek remains by far the most interesting in terms of research, both in version 3 and version 4. I’m talking about usage experience, and on that front GLM has been at the top for me for months. I’m not the only one who thinks so: antirez is integrating it into DS4 as well. One last practical note, as an early adopter I have a link for 10% off the subscription, and it’s still valid if you want to try it.

Back to the starting point: as long as access to frontier models depends on a directive that can change from one day to the next, open weights aren’t a fallback, they’re our insurance policy. And luckily, today, it’s a policy that covers almost everything.

The links that caught my eye this week

OpenAI is preparing the GPT-5.6 models

The detail that jumps out, especially after the deep dive, is the timing: OpenAI is aggressively cutting prices to undercut Anthropic right while Fable is stuck in American regulatory trouble. These are still rumors, so I take the numbers and dates with a grain of salt, but the 1.5 million token window and the push on long-horizon coding tell you where the game is being played.

Midjourney builds a full-body ultrasonic scanner

This is the news item that has nothing to do with the others, and that’s exactly why I’m keeping it. That a company born to generate images would start building full-body ultrasonic scanners, complete with spas, is a leap I struggle to frame. The 60 seconds versus the hour and a half of an MRI I find hard to believe until I see real data, but if confirmed it’s physical AI to keep an eye on.

Factory 2.0: from coding agents to software factories

Here I find, almost word for word, the thesis of last week’s deep dive: the engineer who stops writing software and starts building the factories that build it. What strikes me most is the pillar of model independence and sovereign intelligence, which ties directly into today’s open weight discussion. The risk, as always, is that it stays more manifesto than product.

Sakana Marlin

An agent that works autonomously for up to eight hours and churns out hundred-page strategy reports is exactly the kind of long task that fascinates me. But I stay true to my fixation: agents are at their best where the result is verifiable, and strategic analysis is far more slippery terrain than code. The real question is how Marlin verifies its own conclusions.

Google DeepMind and the path to ASI

What I appreciate about this paper is its sobriety: no single magic moment in which AGI becomes superintelligence, but a series of progressive transformations, with bottlenecks and frictions put down in black and white. It’s a framing I share, and one that counterbalances the imminent-revolution tone. A good forty minutes of reading, but if the long term interests you, they’re well spent.

From test-driven to loop-driven development

If you read last week’s deep dive, here you’ll feel like you’re looking in the mirror: trigger, goal, harness, verifier and state around the agent’s loop are almost the same ingredients I used to try to define loop engineering. The central point is the one I always repeat, the more autonomy you give the loop, the stronger the checks have to become. It’s nice to see the concept consolidating in the community, and not just in my head.

A week where I go back to a theme that has been with me for months and that, with LINCE, I have ended up handling up close: what an agent really is, where its boundaries begin and end. In the deep dive I try to line up how the concept has evolved, from harness engineering to loop engineering, all the way to a thesis I care about: harness and loop are becoming the minimal unit through which we access agents, more a process running in a second-level operating system than an app with an LLM stuffed inside. I read it through the investments of recent weeks, from OpenAI acquiring Ona to Xiaomi with MiMo Code, all the way to the sandboxes from NVIDIA and LangChain. In the links section you will find the themes that frame the picture: Google pushing on local with DiffusionGemma and Gemma 4 QAT, the Claude Fable 5 saga (launched, leaked by Pliny and then suspended by a US directive), and two applications of AI to scientific research, Claude as a chemist and Codex simulating black holes. Enjoy.

My agenda

Podcast:

• New interview: Roberto Stagi (Ratel AI) explains why an agent’s context does not saturate because of MCP servers, but because the tool index stays inside the model. Open source, open benchmarks. Listen. It also covers “agent anxiety”: the unease of not having an agent at work while you are having lunch at the beach, more common than we admit.

• Saturday saw the release of “Writing code is a commodity: Fable and workflows”, where I hand Fable a multi-language task and it brings it home overnight with 40 agents in parallel, zero-shot. From there: loop engineering and Anthropic’s article “When AI builds itself”. Episode

• Our projects Lince.sh and AntiVocale (Google Play, GitHub), by now you know them well.

On my own:

• I was in Catania as a speaker at Coderful, one of the best organized conferences with the best content I have come across recently. You can find my slides here; as soon as it is available, you will find the video there too.

• On June 24 I will be in Milan as a speaker at AIConf.

Harness and loop: the new minimal unit of agentic AI

Part of my work over these months, especially on LINCE, has been trying to give a definition of an agent: where it begins, where it ends, where its boundaries run. I am not here to tell you the details of that project, but one thing that work forced me to do is to look closely at how the very concept of an agent, and of its boundaries, has evolved in recent months. It is a story worth telling, because I believe it is changing the basic unit we reason with when we talk about agentic AI.

The starting point is something I have been saying for weeks: to build agents, great models and a few tools are not enough. The harness, that is the scaffolding around the model, is becoming the central piece, and how you couple the model to the harness matters as much as the model itself. The skills of those who work seriously on these systems have shifted accordingly: before we talked about harness engineering, and recently the community (Boris, the creator of Claude Code, first of all) has started calling it loop engineering. Behind these two terms there is a precise idea: beyond the context you give the LLM, there is a lot more to take care of.

Harness engineering adds, to context curation, the ability to define the limits within which we want the agent to move, the harness itself. It means giving it a sandbox, some evals, a way to verify its own work. By adding these boundaries, the agent can move with more autonomy and handle longer, more complex tasks. Loop engineering goes a step further: if we want even greater autonomy, we also have to define the limits of the loop within which the harness cycles to reach the result. A loop is made of an initial state, an event that starts it, a goal to reach, a set of consolidated behaviours (the skills), a working state (the memory) that keeps track of what has been done and what remains to be verified, and decision mechanisms to figure out whether to continue or whether the goal has been reached.

The distinction, if you want a compass, is this: the harness defines the space in which the agent can move, what it is allowed to do and what it is not; the loop defines the time and the decision, how many times to repeat and when to stop.

Putting the two together, what we call an agent starts to look more and more like a process running inside an agentic operating system, a kind of second-level operating system, in which the harness defines the limits and the loop manages the processes. And this bond between LLM, harness and loop is defining a new minimal entity: a unit of work that we can move onto the machine, the network, the cloud. Not a microservice like the web or REST ones we are used to, but something closer to a pod.

Let me explain with an analogy I am fond of. When I interface with a database using SQL, I take for granted that logging, writing to disk and transaction management are handled by the server, without my having to plug them in every time. A database server writes to disk and keeps transactions, full stop. In the same way, when I interface with an agent (that is, with its harness and its loop), I take for granted that it has skills, evals, a sandbox. Thinking of evals, sandboxes or guardrails as pieces to stick on top of some code that talks to an LLM is a view that holds up less and less: those pieces are an integral part of the unit we work with.

And that is exactly what the investments of recent weeks tell us. You no longer build an application with the LLM tucked inside as a tool, which is what LangChain, LlamaIndex and the others did a couple of years ago. You build on top of the agent, understood as LLM plus harness plus loop, treating it as the system in which to make your AI-native applications live. OpenAI acquired Ona (formerly Gitpod) precisely to give Codex secure, preconfigured cloud environments and to orchestrate persistent, long-running tasks. Xiaomi released MiMo Code, an open source coding harness that, by their account, holds up over sequences beyond 200 steps with a persistent memory entrusted to subagents (self-reported numbers, I take them with a grain of salt, but the direction is that one). NVIDIA published SkillSpector to analyze agents’ skills for vulnerabilities before installing them. And even LangChain now offers hardware-isolated microVMs to give each agent its own dedicated computer.

It is a bit like writing your own app in HTML5. Underneath there are layers upon layers (the browser doing the rendering, the JavaScript engine, HTTP, TCP/IP, the sockets), each with its own mechanisms for security, tracing and verification, and each of which we take for granted. Nobody plugs in the sockets by hand. The harness and the loop are becoming that kind of layer: in a word, they are the new minimal entity through which we access agents.

The links that caught my eye this week

Local, even at Google

• DiffusionGemma: text generation 4x faster

• Gemma 4 QAT: compression for mobile and laptop

DiffusionGemma is a 26B MoE that generates blocks of text in parallel with textual diffusion, up to 4x on GPU. Gemma 4 QAT brings quantization-aware checkpoints to run on mobile and laptop without losing quality.

DiffusionGemma and Gemma 4 QAT confirm the local trend I was already talking about in recent weeks: there is more and more attention on local models, even from Google. The two pieces of news, by the way, attack the two real bottlenecks of inference at home: latency, with parallel block generation, and memory, with quantization. The right applications for smaller models still need to be found, but the growth of hardware will lead to increasingly powerful models that can run locally. And given that we are starting to see governments, like the US one, restricting the use of powerful models, I believe we might soon need it for real.

The Fable 5 saga

• Claude Fable 5 launch

• Access to Fable and Mythos suspended

• Pliny’s system prompt leak

• Anthropic walks back the policy that “sabotaged” researchers

Anthropic launches Fable 5 and Mythos 5, then a US export control directive suspends access over a possible jailbreak. Pliny leaks the system prompt, while Anthropic withdraws the policy that quietly degraded researchers’ requests.

Fable 5 is, or rather was, since the US government banned its use, a bombshell. I talk about it in last Saturday’s podcast: its ability to handle very complex tasks is genuinely remarkable. I could have made it the deep dive, on this and on all the news it generated, from researchers railing (rightly) against overly strict limits on LLM work, then loosened by Anthropic walking back, all the way to the US government banning its use. I deliberately did not make it the deep dive, because I believe we will see more plot twists in the coming days and it seems too early to draw a synthesis. Meanwhile Pliny (a well-known name in the hacking world) leaked the system prompt, and apparently using that system prompt on Opus yields better results than the vanilla version of Opus 4.8. I have not tried it yet, but it seems like further confirmation of how the so-called in-context learning phase can no longer be overlooked: if a well-crafted system prompt shifts the results of an already powerful model like Opus 4.8, it means much of the value lies not just in the weights, but in how the harness sets up the context. And that is exactly the thread of this week’s deep dive.

AI enters the lab

• Making Claude a chemist

• Codex to simulate black holes

Claude predicts NMR spectra matching ChemDraw and MestReNova and proposes molecular structures from spectral data. Astrophysicist Chi-kwan Chan uses Codex to refine simulations of plasma and particles around black holes.

These are both applications of AI to computational scientific research, perhaps the next frontier where we will see agents perform the feats we now see on code. It is no coincidence that coding was the first domain to take off: like code, scientific simulation is an environment where verification, however hard, remains manageable, because a computation either matches the data or it does not. And those who have been reading me for a while will have learned that it is precisely where results are verifiable that agents give their best.

A week in which I come back to a topic close to my heart for a while now: how we are optimizing AI to run locally, and where all of this is taking us. In the deep dive I try to line up the pieces, from the work on small models, quantization and minimal harnesses all the way to hardware, with Apple currently winning hands down and NVIDIA trying to respond with the RTX Spark. My thesis is that the future is not local versus cloud, but a hybrid architecture in which the two complete each other: run at home what you can, and call the cloud only when you really need to. In the links section you will find the themes that frame the picture and round it out: a tool to compare Ollama models locally, Anthropic on recursive self-improvement, Google’s Sleep paradigm for models that learn on their own, the real bottleneck of enterprise agents (permissions, not the model), dreaming in ChatGPT’s memory, Open Code Review and NVIDIA’s new Nemotron-3-Ultra, with its open weights and datasets. Enjoy the read.

My agenda

Podcast:

• Saturday saw episode 55 of Risorse Artificiali, “Dynamic workflows: the AI that writes its own harnesses”: with Opus 4.8 every agent generates its own custom tool in JavaScript on the fly, and we discuss what this means for security and sandboxing. Listen

• In the same episode: why benchmarks are not comparable (it is the harness that counts, not just the model), MiniMax M3 and the Hassabis interview with YouTube’s automatic dubbing.

• Our projects Lince.sh and AntiVocale (Google Play, GitHub), by now you know them well.

On my own:

• I was at PyCon Italia as a speaker: you will find all the content from my two talks, as always, on maeste.it in the section dedicated to talks. I will also put the videos there as soon as they are available.

• On June 12 I will be in Catania as a speaker at Coderful

• On June 24 I will be in Milan as a speaker at AIConf

Hybrid architectures: AI runs locally, you call the cloud only when needed

For a while now I have been seeing a trend that keeps getting clearer: optimizing everything to run AI locally. You can see it on several fronts at once, and put together they tell a precise direction. There is the work on inference, there are the small models, there are the quantization aware models, that is, designed from training onward to hold up well under reduced precision, and above all there is an enormous amount of work on quantization, including asymmetric quantizations that try to squeeze every bit without losing quality. New architectures are arriving that remove the encoder or some decoding stages, along with harnesses designed in a minimal way, I am thinking of Pi, or built to run hand in hand with inference, like antirez’s DS4, all the way to systems like Unsloth that let you do inference and even fine tuning on the same machine. The underlying idea seems to be just one: having more and more systems running at home, and not just to play around.

In all of this hardware matters, and it matters a lot. Right now Apple is winning hands down thanks to the stability of its ARM architecture with shared RAM: if on many other fronts Apple is struggling, on the hardware to run things locally it has a turning point in its hands. NVIDIA and Microsoft are trying to respond with a competing system, the RTX Spark, because the DGX Spark remains too specific for most of us.

Before getting to my strong opinion, I want to clear up a possible misunderstanding. All this work on local does not clash with the push by frontier labs to concentrate ever more intelligence into SOTA models, quite the opposite. The two things complete each other, and it is precisely from their sum that the hybrid architecture I am talking about emerges. On one side the big labs will keep raising the bar of what a model can do, on the other a growing ecosystem brings part of that capability onto our machines. It is not a race between the two fronts, it is a division of labor that is taking shape.

And here is my strong opinion. Right now, to do local inference seriously, you need either hardware of a certain level, for example to run DeepSeek with DS4, or fairly specific use cases. Even though the latest small models, I am thinking of Gemma 4 12B, open the door even to RTX and ADA cards with 16 GB of RAM, and in the meantime open weight models keep growing in capability: MiniMax M3 confirms the will to carry forward, in the wake of DeepSeek V4, frontier coding, native multimodality and a one million token window, and on top of that at very low API prices. I, however, see a different future, made of hybrid architectures: running some operations locally, perhaps on purpose-finetuned models, and delegating to the cloud only when it is really needed. A bit like what we saw with “/advisor” in Claude Code, but flipped: the main model is the local one, and you call the cloud advisor only in the moments that matter. It is a direction similar to the one Perplexity proposes, which not by chance titles one of its pieces The data center moves to your machine.

And here I get to the part that intrigues me the most, because it is still all to be written. My gut feeling is that one of the engineering optimizations we will need is the ability to load models into memory in a much faster and more dynamic way, so we can load on the fly specific versions or ones with dedicated fine tuning depending on the task at hand. Today it is a challenge for which there are no clear solutions yet, and that is exactly why it is worth keeping our eyes open: it is one of those problems that, once solved well, will change the economics of everything else.

The links that struck me this week

Ollama Model Tester (GitHub Repo)

A small but clever tool, right in the spirit of this week’s deep dive. If you are experimenting with local inference, being able to run the same prompt across multiple models and compare the responses side by side saves you a lot of time. We are going to need more and more tools like this.

When AI builds itself

Anthropic openly talking about recursive self-improvement always makes a certain impression. I take the figure of eight times more code per engineer with a grain of salt, like all internal benchmarks, but the direction is that one and it is worth reading how they tell it.

Sleep for Continual Learning

Here Google tries to give models a kind of sleep: a phase in which they consolidate short-term knowledge into the parameters, complete with a Dreaming stage via reinforcement learning to generate their own curricula. It is exactly the strand of models that improve on their own that has interested me for a long time. Keep it in mind, because further down, with Open Code Review, the same pattern comes back: AI working on the work of AI.

The AI agent bottleneck isn’t model performance, it’s permissions

This piece says something I have been repeating for months: the bottleneck of enterprise agents is not how good the model is, but permissions and governance. And it is exactly one of the problems that with Lince.sh we are trying to help solve, working on sandboxing and on what an agent can or cannot do. Read it, because it frames the problem well.

OpenAI introduces “dreaming” into ChatGPT’s memory

After Anthropic’s Memory Files I talked about last week, OpenAI too is reworking memory, with a background system that turns past chats into a profile organized by categories. The memory topic has become one of the real battlegrounds between harnesses, and here you can clearly see where the game is heading.

Open Code Review (GitHub Repo)

And here we are at the hook I left you above with the Sleep paper. Here we are on concrete ground: a CLI that reads the git diff and produces precise line-by-line reviews, with the philosophy of combining deterministic engineering and an agent, letting each handle what it does best. It is the same division-of-labor idea from the deep dive, applied to code quality: AI that reviews and improves what AI itself produces, but with a deterministic backbone holding the line.

NVIDIA Nemotron-3-Ultra

I close with a model that speaks straight to the deep dive: 550 billion parameters but only 55 active, thanks to a hybrid Mamba-Attention MoE, with a one million token context window. The thing that makes my ears perk up is that NVIDIA publishes checkpoints, quantized versions and even the datasets: it is exactly the kind of openness that feeds the local ecosystem I was talking about.

Week of getting back from PyCon Italia, and with this issue’s deep dive I start from a provocation I have been carrying since those days: nobody reads the documentation anymore, neither developers nor end users. I tell you why this happens and which paths I am exploring to fix it, from the README as an entry point to terminal wizards, hierarchical help and onboarding skills for agents, with concrete examples taken from LINCE and antirez’s DS4. In the links section you will find the themes of the week: Pope Leo XIV’s encyclical on AI, the new DeepSWE benchmark that crowns Codex on coding, Anthropic’s Memory Files and Claude Opus 4.8 with Dynamic Workflows, the price war reignited by DeepSeek, and Reasonix, a coding agent built for open weight models. Enjoy the read.

My agenda

Podcast:

• On Wednesday the conversation with Andrea Saltarello (Improove, AIConf, Politecnico di Milano) came out: why AI adoption in companies is a cultural problem before a technical one, and how to train juniors in the age of agents. Listen

• On Saturday “The Pope understood LLMs better than we did” came out: Leo XIV’s encyclical opens, then saturated benchmarks, DeepSeek V4 and append-only context, microkernel harnesses and Claude vs Codex. Episode

• By now you know about our GitHub repository with tools and configurations for AI coding from the terminal on Linux. It now has its own site with single-script installation Lince.sh

• We released AntiVocale (Google Play, GitHub), a software to translate voice messages into text

On my own:

• I was at PyCon Italia as a speaker: you can find all the materials from my two talks, as always, on maeste.it in the section dedicated to talks. I will also put the videos there as soon as they are available

• On June 12 I will be in Catania as a speaker at Coderful

• On June 24 I will be in Milan as a speaker at AIConf

Who actually reads the documentation? From the README to onboarding skills

Nobody reads the documentation anymore. I say this mostly about developers, but it probably applies a bit to everyone, end users included. It is something that became clearly evident talking to so many people at PyCon Italia, which I just got back from and where I had two talks. One in particular was a workshop that dealt with exactly this: how to provide the right setup to a project, open source or not, so that agents can code well, that is, have all the information they need. My provocation during the workshop was precisely that: agents often get things wrong, but not because they are stupid, rather because they ignore the basics of the project.

The same thing happens with end users, be they developers or users of the project we are releasing, because really nobody reads the documentation anymore. In this period of information overload, due in part to AI, nobody bothers to do it: there are so many projects, and so many things people want to try, that the documentation just sits there, unread. I will add one more thing: the fact that we have gone back to the terminal, which I talk about often, is wonderful for many reasons on one hand, but on the other it makes the interface a bit less intuitive, at least for a certain slice of users.

I have been racking my brains for a while on the solution, because a user who does not read the documentation will probably not use our project to its full potential, and risks getting fed up soon: not because the project does not work, but because they could not get it to work for what they needed. And that is a shame, because it is entirely avoidable.

The solutions I have explored, in LINCE and recently with a pull request for antirez’s DS4, span several fronts. The first is making the terminal interface a bit more window-based, or wizard-guided, like Lince does with its agent creation wizard (the capital “N”), or like the LINCE dashboard itself, which brings icons and windows inside the terminal. The second is rethinking the README: the README as a single, exhaustive document is dead, and it must instead become an initial entry point, a sort of TLDR. The detailed documentation can live elsewhere, but by scraping just the README the user immediately understands what the project is for and what they can do with it. Of course it must also contain an invitation to read the rest. Along the same lines, configuration files should be as self-documented as possible, and it should be extremely easy to create versions tailored to the needs of whoever uses them: that is what we try to do with the learning mode of Lince.sh.

But there is one approach I like the most right now: creating onboarding skills for the agents themselves. The user, instead of reading the documentation line by line, arrives at the project, launches the skill and starts conversing with their own agent, instructed to stick only to the documentation and the command help. They thus get all the information they need in a way that has by now become the habit, conversation, but stays anchored to what you have actually documented. It is exactly the spirit of the skill I proposed to antirez for DS4 and of the one we already have in Lince.sh.

To do this, however, the command help also needs to be well organized, and here we come back to the starting point: it needs to be made usable by agents, even when it will not be the agents using it directly, but they will use it only to build the onboarding. A good example are Lince’s commands, but above all those of DS4, where antirez did an excellent job on hierarchical help, which I will try to take inspiration from for Lince as well.

And then, last but not least, we increasingly need different and somewhat more human content, to avoid the AI slop effect. That is also why I have a podcast, and why I write this newsletter: as you know it is no longer AI generated, the AI acts as my editor but what you read is written by me. The same goes for the videos that explain certain features. There, that is something I have not done enough for Lince.sh, and I am genuinely interested to know whether it is something you would like.

The links that struck me this week

Notes on Pope Leo XIV’s encyclical on AI

I talked at length about the papal encyclical on this week’s podcast, and I think it can be condensed like this: the Pope understood Large Language Models far better than Bernie Sanders and Walter Veltroni.

DeepSWE: the new coding benchmark

A new benchmark has appeared in the AI world, in particular for coding agents, and it is significant precisely because it is very new and very carefully curated, and therefore not yet saturated. The results are impressive and confirm the impression that, right now, Codex is better than any other agent and any other model at coding tasks.

Anthropic plans Claude memory update with new Memory Files

Anthropic, however, is not standing still and is working a lot on the memory aspects of its harness. A link definitely worth reading.

Claude Opus 4.8

And as confirmation that Anthropic is certainly not standing still, Claude Opus 4.8 is out, bringing an incremental improvement over 4.7. Perhaps the most significant thing is that as of 4.8 the Dynamic Workflows are available, which look a lot like the agent swarms Google already launched with Antigravity. And exactly like the Antigravity swarms, they are extremely expensive: before you start using them, run a few tests on small tasks to understand how much impact they can have on your wallet.

DeepSeek made its 75% discount permanent

The price war has officially begun, and DeepSeek is setting the pace. What used to be a promotion becomes DeepSeek V4’s base price: cut to a quarter of the price initially announced.

Reasonix

Reasonix is a DeepSeek-native coding agent for the terminal. The interesting part is that it has been optimized to leverage DeepSeek’s caching mechanisms, going essentially append-only: something you can afford with a million tokens, and which drastically reduces costs. But in general it is interesting that we are starting to see harnesses designed and built to make the most of open weight models’ capabilities. Something that Anthropic, OpenAI and Google are certainly already doing with their harnesses, optimized for their own models.

This was a week of heavy hitters on the agent front, with parallel announcements from Google, OpenAI, and Anthropic that, taken together, tell a story bigger than the individual products. In the deep dive I try to line them up and read them as pieces of a single infrastructure, what the community has started calling the internet of agents: Spark and UCP from Google, Codex for almost everything and OpenClaw from OpenAI, Managed Agents running 24 hours in the cloud from Anthropic. And on the open-source side, the data point that struck me the most: Hermes Agent became the tool that consumed the most tokens on OpenRouter in the past week, ahead of everything else. In the links section you’ll find the side stories that round out the picture: the huge Anthropic-SpaceX deal worth nearly $45 billion in compute, which ties into Anthropic’s mind-blowing revenue growth, OpenAI’s march toward a September IPO after the dismissal of Musk’s lawsuit, a closer look at Gemini 3.5 Flash, Andrej Karpathy’s move to Anthropic, and Anthropic’s own reflection on why HTML beats Markdown as a context ingestion format for coding agents. Enjoy.

My agenda

Podcast:

• On Saturday a new episode of Risorse Artificiali dropped, focused on Google I/O 2026: Gemini 3.5 Flash omnimodal at 1500 tokens/sec, Antigravity swallowing the Gemini CLI, and a long story on Demis Hassabis (move 37, AlphaFold, virtual cell). Episode

• By now you know about our GitHub repository with tools and configurations to do AI coding from the terminal on Linux. It now has its own site with a single-script install at Lince.sh

• We released AntiVocale (Google Play, GitHub), a piece of software that turns voice messages into text

On my own:

• Tuesday evening I’ll be in Milan for the AI Socratic Milano event. If there’s a chance I’ll also present the current state of Lince

• The video of the talk I gave with Alessio at VoxxedDay Zurich is now online

• On May 30 I’ll have the honor of being one of the PyCon Italia speakers

• On June 12 I’ll be in Catania as a speaker at Coderful

• On June 24 I’ll be in Milan as a speaker at AIConf

Spark, Codex, Managed Agents (and Hermes #1): the week that laid the rails of the internet of agents

I’ve been saying this for weeks, and week after week I feel like I’m watching a puzzle come together: the era of agents has arrived, and it’s no longer a question of a single product announced here or there, but of an infrastructure that the big players are building in parallel. More and more, you can glimpse what various observers are starting to call the internet of agents. This week was especially dense, because Google, OpenAI, and Anthropic moved important pieces at the same time, and on the side, the open-source community landed a punch that really struck me.

Let’s start with Google, which announced Spark, a 24/7 personal agent built on Gemini 3.5 Flash and Antigravity, designed to run in the background on your workspace and take initiative on email, calendar, organization. No longer a chat you open when you need something, but an assistant that lives with you. But the piece that intrigued me even more is the update to the Universal Commerce Protocol, UCP, the open standard Google is working on with the rest of the industry to let agents talk directly to merchants. Multi-item carts, real-time catalog access, identity linking to keep loyalty benefits. If Spark is the diner, UCP is the rail it travels on.

OpenAI responds on two fronts. The first is Codex for almost everything, which takes Codex well beyond coding and turns it into a generalist agent capable of handling heterogeneous tasks. The second is the continued investment in OpenClaw, which remains their reference open-source piece and keeps a frantic release pace. The community, however, is increasingly debating the project’s governance, and it’s a legitimate debate: just look at the number of stars on GitHub to see we’re dealing with a phenomenon, not a niche experiment. When an open-source project becomes this central, the question of who decides the roadmap weighs heavily, and weighs a lot.

Anthropic, for its part, doubled down on its enterprise bet with Managed Agents: managed agents, in the cloud, active 24 hours a day. It’s the hosted version of the concept many of us are testing locally (me with Hermes Agent at home, which I talked about a few weeks ago), designed for companies that want a fleet of agents working in the background without dealing with infrastructure. Dream mode finds its natural environment here.

And then there’s the data point that struck me the most: Hermes Agent became the tool that consumed the most tokens overall on OpenRouter in the past week. Number one, ahead of everything. It’s a powerful signal: developers aren’t just watching agents, they’re putting them into production, and when they have a choice they don’t automatically gravitate toward the biggest brand.

Putting the pieces together, the pattern becomes clear: agents are leaving the chat and installing themselves into operating systems (Android last week, desktop workspaces now with Spark), talking to merchants (UCP), running 24 hours in the cloud (Managed Agents, Spark), and reaching all the way to the developer’s terminal (Codex, OpenClaw, Hermes). The internet of agents is no longer a marketing metaphor: it’s an infrastructure being laid down right before our eyes, brick by brick. And as with any infrastructure, where you position yourselves while it’s being built matters.

Links that struck me this week

Anthropic to Pay SpaceX Nearly $45 Billion for Computing Deal

Anthropic signs a deal worth nearly $45 billion with SpaceX to get 300+ megawatts of compute from the Colossus 1 datacenter in Memphis over three years.

Anthropic keeps amazing, and this is the confirmation that compute is the raw material of the whole game. $1.25 billion a month, with a 90-day exit clause, tells two things at once: the level of demand Anthropic expects to serve, and the will not to depend on a single supplier. Diversifying beyond AWS also speaks to the market: today the constraint is capacity, not contracts.

OpenAI Reportedly Moves Toward IPO

OpenAI is preparing its IPO for September 2026, with Goldman Sachs and Morgan Stanley as lead underwriters after the dismissal of Musk’s lawsuit.

The legal obstacle has been removed and OpenAI can finally aim for the public market. It’s a huge step, because it closes the chapter opened by the controversial 2025 restructuring and marks the definitive farewell to the non-profit myth. From here on, product and model decisions will also be measured against an impatient financial market, and more things will change than it might seem.

Mind-Blowing Growth Is About to Propel Anthropic Into Its First Profitable Quarter

Anthropic is heading toward $10.9 billion in Q2 revenue, double the previous quarter; growing faster than Google and Facebook before their respective IPOs.

Put this number together with the SpaceX deal above and you see the full picture: revenue exploding and a spending machine swelling in proportion. Growing faster than Google and Facebook pre-IPO is a remarkable stat, but full-year profitability is anything but a given, precisely because of the hunger for compute. Risky bet, but if the trajectory holds, the payoff is of a different order.

Gemini 3.5 Flash

Google launches Gemini 3.5 Flash with 76.2% on Terminal-Bench 2.1, output 4x faster than competitors, and new multimodal and agentic capabilities.

I already covered it in the deep dive as the engine behind Spark, but the model on its own deserves a note. 76.2% on Terminal-Bench 2.1 puts it close to the frontier on agentic coding, and the 4x speed changes the economics of inference for long-running workflows. Google is seriously repositioning, and this is the piece that proves it.

Karpathy Joins Anthropic

Andrej Karpathy announces his move to Anthropic to focus on LLM frontier R&D, putting his teaching activity on pause.

You know that when Karpathy talks, I listen. This time he isn’t talking, he’s acting. Going full-time back into a major lab after years as an independent is a strong signal about the next two or three years: the big leaps, he’s essentially saying, will happen inside there. The choice of Anthropic, and not OpenAI or Google where he had been, says just as much.

Using Claude Code: The Unreasonable Effectiveness of HTML

Anthropic explains why HTML, not Markdown, is the most effective context ingestion format for Claude Code in specs, prototypes, and custom interfaces.

A discussion that ran through the podcast and the community in recent weeks, and that strikes me as crucial for anyone building real agentic workflows. The structural richness of HTML, with layouts, tables, interactive elements, gives the model an information density that Markdown cannot express. You really get it when you try to feed a long spec to an agent.

Important week for voice interaction, with two releases just a few days apart that I decided to cover together in the deep dive: OpenAI’s GPT Real Time models, released on May 7, and Thinking Machines’ Interaction Models, the Mira Murati startup that landed with fanfare on May 11. I walk through what really changes compared to the voice mode we are used to, because a year ago we had identified simultaneous translation as one of the jobs at risk, and today that risk has become very concrete. In the links section you’ll find side themes: agentic Gemini installed in the Android operating system, two papers on small, modular models (Recursive LMs and Allen AI’s EMO), Google’s SkillOS framework for agents that learn from experience, and Garry Tan’s thesis on personal AI as an operating system. Happy reading.

My agenda

Podcast:

• Episode 52 of Risorse Artificiali is out, marking exactly one year of podcasting without skipping a week. In this episode we try to take stock of what changed in AI over the past year while we tried to tell its story to our Italian friends.

• On Wednesday a new interview went live: Domenico Gagliardi (Founder and COO of Kortix) explains why with AI no software is defensible anymore, and where value still sits (infra + data).

• As you know, our GitHub repository with tools and configurations for AI coding from a Linux terminal now has its own site with single-script install: Lince.sh

• We released AntiVocale (Google Play, GitHub), a tool that turns voice messages into text

Solo:

• Tuesday evening I’ll be in Milan for the AI Socratic Milano event. If there’s a chance, I’ll also share an update on the current state of Lince

• The video of the talk I gave with Alessio at VoxxedDay Zurich is now online

• On May 30 I’ll have the honor of being one of the PyCon Italia speakers

• On June 12 I’ll be in Catania as a speaker at Coderful

• On June 24 I’ll be in Milan as a speaker at AIConf

Real-time voice: Thinking Machines, OpenAI and the end of turn-by-turn

Over the span of a few days, two releases meaningfully raised the bar for voice interaction with models. The first, on May 7, came from OpenAI with the GPT Real Time models: three new API models, GPT-Realtime-2 with GPT-5-class reasoning and an extended 128K-token context, GPT-Realtime-Translate for live translation from over 70 input languages into 13, and GPT-Realtime-Whisper for streaming transcription. Four days later, and with much fanfare, came the response from Thinking Machines, Mira Murati’s startup, which introduced the Interaction Models in research preview: not yet easily accessible in Europe, but the videos I’ve seen are frankly impressive. If I had to describe them in one phrase, they are ChatGPT voice mode on steroids. These are models that respond to voice in a truly interactive way, built from scratch with a multi-stream design for real-time responsiveness, designed to remove the classic turn-by-turn ping-pong limit by construction. OpenAI’s timing probably took some momentum away from the Thinking Machines launch, because part of what was demoed was already covered by their new API.

There’s one detail, though, that struck me in Thinking Machines’ favor: their model is relatively small, around 273 million parameters as I recall. Reminder that, by rumor since they never published the numbers, both Claude Opus and GPT 5.5 are believed to sit around 2 trillion parameters in a Mixture of Experts configuration. An order of magnitude less, in practice. And the results are still impressive: there are videos of people speaking in an extremely natural way, as if they were talking to another person. The model interrupts the speaker, waits, picks up the thread. Anyone who has tried ChatGPT voice knows that, to date, it was already the best experience around, far better than Claude’s, but you still get the sense that the model is waiting for you to pause before figuring out you’ve finished your sentence and replying. That makes sense, because internally it works like that: it takes the context, slices it into sub-sections and starts preparing the reply turn by turn.

Thinking Machines’ model, and most likely the new GPT Real Time too, works differently. They are called real time precisely because they manage to maintain a per-second understanding of the context up to that moment, continuously re-elaborating it. The paper isn’t out yet, I’m curious to read it, but rumors suggest they may be using recursive language models internally, something Google has already explored in other contexts. And this enables a striking degree of naturalness, including simultaneous translation.

I watched a GPT Real Time clip last night and the effect is exactly this: a person speaks in French, the English translation starts a couple of seconds later and proceeds in parallel, just like when you listen to a professional simultaneous interpreter. It works like this: the model waits to recognize that the main verb of the sentence has been delivered, because that’s what determines the semantic direction of the discourse, and at that point it starts translating. Thinking Machines shows equivalent videos, and for developers the OpenAI cookbook already provides three ready-to-use architectures (browser, Twilio, LiveKit) for broadcast translation, customer service and multilingual meetings.

By the way, a year ago, on these very pages, we said simultaneous translation was one of the jobs at risk. Well, concrete risk, here we are. If automatic translation used to feel like a walkie-talkie, that’s no longer the case. And it holds even with multiple languages interleaved, because once you have the system, one language is as good as another.

The links that stood out this week

Gemini lands on Android in its agentic form

Google brings Gemini to Android with multi-step actions across apps, autonomous browsing, form-filling, Rambler dictation on Gboard, and widgets generated in natural language (vibe-coding). Debut on Samsung Galaxy and Pixel this summer.

What interests me here isn’t the vibe-coded widget, which is more showcase than substance, but the fact that Google is pushing agentic capabilities directly into the mobile operating system, with real access to apps and the web. It’s yet another confirmation of the trend that has agents stepping out of the chat and moving into our devices. The open question is how well security will be handled in such open scenarios, because that’s where the whole game is played.

Reinforcing Recursive Language Models

Article on how to use reinforcement learning to fine-tune 4B-scale models as Recursive Language Models for production, matching Claude Sonnet 4.6 at much lower cost and size.

A theme close to my heart for a while now: small models, trained well for specific tasks and recursively collaborative, can match the big ones. The data point in line with Sonnet 4.6 is notable, especially if it holds outside synthetic tests. I referenced this same work in the deep dive as a plausible architecture behind Thinking Machines’ Interaction Models, because I believe the trend of small recursive models is one of the most interesting threads to follow.

SkillOS: skill curation for agents that learn from experience

Google paper on an RL framework that separates a frozen agent executor from a trainable skill curator, which manages a repository of reusable skills evolved from accumulated experience.

A parallel thread to the Dream feature in Anthropic’s Managed Agents we talked about a few weeks ago: agents that improve themselves by reflecting on their own sessions. Here Google formalizes the idea with a dedicated curator and shows that the resulting skills generalize across different models and domains. For anyone building long-running agentic systems, this is the right direction to keep an eye on.

EMO: emergent modularity in Mixture of Experts

Allen AI releases EMO, a 128-expert MoE where modularity emerges naturally during pretraining by using document boundaries as weak supervision. Near full-model performance with just 12.5% of the experts active.

The number that makes my ears prick up is that 12.5%. If it really holds on real tasks and not only on benchmarks, it means you can deploy specialized subsets of a model and drastically reduce memory and compute. For local inference, which we talk about often, this would be a game changer. The thread is worth following, especially on the open-weight side.

Garry Tan: personal AI as an operating system

Garry Tan (YC) introduces GBrain, an MIT-licensed open-source system that turns markdown notes into a self-organizing knowledge graph, the foundation for personal agents with autonomous cron jobs.

What I like about Tan’s thesis is the framing: personal AI isn’t a chat, it’s an operating system with a thin harness, fat skills, fat code and a fat data layer. It is exactly the mental model I’m running with Hermes Agent at home. The fact that GBrain is MIT, open source and based on markdown is a clear manifesto: stay above the API line, not below it. Worth a deeper look.

A week dedicated to agents, from various angles. In the deep dive I tell you about my experience with Hermes Agent, which for a few weeks now has been acting as my personal assistant on a dedicated machine at home: how I configured it, how I worked on security, and two concrete episodes in which it took initiatives that genuinely impressed me and that show what it means to have an agent with real access to your own data. In the links section you’ll find echoes of the same theme from different perspectives: antirez’s repository for local inference of DeepSeek V4, Anthropic’s new research on model explainability, the Dream mode of Claude Managed Agents that brings a form of self-improving in the cloud, the rumors about Orbit (Anthropic’s upcoming proactive assistant), Subquadratic’s claim about a 12-million-token context window (to be taken with a pinch of salt) and nine principles for writing skills that are actually useful. Enjoy the read.

My agenda

Podcast:

• Episode 51 of Risorse Artificiali is out, with the story of Hermes Agent running locally and deciding on its own to render an HTML into pictures.

• The thesis running through the episode: AGI is no longer just the model, but the integrated system (model + optimized inference + harness). Episode

• On Wednesday a new interview comes out: Domenico Gagliardi (Founder and COO Kortix) explains why no software is defensible anymore in the AI era, and where value still lies (infra + data).

• By now you all know our GitHub repository with tools and configurations for AI coding from the terminal on Linux. It now has its own site with single-script install at Lince.sh

• We released AntiVocale (Google Play, GitHub), a software to translate voice messages into text

Solo:

• On Tuesday evening I’ll be in Milan listening to Alessio talk about Local AI at the AI Meetup #14

• The video of the talk I gave with Alessio at VoxxedDay Zurich has been published

• On May 30th I’ll have the honor of being one of the PyCon Italia speakers

• On June 12th I’ll be in Catania as a speaker at Coderful

• On June 24th I’ll be in Milan as a speaker at AIConf

A month with Hermes Agent: setup, security and autonomous initiatives

For a few weeks now I have been running Hermes Agent on a dedicated machine at home, and I want to share with you my experience with an agent that constantly acts as my assistant. Those who have been reading me for a while know that in the past I had tried OpenClaw on a virtual machine, but I had left it because it was still immature and because at the time I had little time to spend on it to figure out how to make the most of it. Hermes Agent is essentially an alternative to OpenClaw: completely open source, not tied to any big tech, and with great attention to security, since the developers of the system come from the blockchain world.

For the setup I took an old PC I had at home and installed a completely fresh Ubuntu on it, dedicated only to Hermes, so that it would have no direct contact with my main machine, even though it sits on my network and has access to some of my cloud resources. I had thought about putting it on a Raspberry, but since I had this free machine available I preferred to give it a bit more resources. As a model I tried both GLM-5.1 and GLM-5-Turbo, and right now I’m stable on 5-Turbo with the coding plan, while TTS and STT run locally on the same machine, so that voice never leaves the house.

I gave it access to my personal accounts (not the enterprise ones) both on Google Workspace and on my GitHub projects, but with great care: you know that the sandboxing topic matters a lot to me. Fine-grained tokens to let it see only what I want it to see, and above all a manual hardening of the Hermes skills to remove at the script level all the operations I considered dangerous, like deleting or sending emails autonomously. I didn’t simply instruct it not to do those things: I actually removed them from the available scripts, because an agent cannot do what it doesn’t know how to do.

That said, the agent does a lot of things for me: it manages the smart devices in the house, monitors the podcast performance, checks the mail and prepares reply drafts (after the hardening above), keeps calendar and todo list with integrated reminders, manages my llm-wiki at night, does PR reviews on LINCE, summarizes articles and papers building schemas and tables and reading them aloud, and has started curating my information feeds. While I was waiting for my son at basketball practice, I asked it to rebuild my personal site, and the result is what you can find now at maeste.it.

The most fascinating thing about these agents is that, when they have a decent amount of information about your conversations or about the data you’ve given them access to, they start to take interesting initiatives. On the site, it not only proposed a style very much in line with my taste, but it went and retrieved information I had not explicitly given it. On the previous site, for example, the list of conferences I had spoken at was missing many. It had access to this newsletter, it extracted the mentions of past conferences and went on to reconstruct the complete list, including citations to slides and related videos. It really impressed me.

Another episode. While I was outside walking, I asked it to dig into an article for me and summarize it. What it decided to do on its own was a summary in Italian (because it judged that with low attention my native language was more convenient, even though we usually talk in English), and it sent it to me as a voice message on Telegram, generated by the local TTS. But for some more visual concepts it judged that voice alone wasn’t enough, and it built an HTML on the fly to represent them at their best. At that point it realized on its own that an HTML would be inconvenient to consult inside Telegram, especially on a smartphone, and so it took screenshots adapted to the format of a phone screen, sending me those instead of the whole document. Really impressive.

If you are software engineers with a sensibility for security, it’s a tool you can install with a bit of care and have fun with. If instead you don’t feel strong on that front, Hermes Agent is probably still too much in geeky territory. But if you are a geek, then it’s your territory.

Links that caught my attention this week

ds4.c

Here comes Salvatore Sanfilippo’s repository for DeepSeek 4 inference on Apple machines. I had already talked about it in past weeks, mentioning that Salvatore was working on this, and he has finally started publishing the code. The thing itself is interesting, the code itself is interesting, just like the increasingly strong trend of local inference.

Natural Language Autoencoders

Interesting research from Anthropic, which as always is attentive to explainability and in this case tries to give a natural-language explanation of the internal activations of a model.

Claude Managed Agents: Dreaming, Outcomes and Multiagent Orchestration

At Anthropic’s latest conference one of the interesting announcements was Dream mode, which lets cloud agents have a form of self-improving by reflecting on how they have been used and which skills should be modified or prioritized.

Anthropic is working on Orbit

This is little more than a rumor, but it’s said that Anthropic is working on this Orbit, a cloud mode that resembles agents like OpenClaw and Hermes Agent. Above you’ll find my concrete experience with a personal agent of this kind. It seems Anthropic too is interested in this market.

Subquadratic: a 12-million-token context window

This is exactly the article I had Hermes Agent summarize for me in an early phase, the one I was telling you about above. The article itself is interesting and talks about an evolved multi-level attention mode that allows the context window to grow up to 12 million tokens. Experience however teaches us that these things should be taken with a pinch of salt, because in the past too there was talk of research reaching 100 million tokens that didn’t go anywhere. What raises the most suspicion in the article and in the paper is that single tests or little more were run for each inference head: really too few to shout miracle.

9 Principles That Separate Useful Agent Skills From the Rest

A very interesting article that summarizes well what skills really are and when they are truly useful and interesting. If you’re writing systems that rely on skills as a standard, agentskills.io or simply Claude’s skills which are essentially the same thing, this is an absolutely must-read article.

This week in the deep dive I tell you about my experience with the Cyberwave hackathon I did together with Paolo, the other co-host of Risorse Artificiali. It was very interesting to play with a robot and with the Cyberwave platform to have our first real Physical AI experience, and it was a very formative experience even if not as straightforward as we expected, but you’ll find all the details in the deep dive. In the links section, on the other hand, I’m flagging some interesting things that happened this week, from DeepSeek V4 to GLM-5V-Turbo, passing through other news and unexpected points of view. But I’ll leave the reading to you.

My agenda

Podcast with Alessio and Paolo:

• On Saturday episode 50 of Risorse Artificiali came out. Three Chinese open weight models, DeepSeek V4 cutting 78% of compute on the KV cache, and my deep-dive on Hermes Agent (it runs on its own with GLM-5.1 and manages my email and calendar, which I’ll describe in detail next week here in the newsletter). Listen

• On Wednesday the new interview with Stefano Gatti came out, his second time with us after being the first guest of the series. Strong thesis at the end: AI today is not an equalizer, it amplifies those in the top 10%. Listen here

• By now you know about our GitHub repository with tools and configurations for AI coding from the terminal on Linux. It now has its own site with single-script installation at Lince.sh

• We released AntiVocale (Google Play, GitHub), a software to translate voice messages into text

On my own:

• The video of the talk Alessio and I gave at VoxxedDay Zurich has been published

• On May 30 I’ll have the honor of being one of the PyCon Italia speakers

• On June 12 I’ll be in Catania as a speaker at Coderful

• On June 24 I’ll be in Milan as a speaker at AIConf

Cyberwave Hackathon: Robotics Through the Eyes of Two Software Engineers

In recent weeks, Paolo (one of my two co-hosts on the Risorse Artificiali podcast) and I had the opportunity to take part in the Cyberwave cohort dedicated to robotics experiments. Cyberwave is an interesting Italian startup focused on robotics, it has just closed a seed round and is looking for feedback from developers: that’s why they created a four-week hackathon open to a group of experimenters. Could we miss it? Of course not, especially because one of the founders, Simone di Somma, had already been a guest on Risorse Artificiali, and the whole thing had piqued our curiosity quite a bit.

The Cyberwave platform is cloud-based and lets you work with physical robots by creating a virtual twin inside their 3D simulation environment, with the goal of simplifying the development experience in the world of robotics. Given our experience in software engineering we started off pretty relaxed, I’d dare say even a bit overconfident, sure we could cover a fairly advanced use case. But robotics, we discovered, is something completely different from software engineering, and far more so than we expected. To begin with, robots need to be calibrated as soon as they arrive: when you open the box and start programming them, you’ll be surprised to find that they don’t necessarily go straight, so a calibration job is required, along with a study of the hardware details of the system you have in your hands. Debugging, then, is physical, complicated, and at times risky for the rover itself.

That said, as the tinkerers we are, we didn’t get discouraged. We started exploring both the robot, a Waveshare UGV Beast, and the platform, discovering the innovative things it offered us and the inevitable bugs of such a young product. Two software geeks who have to go bug hunting, discuss them on Discord with the founders and contribute back with PRs: two kids in a candy store. In the end, instead of a complex use case, we put together a sort of quickstart for working with Cyberwave and the UGV rover: a series of Jupyter Notebooks that let even newbies like us understand all the possibilities a robot and the platform offer for development.

Working on it we realized that some considerations resembled those of traditional software architecture quite a bit: what to put in the cloud and what at the edge looks a lot like the backend/frontend split, and the fallbacks for communication errors must be designed so the robot keeps working even if the network drops. Other things, instead, are new. Basic AI (image, person, and obstacle recognition) is now a commodity, but to make a robot truly autonomous there’s still a lot to do: recognizing an obstacle is one thing, recognizing edges and shadows (as another hackathon competitor did) is something else entirely. And every robot is different: the form factor shapes the design and makes it hard to build truly portable high-level libraries.

We then won the hackathon, and it makes me happy because it rewards exactly the spirit of building something useful for other developers. But the important thing is something else: we had a lot of fun and we got the strong confirmation that the next big thing is robotics. My aha moment came when I implemented a CLI for the rover and fed it to Claude Code: being able to talk to the robot in natural language, telling it what to do and where to look and watching it execute, is a real game changer. It’s a window onto the future, the one in which even non-experts will have well-tested tools and platforms like Cyberwave for a smoother experience than what is possible today. One critical point remains, and it should not be underestimated: the alignment of AI models, both generative and recognition, is essential when you send a physical object out to take initiatives. Everything is still early stage, but the direction is clear, and if you’re young and you have to decide where to invest your time, maybe that’s where you should look.

Links that caught my attention this week

Speculative Decoding

I’ll start by quoting the other Risorse Artificiali co-host, Alessio, who wrote a great article on speculative decoding, a technique to get better results in the decoding phase of transformers, very very useful when you do local inference.

DeepSeek V4 and Local Inference

• DeepSeek Unveils Flagship AI Model a Year After Breakthrough

• antirez on DeepSeek v4, KV cache and SSD

DeepSeek announced version 4 of its Large Language Model in preview. What does preview version mean? It means Reinforcement Learning isn’t fully complete, so some benchmarks aren’t as brilliant as one might have expected from the new DeepSeek version, but they will likely improve a lot for the final. I’m also citing some great work by Salvatore Sanfilippo (antirez), who, on top of this model, started spending time optimizing local inference. He does a lot of things with DeepSeek version 4, including a hybrid 2-bit and 8-bit quantization, but the thing that struck me the most is the latest one, which I link to in the post: the ability to use the KV cache on an SSD disk instead of in memory. As I commented on X, this could be a real game changer for local inference and beyond. Being able to use long-term storage like an SSD instead of RAM could significantly lower inference costs, or open a whole new path for local solutions.

Sunsetting Roo Code Extension, Cloud and Router

Roo Code, one of the first agents integrated into VS Code, is shutting down. But that’s not really the news: it happens with open source projects that at some point they get discontinued. What struck me is the founder’s statement, who said that the time of IDEs is over. I’ll leave the reflection to you, I already have mine, which I think my readers know well, since for a long time I haven’t used an IDE anymore but a CLI with multiple agents in LINCE.

Karpathy and Hassabis: Two Interviews Not to Miss

• Andrej Karpathy: From Vibe Coding to Agentic Engineering

• Demis Hassabis: Agents, AGI & The Next Big Scientific Breakthrough

My readers know very well that when Karpathy or Demis Hassabis speak, I listen. And this week they both did, in two very interesting interviews. I’ll leave the listening and the judgments to you.

Google to Sell Its TPUs

Interesting business news from Google, which is starting to sell TPUs. The Mountain View company, after becoming OpenAI’s main competitor on the consumer side, seems to want to enter the hardware market as well, becoming a direct competitor to Nvidia.

GLM-5V-Turbo

Those who have been reading me for a while or listening to me on Risorse Artificiali know that I’m a GLM user as an alternative to Claude, and that I’ve had their Max subscription for some time, also because it’s very convenient. It also has to be said that GLM has made huge progress, getting very close to state of the art models. With the 5 series of their models, this new 5V-Turbo version comes out, with truly very interesting benchmarks. At the moment it’s only available as an API or for a subset of testers in the coding subscription. Obviously I’m already on the list.

A tough week for Anthropic, which had to admit to three major issues that sparked varied reactions in the community. Meanwhile, OpenAI gains ground on them with Codex and GPT-5.5, and on Google with ChatGPT Images 2.0, which competes closely with or perhaps surpasses NanoBanana. The Chinese are no less, with the arrival of DeepSeek version 4 and Qwen 3.6, all open source. And I wonder if it isn’t time to focus on open source tools instead, but read all about it in my deep dive.

My agenda

Podcast with Alessio and Paolo:

• In the latest episode we talk extensively about what I discuss in this week’s deep dive and show image examples

• A great interview with Luigi Congedo is out, bringing his experience from American VCs and telling us about his courageous choices in Italy. Don’t miss it.

• We’re trying to improve the audio/video format and podcast presentation... any feedback is welcome

• Next Wednesday Stefano Gatti returns for an interview. He’ll share his current reading of hybrid intelligence that he anticipated in October, and this week of reckoning is a good context to revisit his perspective.

• By now you know about our GitHub repository with tools and configurations for AI coding from the terminal on Linux. It now has its own site with single-script installation at Lince.sh

• We released AntiVocale (Google Play, GitHub), a software to translate voice messages into text

On my own:

• The video of the talk Alessio and I gave at VoxxedDay Zurich has been published

• On May 30 I’ll have the honor of being one of the PyCon Italia speakers

• On June 12 I’ll be in Catania as a speaker at Coderful

• More talks at other conferences coming up...

Bugs, Models, and the Open Source Temptation

This week’s news was dominated by two things for sure. The arrival of GPT-5.5 and ChatGPT Images 2.0, which marked a major step forward for OpenAI in both agentic AI and coding as well as image generation. The results are truly remarkable for OpenAI, because they’ve closed the gaps that until recently were quite evident with Anthropic on the agentic side and with Google on image creation. GPT-5.5 achieves state-of-the-art results on Terminal-Bench 2.0 (82.7%) and SWE-Bench Pro (58.6%), and for the first time an OpenAI model seems truly capable of competing with Claude Code in agentic coding.

But in parallel, the Anthropic case exploded. They admitted to having three significant bugs in Claude Code that affected the performance and quality of their flagship model Opus. The postmortem is detailed: on March 4 the default reasoning effort was changed from high to medium without announcement, on March 26 a cache management bug wiped the thinking context at every turn, and on April 16 a system prompt to reduce verbosity compromised the quality of generated code. All three issues were fixed by April 20, and Anthropic is resetting usage limits for all subscribers as a goodwill gesture. This confirmed a feeling already present in the community, which sparked various reactions, some perhaps excessive, calling the situation unacceptable and gravely serious. I honestly think that bugs in the software world can happen, and this won’t be the first or the last. On the other hand, I understand the position of those who complained that instead of having so many releases and new features, perhaps Anthropic should focus on the stability of their system, because it’s becoming increasingly central for a large mass of developers.

But if we look back at OpenAI’s house, maintaining an exaggerated release velocity seems to be a necessity, because otherwise it takes a moment to fall behind or get overtaken by another company. The good news, if we want to see it that way, is that some developers who decided to switch to other tools, Codex in particular, to try GPT-5.5, have certified how the use of standards, and in particular skills, allows an easy transition to different tools.

In this sense I’m glad I anticipated the use of multiple coding agents in LINCE.sh, because as we can see in this case too, tying yourself inseparably to one coding agent and one vendor might not be a good idea. And extending this concept a bit, I think the time has come for me to start looking at some open source agents. If state of the art models aren’t feasible locally or open source, or at least not yet, what we can do as AI engineers is to at least use tools that are completely under our control, and why not, maybe contribute to their improvement. By the way, it’s been a rich week for open models: DeepSeek V4 with 1.6T parameters and 1M token context in open source, and Qwen 3.6-27B, a dense 27B parameter model that beats its 397B MoE predecessor on all major coding benchmarks, show that the distance between proprietary and open source models is narrowing at least on architectures.

There’s an embarrassment of choice out there among open source tools, including for example Goose or OpenCode, but I think this week I’ll try to focus on PI and Hermes Agent. Two very different tools, one for coding and the other for generic agents, but both with very interesting features. The first is truly minimal and grows through extensions, and has been used very effectively to implement Karpathy’s autoresearch. The second is interesting because, doing very similar or identical things to OpenClaw, it has a truly remarkable attention to security and isolation of code generated and executed by the agent.

Links that caught my attention this week

Anthropic’s Update on Claude Code Quality

Official postmortem on three separate bugs that degraded Claude Code quality between March and April 2026.

A postmortem worth reading. It’s definitely interesting to see how Anthropic lays out the three errors, but it’s also very interesting to read how difficult it was to investigate the cause of these errors. The complexity is truly high in these systems, and not only because of the models.

OpenAI’s Big Leap Forward

• OpenAI Introduces GPT-5.5

• OpenAI Introduces ChatGPT Images 2.0

• Sign of the Future: GPT-5.5 (Ethan Mollick)

GPT-5.5 brings state-of-the-art results on Terminal-Bench 2.0 and SWE-Bench Pro, ChatGPT Images 2.0 generates images with high-quality text, and Mollick tests the new capabilities in depth.

I mentioned in the deep dive how significant the advances at OpenAI have been. Here you’ll find the announcements of the new GPT-5.5 model and the connected tool Codex, which are doing truly important things, both from what I’ve read and from my own direct testing. And there’s also the announcement about images generated by ChatGPT Images 2.0. If you’re curious, go check out my podcast thumbnails, which are generated or retouched by ChatGPT Images. Don’t miss professor Ethan Mollick’s detailed analysis: absolutely a must-read article, and it’s also fun to check out his simulations to get a sense of how models have evolved in recent months.

The Chinese Are Not Standing Still

• DeepSeek V4 Preview Release

• Qwen 3.6-27B

DeepSeek V4 in open source with 1.6T parameters and 1M token context, and Qwen 3.6-27B, a dense 27B model beating its 397B predecessor on all coding benchmarks.

The Chinese are certainly not standing still, and the announcement of DeepSeek V4 in preview arrives. It’s an important announcement because DeepSeek, you may remember, about a year ago generated a real earthquake by demonstrating that open weight models could compete with American state of the art models. More or less the same thing is happening again, but what always makes DeepSeek releases interesting are the papers they release alongside them, which in the case of the previous version led to concrete advances not only for DeepSeek but for the entire community. This time’s paper seems very interesting too, though perhaps less disruptive, but I haven’t had the chance to dig into it enough for a detailed comment yet. Maybe I’ll come back to it. Meanwhile, Alibaba also releases Qwen 3.6-27B in fully open mode, and it’s a significant release because the benchmarks are truly remarkable and much better than even Gemma 4, which made so much headlines just a few weeks ago.

Google Introduces Gemini Enterprise Agent Platform

Enterprise platform to build, scale, and govern business agents, with low-code Agent Studio, Agent Development Kit, and over 200 models in the Model Garden.

You may remember that a couple of weeks ago Anthropic announced its version of an agent platform. Well, Google has already arrived with its own announcement too, and this identifies a fairly strong trend among big tech companies that are starting to provide proper platforms that greatly simplify the development of cloud-based agents. We may be seeing the emergence of a new trend that shifts agents, which today run locally on our machines, toward the cloud. I’m not sure, because part of the appeal of agents running on our machines is having access to our data, our systems. But certainly as we move into the enterprise world, we’ll see agent platforms like Google’s and Anthropic’s establishing themselves. I don’t know if we’re ready for the enterprise world yet.

Here we are, at the first newsletter of the second year of this adventure. I’m sticking with the format I started last week, so a deep-dive plus a handful of links that stood out to me. The feedback I’ve received so far is all a little nostalgic of the old format, which seems to have been very much appreciated, but I want to give you the chance to get used to this new one. That said, I listened to the private feedback you sent me and I tried to expand the links section a bit, identifying the main themes of the week within it. A bit like what I used to do in the previous newsletter, but much, much more compressed. I condensed, expressing above all my opinions. I kept the deep-dive anyway because I think it’s important, at this point, to contribute (or at least try to) to the discussion around AI with all the things I’m experimenting with, for work and for passion. This week’s deep-dive is the story of a small personal project built on a flight, a “second brain” inspired by Karpathy’s latest gist, which in New York made me understand why this idea can really change the way we work with LLMs.

My agenda

Podcast with Alessio and Paolo:

• A great interview with Luigi Congedo is out, where he shares his experience in American VCs and tells us about the bold choices he made back in Italy. Don’t miss it.

• While I was on a well-deserved vacation (which I’ll tell you about later) Alessio and Paolo had an exceptional guest, Andrea Cosentino, who takes us deep into the world of security and hacking. Bear with the imperfect audio for the first 5 minutes, it’s worth it (and then it clears up).

• We’re working on more interviews and episodes with very interesting guests.

• By now you know about our GitHub repository with tools and configurations for terminal-based AI coding on Linux. It now has its own site with single-script installation at Lince.sh

• We released AntiVocale (Google Play, GitHub), a piece of software to translate voice messages into text

Solo:

• The video of the talk I gave with Alessio at VoxxedDay Zurich has been published

• On May 30th I’ll have the honor of being one of the PyCon Italia speakers

• On June 12th I’ll be in Catania as a speaker at Coderful

From Karpathy’s gist to my own second brain: compounding, views, and open research

A few days ago, on a flight, with shaky WiFi and Claude Code open, I was reading Andrej Karpathy’s gist and the tweet where he talks about how he’s building personal second brains using LLMs. I recognized myself immediately in the organization he proposes: it was already pretty close to how I keep my notes when I’m working on a research topic I want to dig into over time. By the end of the flight I had my own working version, shaped around the way I think instead of someone else’s. This is the story I want to tell you, and above all, it’s the reflection that came out of it.

Karpathy’s idea, simplified, is this: a raw/ directory where you collect your sources (articles, papers, clips taken from the web), an agent that “compiles” them incrementally into a wiki of markdown files with summaries and cross-references, and Obsidian as the frontend to read everything. No RAG, no vector databases, no embeddings. The agent itself maintains indexes, concept pages, and connections between sources. Complex queries become actions of the agent against the wiki, and the outputs of those queries can in turn be fed back into the wiki, enriching it. Karpathy calls this effect compounding: every new thing you add stacks on top of what was there before, instead of getting lost in a chat you’ll close and forget.

The principle isn’t new. An organization based on sources and linked notes has existed for decades, just think of the Zettelkasten. What really changes, and it changes for real, is the ingest phase. When you ask the agent to ingest a new article against an already populated wiki, it proposes connections you hadn’t seen, because it “remembers” all the sources together in its context, something a human does poorly past the first twenty notes. It’s the difference between a well-ordered library and a librarian who has read all the books. The result is not a static archive like NotebookLM, which crystallizes whatever you’ve given it: it’s something that evolves with every addition, and where the connection is worth as much as the content. The more you use it, the more valuable the system becomes. And this changes the way you work: you stop asking the LLM “answer me about X” and you start asking it “update what you know about X with this new source, then answer me”. It’s a tiny difference in the prompt but an enormous one in practice, enough to make a system that yesterday looked like yet another notebook seem like a game changer.

I built my version by chatting with Claude Code for a few hours during the flight. What came out is a bundle with an init script, a CLAUDE.md that acts as a contract between me and the agent, three skills (a fetcher that pulls URLs from an inbox and converts them into clean markdown, a deterministic linter that keeps the wiki honest with checks on dead links, orphans and staleness, and a views builder), session hooks that maintain a “hot cache”, and a few slash commands to save important conversations and generate output. On top of the gist I added a periodic reflection that writes in prose about where I’m converging and where I’m systematically not looking, closing with an uncomfortable question à la Richard Hamming that often hurts. And the views: alternative representations of the same pages, like timelines, comparisons, diagrams, slides, reports, which by default evolve alongside my thinking and only when they need to serve someone else do they become frozen snapshots. The bundle lives in a public repo for anyone who wants to take a look.

The reason I was on that flight was a ten-day trip to New York, and that’s where I ended up actually using the system. I ingested guides, articles, recommendations from friends, fragments of old trips, and the agent started proposing juxtapositions I’d never have made on my own. The Bushwick Collective murals, in Brooklyn, read as the open-air continuation of what Basquiat and Haring had brought inside the halls of the MoMA and the Whitney forty years earlier: same gesture, different temperature, and a visit to Bushwick becomes a chapter of the same story rather than a disconnected side trip. The Sunday gospel service in Harlem linked to the jazz concert we were going to see that same evening in Greenwich Village: not two musical experiences in two different neighborhoods, but two branches of the same trunk, given that Thomas Dorsey, the father of modern gospel, was a jazz pianist first, and African American worship is the crucible from which jazz itself drew musicians and language. The Central Park Reservoir not as a mirror of water for joggers but as the terminal of the Croton Aqueduct of 1842, and therefore as the root of the same water problem that half a century later would give birth to wooden water towers on the rooftops: two answers to the same crisis, forty years apart, both still visible from the same bench. But the truly interesting part is what happened during the trip. Tastes kept changing, timing kept changing, an unexpected experience opened a new direction, and the wiki evolved with me: every question asked in the evening, every morning change of plans, came back into the system and altered the subsequent answers. The second brain wasn’t a frozen itinerary crafted before leaving, it was a travel companion learning alongside me. A deliberate and conscious use of a system like the one Karpathy proposes, applied to something concrete like a trip, is a real game changer. And I understood in practice why he sees in it a foundation for something bigger. I picked the New York example because it makes the enormous potential of this approach concrete, and it’s precisely because of that potential that I’m already using the same system for much more serious research, on agents and memory, where the ability to accumulate sources and make them talk to each other matters even more.

That said, I’m not sure there’s room for a packaged product built on this idea. Plenty of people have already published their version on GitHub in recent months, it takes two minutes to find a dozen. A strong idea, a capable agent and an afternoon of conversation produce a system tailored exactly as you want it, not as someone else’s product manager wants it. The same applies to other cases: last week I was writing about LINCE, my sandbox environment for agents, and quite a few of the things we put into it today are covered by products from big tech. I built it anyway, and I’d make the same choice again.

Then why put the code on GitHub, if not to compete with those products? Not to become famous, not to collect users or stars. To enrich the public discussion. Open source in its essence is shared research: you publish what you found so that someone else can build on it, criticize it, break your assumptions. An imperfect version of my second brain on GitHub doesn’t want to compete with anyone. It wants to contribute to a collective conversation, and whoever forks it won’t be a user to be converted into revenue but someone else thinking about the same problem. That’s something the packaged product can’t do. It can give you a finished solution, but it takes away the research part, the part where you also learn something by doing it. If you build your own version, let me know what you put in it that’s different from mine: that diversity is exactly the point.

The links that caught my eye this week

Lots of news from Claude

• Introducing Claude Opus 4.7

• Introducing Claude Design by Anthropic Labs

• Claude Managed Agents

• Schedule recurring tasks in Claude Code Desktop

There are plenty of memes about the pace of feature releases at Anthropic: from “I wake up and Claude has a new feature” we’ve moved to “I breathe and Claude has a new feature”, and that’s exactly what happened this week. Genuinely important features, because Opus 4.7 is a big step forward in agentic development, but Claude Managed Agents are also noteworthy: agents that can be developed locally as if they were a regular Claude Code agent, and then deployed on the cloud system. But the one that struck me most is definitely Claude Design, because it brings a new capability, that of developing graphical interfaces through text, which until now was the prerogative of specific tools like Lovable. At this point Claude isn’t just a Lovable supplier anymore, it’s a direct competitor.

Gemini doesn’t lose sight of the consumer front

• Gemini 3.1 Flash TTS

• Skills in Chrome

Google on its end is not standing still, and this week at least, focuses mostly on the consumer side, releasing two important things. The first is the Gemini 3.1 Flash text-to-speech, which lets you read almost any web page, and we’re already seeing the feature land inside Google’s own pages. We’re heading towards a web that becomes multimedia with little effort: we can start listening to the pages we care about instead of reading them, and that’s an interesting direction. On top of that, there are the Skills in Chrome, essentially saved prompts inside the AI version integrated in the browser, very useful to create a kind of mini AI applications living inside Chrome.

Autoresearch beyond model training

• Autogenesis, A Self-Evolving Agent Protocol (arXiv)

• Autoresearch isn’t just for training models (Shopify Engineering)

• davebcn87/pi-autoresearch (GitHub)

You’ve probably heard about Karpathy’s autoresearch. Here I’m linking an article and a repository coming from Shopify to show how powerful autoresearch can be even when used outside Karpathy’s base use case, which was model training. Also very interesting is the paper I cite: are we really heading towards agents capable of improving themselves? I don’t know, but at least we’re trying.

Qwen3.6

And then there’s Qwen, officially releasing the weights of its latest model. Qwen’s open source strategy continues, even though the free version of their subscription is gone. Fortunately for us, they don’t stop pushing on the open source side of models, releasing weights and training code.

Codex for (almost) everything

Anthropic did a lot, Google too, but OpenAI was certainly not to be outdone this week, because it released extensions for Codex that allow full use of your computer. I haven’t had the chance to try it thoroughly yet, but from what I see and read the results are incredible. And if you wonder what the point is of having an agent use the computer directly with mouse and keyboard when it can access APIs, remember why we’re chasing humanoid robots: exactly to use all those tools we’ve built for ourselves and our form factor. The same goes for an agent using the computer.

Dwarkesh interviews Jensen Huang

Dwarkesh interviewed Jensen Huang and didn’t go easy: he was very sharp with his questions, so much so that, for the first time I believe, I saw Jensen lose his proverbial calm when they talked about China and Chinese competition.

This is issue number 52. Exactly one year ago I started this adventure of writing every single week about what’s happening in the world of AI. I’ve been thinking for a while about whether it’s time to change the format of this newsletter, and I believe today is the right day. I could have waited a week and started with year number 2, but instead I want to close the first year with this change.

What’s different? The philosophy shifts a bit. Until now I’ve tried to inform you by collecting and curating a series of links that could highlight the trends of the moment in the AI world. I believe that in the phase we’ve just been through this was useful, because seeing where big tech was heading, what investments they were making, what new technologies and models they were launching was the most important thing so each of you could form your own opinion. But things have changed over time: news roundups like the ones I’ve been doing are increasingly common, even in Italian, and I believe they’re starting to have less added value. On top of that, the information overload we’re all subject to forces us to separate what’s important from what’s redundant, and I certainly don’t want to be redundant. I’d rather give you something more, trying to tell you about things with a strong point of view, as always, but in greater detail.

So starting this week, the newsletter consists of just two sections. A deep-dive where I tackle a specific topic, talk about a personal project or something worth exploring to understand a particular aspect or trend in the AI world right now. The second section is a collection of just a few links, only those that truly caught my attention during the week, with a personal comment that I hope will make you want to read the full articles I link to. This week’s deep-dive starts with a very personal project I built with the folks at Risorse Artificiali: it’s called LINCE and I invite you to read the deep-dive that follows, try it out and let me know.

My agenda

Podcast with Alessio and Paolo:

• A great interview with Gabriele Venturi, founder of PandasAI and a true nerd, is out :)

• We’re working on more interviews and episodes with very interesting guests.

• You already know about our GitHub repository with tools and configurations for AI coding from the terminal on Linux. It now has its own website with a single-script installation Lince.sh

• We released AntiVocale (Google Play, GitHub), a software to translate voice messages to text

On my own:

• The video of the talk I gave with Alessio at VoxxedDay Zurich has been published

• On May 30th I’ll have the honor of being one of the PyCon Italia speakers

• On June 12th I’ll be in Catania as a speaker at Coderful

Sandbox, multi-agent and vendor independence: why I built LINCE

This week I want to tell you about my sensitivity to the security of my development environment, especially since I started developing with agent-based systems. Something I said during a conference, the Voxxed Day Ticino, in a panel on AI security, was precisely that developers need to change their mindset, because the attack surface is no longer just the software they produce and put into production. The attack surface is themselves and their development environment.

Starting from this consideration, I believe it’s fundamental to start asking ourselves how we isolate our development environments, especially when working with agents. The most concrete answer comes from sandboxes. One of the traditional ways to use sandboxes is to rely on cloud solutions. There are quite a few on the market (E2B, Daytona, Fly.io Sprites, to name a few) and they are excellent solutions based on microVMs with hypervisor-level isolation. However, they have a fundamental flaw: you’re sending your code to the cloud and managing your agents inside a virtual machine that, however secure and guaranteed it may be, is not local. For those working on proprietary or sensitive code, this is not a negligible nuance. I asked myself whether it was time to think about local solutions.

It was precisely from this need that, together with the folks at Risorse Artificiali, I started the LINCE project. The project, which you can find on GitHub, was initially focused solely on sandboxing. Our implementation aimed to be extremely lightweight and focused on the Linux environment, so we turned to bubblewrap, a technology already present in Linux that uses kernel namespaces superbly. We’re certainly not the first to use it: bubblewrap is the technology behind Flatpak. What we did was put together an efficient CLI tool to create your sandboxes on the fly, with practically zero overhead, that lets you decide exactly which directories to expose and how. All entirely from the terminal, with no need to install IDEs, graphical interfaces or additional programs, and with minimal dependencies. The first goal was to be able to launch Claude Code and other agents completely skipping permission requests, since you’re inside a sandbox anyway. Additionally, the sandbox can take a snapshot of the current directory and configuration directories at launch time, allowing you to sync the last working version in case of disasters. In this sense, I feel comfortable launching agents without permission checks and letting them run in an almost YOLO mode.

But then there’s another problem, much discussed these days: multi-agent orchestration. Developers, increasingly to boost productivity, have started (and I was among the first) using multiple agents on the same project or developing projects in parallel. As Addy Osmani writes, the sweet spot seems to be between 3 and 5 agents in parallel, and the real bottleneck is no longer code generation but its verification. It’s an activity that leaves you exhausted by mid-morning, as someone says, but it also gives great satisfaction and unprecedented throughput. Part of the overload that comes from it is context switching, so I asked myself whether, alongside the sandbox, it was worth optimizing precisely that.

The idea was to develop a dashboard that would integrate with any agent from any vendor, allowing you to launch them in parallel and monitor when they needed input. The dashboard is a plugin written in Rust compiled to WASM (about 900KB), which adds an additional layer of isolation: the plugin runs inside Zellij‘s sandbox, the terminal window manager we built on, without direct access to the host system. Zellij is modern, well supported on Linux and macOS, and allowed us to keep the promise of a solution that lives entirely in the terminal, with no heavy dependencies.

The vendor independence aspect is not a technical detail: it’s a strategic choice. We saw this concretely on April 4th, when Anthropic blocked subscription access for all third-party tools with less than 24 hours notice, leaving those who depended exclusively on their ecosystem without immediate alternatives. LINCE supports Claude Code, Codex, Gemini, OpenCode, Aider and any custom agent via TOML configuration, precisely because tying yourself to a single vendor, however excellent, is a risk not worth taking.

For those using Linux who have always struggled with audio (and I know there are many of you), we also developed VoxCode, a module for voice interaction with agents using Whisper locally. Audio stays entirely on your machine, transcription is routed directly to the active agent in the dashboard, and everything works from the terminal without needing to configure PulseAudio, PipeWire or any other audio daemon to make it talk to external applications. It’s perfectly integrated with the dashboard and the sandbox system.

At the time of release, although development had started for Linux, we decided to support macOS as well. To do this we integrated nono as an alternative sandbox backend to bubblewrap. Nono is a very interesting project that leverages kernel-level security mechanisms (Landlock on Linux, Seatbelt on macOS) to create sandboxes with a deny-by-default approach across five layers of defense: kernel isolation, atomic rollback, cryptographic audit trail, supply chain provenance and runtime supervisor.

The result is a complete workstation for agent-based development that lives entirely in the terminal: sandbox, multi-agent orchestration, voice input, all installable with a single script from lince.sh. Please let us have your feedback.

Links that caught my attention this week

Hermes Agent

Hermes Agent is an open source alternative to OpenClaw. It caught my attention because there’s much more focus on security, but especially for its pluggable and extremely advanced memory system. It’s worth checking out even just to understand how they use the memory system. Overall Hermes performs very well from my testing and I believe it will be my next personal assistant. The research group behind it comes from the crypto world, which brings some concerns about the business model, but certainly not about technical expertise, especially on the security and cryptography front.

Cursor 3

Cursor isn’t standing still and releases version 3, even though with the arrival of all competitors and especially the Claude Code craze that exploded after December, it seemed a bit forgotten. The most interesting thing about Cursor 3 is its ability to orchestrate multiple agents that can run partly locally and partly in the cloud: the orchestration doesn’t care where agents are deployed, it just tries to get to the result.

Anthropic Ended Subscription-Based OpenClaw Usage

I mentioned this in the deep-dive. Anthropic changing the rules of their subscription from one day to the next is something that should make us raise our antennas. As much as I’m a fan of Anthropic and their technology, and not just the technology but also certain positions they’ve taken on ethical issues, this policy, together with the immediate reaction to remove all source code from the internet after it was leaked (which goes a bit against my open source philosophy), leaves me undoubtedly a bit perplexed.

Practical Lessons From the Claude Code Leak

It’s worth reading this article by Bilgin because in relatively few lines he manages to touch on all the key points of what we can learn from the Claude Code leak. There are truly many insights for using Claude Code better thanks to what was seen in the source code, and I essentially agree with everything that’s said in the article.

Qwen 3.6-Plus on OpenRouter

On OpenRouter you can find Qwen 3.6-Plus in the free tier, which means you can use it without paying a single dollar. The model is really very good and it’s worth trying, also to understand what level Qwen models have reached.

The news of the week, which you surely haven’t missed, is the Claude Code source leak. Certainly relevant news, but definitely not the only thing I’m covering in this newsletter. I also focus on the release of Gemma 4, Google’s open weight models that especially in their smaller versions look very promising with great results. There’s no shortage of deep dives into what we’ve learned from looking at Claude Code’s source, because there are certainly lessons to be learned, given that it remains one of the best agentic coding platforms on the market right now. And the internet went wild, downloading the source code, writing articles about it, and creating ports in Rust and Python.

Before I let you dive into the reading, I recommend not missing Simon Willison’s podcast, which highlights the risks of burnout for developers increasingly caught in the whirlwind of multi-agent orchestration during coding. And of course, don’t miss our podcast and all the initiatives I summarize here in my agenda.

My agenda

Podcast with Alessio and Paolo:

• A great interview with Gabriele Venturi, founder of PandasAI and a true nerd, is out :)

• We’re working on more interviews and episodes with very interesting guests.

• You already know about our GitHub repository with tools and configurations for AI coding from the terminal on Linux. It now has its own website with a single-script installation Lince.sh

• We released AntiVocale (Google Play, GitHub), a software to translate voice messages to text

On my own:

• The video of the talk I gave with Alessio at VoxxedDay Zurich has been published

• On May 30th I’ll have the honor of being one of the PyCon Italia speakers

• On June 12th I’ll be in Catania as a speaker at Coderful

AI Models News and Research

Takeaways for AI Engineers

• Takeaway 1: Small open weight models like Gemma 4 are making a two-tier agentic architecture concrete: local for simple tasks, cloud for complex orchestration.

• Takeaway 2: Qwen demonstrates that native multimodal reasoning (not just multi-format input) is becoming a reality in open models.

• Takeaway 3: For European players like Mistral, the niche of specialized and compact models could be the winning strategy against generalist competition.

• Action Items:

• Try Gemma 4 locally for speech-to-text tasks or lightweight processing: the benchmarks are promising and our experience with AntiVocale confirms it.

• Keep an eye on the Mythos leak from Anthropic: if confirmed, it could redefine the benchmark reference for frontier models.

What’s happening this week?

This week’s model news is undoubtedly dominated by the release of Gemma 4 from Google, a new family of relatively small open weight models that give a big push to using models locally, because they deliver truly remarkable performance. More and more, looking at what’s happening with small open weight models, I’m starting to think that an architecture for agents is taking shape that will soon be based on two tiers: a local one, with relatively small models for simpler tasks or for meta-processing information, and then delegating to state of the art models for orchestration and more complex tasks.

But getting back to Google’s models, as I was saying, the benchmark results are truly impressive and on top of that these are fully multimodal models. In one of the open source projects we’re releasing with the Risorse Artificiali group, AntiVocale (Google Play, GitHub), which is software for translating voice messages to text, we’ve also introduced Gemma 4 with good satisfaction. From an initial test, they have performance similar to Whisper for speech-to-text, but with an improvement in the ability to infer punctuation. This is our direct experience, but the articles I’m sharing are very interesting, especially the one that visually presents the architecture: I recommend taking a look if you’re curious about how a model is built internally.

The Chinese are certainly not standing still, because Qwen released two models this week: an omnimodal one (supporting all format types, from audio to text to video as input) and one called 3.6-Plus with advanced multimodal reasoning. I’ve been talking about this possibility in this newsletter for a while, and finally, in such an explicit way, Qwen releases a model with reasoning based on multimodal data, which partially generates graphical data to then use them within the reasoning phase.

It’s with pleasure that I also talk about Europe, because Mistral released Voxtral TTS, a text-to-speech model with only 4 billion parameters that seems to have excellent performance. I haven’t tested it in detail yet, but perhaps it’s precisely in these highly specialized models that Mistral can make its mark: it certainly can’t compete with state of the art generalist models, as it has already demonstrated in the past, but on very specific things this could be their market niche.

I close by talking about a leak from the Anthropic world, and I’m not referring to the Claude Code leak (which I discuss in the coding agent section), but rather the fact that they’re internally testing a new model larger than Opus that appears to have nothing short of impressive performance. Obviously this is a leak, it’s unclear how much it was orchestrated for publicity, and it should be taken with a grain of salt. But for sure, considering how much Opus is already capable of, a larger model coming from Anthropic will be something interesting to try.

Links of the week

• Claude Mythos — New Anthropic model tier above Opus, with much higher scores in coding, reasoning, and cybersecurity.

• A Visual Guide to Gemma 4 — Visual guide to Gemma 4 model architecture: local/global attention, p-RoPE, Mixture of Experts.

• Gemma 4 Open Models — Google DeepMind open model family in 4 variants, multilingual, multimodal, optimized for local use.

• Qwen3.5-Omni — Full omnimodal model: text, images, audio and video, with support for 113 languages.

• Qwen3.6-Plus — Advanced multimodal reasoning, critical milestone toward native multimodal agents.

• Mistral Voxtral TTS — 4B parameter text-to-speech model, 9 languages, expressive, low latency, open-source.

Agentic AI

Takeaways for AI Engineers

• Takeaway 1: Visual agent orchestration (like Cline Kanban) is maturing, but complexity remains a trade-off to evaluate against lighter solutions.

• Takeaway 2: Persistent memory is confirmed as a key component of effective agents, from the Claude Code leak to dedicated solutions like Engram.

• Takeaway 3: Agent optimization through reinforcement learning (Agent Lightning) and structured training loops is moving from theory to usable frameworks.

• Action Items:

• Evaluate Cline Kanban if you manage complex multi-agent workflows, but compare it with simpler solutions like Backlog.md for your use cases.

• Explore Microsoft’s Agent Lightning if you want to optimize existing agents without rewriting code.

What’s happening this week?

This week in this category I’m focusing on four links that try to identify development and research trends in the AI agent space, and I’m referring here to generic agents, not necessarily coding ones.

I start with Cline Kanban, which was born specifically for coding agents but which, looking at it closely, could easily be applied to more generic agents as well. It’s a kanban board where you can orchestrate agents in a graphical and intuitive way, creating dependencies or workflows. Definitely interesting to look at. Much more evolved, and at first impression a bit too complex for my taste compared to Backlog.md, but certainly worth exploring for more complex use cases.

Then an article about memory, Engram Memory System. I’ve been talking about the importance of memory in agents for a while, and this has also been demonstrated by the attention to memory usage in Claude Code’s leaked source code. In this case it’s a vector-based memory, which is perhaps not the most flexible of all those I’ve seen, but which is promising in how much it can improve the workflow.

The other two articles are somehow connected to each other. One is a research project, or rather a framework from Microsoft, for optimizing agents with reinforcement learning. The other is a more theoretical article about the training loop around the use of the harness by models within an agent system.

Links of the week

• The Model-Harness Training Loop — Agent training cycle based on harness engineering, open models, and accessible infrastructure.

• Cline Kanban — App for orchestrating multiple coding agents with kanban visualization, dependency management, and live status.

• Engram Memory System — Vector memory system for agents, persistent context to improve workflows.

• Agent Lightning (Microsoft) — Framework for optimizing agents with RL, prompt optimization, and fine-tuning, zero code changes.

AI Assisted Coding

Takeaways for AI Engineers

• Takeaway 1: The Claude Code leak confirms that the competitive advantage of coding agents isn’t in the model but in the harness: memory management, tool usage, and subagent orchestration.

• Takeaway 2: Cursor 3’s hybrid local/cloud approach represents an interesting architectural alternative to CLI-based subagent swarms.

• Takeaway 3: Cross-agent review between different agents (Codex on Claude Code, Lince.sh) is emerging as a practice to improve generated code quality.

• Action Items:

• Read the four articles about the Claude Code leak to extract patterns applicable to your agents, particularly on memory and harness.

• Check out Karpathy’s diagram of his personal workflow with coding agents as a starting point for optimizing yours.

What’s happening this week?

When it comes to agentic coding, this week was undoubtedly dominated by Anthropic’s code leak. As many of you will have seen, a developer published a version of Claude that also contained the code for debugging purposes, and the internet immediately went wild. We also discussed it extensively during the latest episode of the Risorse Artificiali podcast, which if you speak Italian I recommend listening to.

I don’t want to dwell too much on the lessons learned here, because they are many and varied. Even though there’s no magic recipe, as you’d expect if you’ve been in this world for a while. It’s a combination of good harness and memory usage practices: that’s what I’d condense into a single sentence. The code has clearly grown a lot on itself, much of it written with AI assistance, and at times has areas for potential improvement with good refactoring. But that’s not the point, because Claude Code works very well thanks primarily to those two aspects I mentioned earlier. I recommend reading the four links I’m sharing, because they analyze the code in an accessible but sufficiently in-depth way to understand the tool and how it adapts to different needs, and maybe give you some ideas for your coding agents and beyond.

If you’re using coding agents, I also recommend not missing Karpathy’s tweet, especially for the attached diagram that clarifies his personal use of coding agents. It may not be perfect for your use case, but it can certainly give you advice, as Karpathy always manages to do.

It’s been a while since we talked about Cursor, but they’re not standing still either. Version 3 of their IDE is out, redesigned for agent-driven and multi-repository development. Very interesting. It integrates both local and cloud agents in parallel, in a broad swarm-type orchestration. They deserve credit for the courage and ability to try new solutions, because this hybrid local and cloud approach is certainly different from the approach taken by Claude Code and all other CLIs, which instead tend to do subagent swarms.

Finally, I’d like to point out a plugin for Claude Code to use Codex within the Claude workflow. It’s curious because it allows for cross-agent review and using two different agents in parallel on the same problem. Lince.sh, the project I’m developing with the other folks at Risorse Artificiali, also lets you do something vaguely similar: use multiple agents on the same code repository and switch between them very quickly, all while staying in the same terminal. If you’re interested, check it out and give us your feedback. I’ll definitely talk about Lince.sh much more extensively in the next newsletter, after we’ve officially launched it on all social media, and maybe I’ll dedicate an entire issue of this newsletter to it. What do you think?

Links of the week

• Cursor 3 — IDE redesigned for agent-driven development, multi-repo, local and cloud agents in parallel.

• Inside the Claude Code source — Analysis of Claude Code source: 500K lines of TypeScript, harness architecture, divergences from Codex.

• Codex Plugin for Claude Code — Plugin to integrate Codex into the Claude Code workflow, cross-agent reviews.

• AINews The Claude Code Source Leak — Claude Code source leak via source maps: orchestration, memory, npm security risk.

• Practical Lessons From the Claude Code Leak — Architectural lessons from the leak: CLAUDE.md, subagents, worktrees, automatic hooks.

• Claude Code’s Real Secret Sauce — The software harness (Grep, Glob, LSP, subagents) matters more than the underlying model.

• Karpathy on LLMs and coding — Karpathy’s tweet with related diagram on using LLMs for coding.

Business and Society

Takeaways for AI Engineers

• Takeaway 1: The compute race between OpenAI and Anthropic will define the AI landscape of 2026-2027, with Google as the dark horse that has closed an enormous gap.

• Takeaway 2: The generative AI economy remains dominated by semiconductors (70% of revenue): those selling the shovels continue to earn more than those digging.

• Takeaway 3: Burnout from multi-agent orchestration is a real and underestimated risk for developers, as highlighted by Simon Willison.

• Action Items:

• Read the two economics articles (timelines and economics) to understand the market forces driving the technological choices that impact you daily.

• Monitor your own cognitive limits when using multiple agents and adopt tools that reduce context switching.

What’s happening this week?

OpenAI raises another 122 billion dollars in funding, with a monster valuation exceeding 800 billion. Meanwhile, Anthropic, which is currently winning the revenue race, has doubled its compute capacity, nearly matching OpenAI’s. A truly tight 2026-2027 is shaping up between these two competitors who are capturing most of the market, without forgetting Google of course, which has done incredible things recovering an enormous gap it had in 2024 and becoming one of the main competitors at the same level as these two.

Precisely because of this intense competition, it’s interesting to read the articles about the AI timeline update predictions and also how the economics of generative AI works. These are two economics-focused articles, but ones that I think are worth diving into to understand the economic forces behind this industrial revolution.

Simon Willison, on a podcast, talks about something I’ve often addressed in these pages and also in Italian on the Risorse Artificiali podcast: how much in the era of agents, burnout can truly be a risk for developers who find themselves facing their cognitive limits in orchestrating multiple agents. As mentioned, with Lince.sh we’re trying to provide a tool that somewhat limits context switching, at least keeping the developer within the terminal. But undoubtedly, increasing the number of agents to coordinate is on one hand a necessity to increase the capacity to use these tools, but on the other hand presents significant risks. Simon is one of my favorite writers to read, and he proved to be a great surprise on Lenny’s podcast as well.

Links of the week

• Simon Willison on Lenny’s Podcast — AI state of the union: human cognitive limits in the era of agents, burnout, new personal limits.

• Q1 2026 AI Timelines Update — Automated Coder predictions moved up to mid-2028, Claude Code at $2.5B annualized revenue.

• Compute Wars: OpenAI vs Anthropic — Anthropic doubled capacity, nearly on par with OpenAI. 2027 will be a tight race.

• OpenAI raises $122B — $122 billion in new funding, $852B valuation, strategy focused on compute and enterprise.

• The Economics of Generative AI — Semiconductors capture 70% of AI revenue. The most profitable strategy remains selling the shovels.

Welcome to this week’s newsletter, where I try to discuss the security needs of AI agents on one hand, and the growing autonomy we are trying to give them to become increasingly useful on the other. The two things are not in stark contrast, but mine is an invitation to always keep in mind the need for sandboxes and guardrails that limit the problems that can arise from the great freedom given to agents during ideation, which is however necessary to give them the autonomy they need to become even more powerful. There is no shortage of news on the models front and on very interesting research, especially in memory optimization. Probably not a coincidence, given the growing difficulty in sourcing memory itself and the resulting price increases. The Business and Society section is split between strong moves by OpenAI and an American senator who bestows upon artificial intelligence a role, that of the oracle, that perhaps does not belong to it. Before leaving you to the reading, let me remind you of all the occasions where you can meet me in person to exchange opinions and enrich each other.

• Podcast with Alessio and Paolo:

  • We are working on more interviews and episodes with very interesting guests.

  • You already know about our GitHub repository with tools and configurations for AI coding from the terminal on Linux. This week we released a complete dashboard... almost an IDE for agents, but all from the terminal: LINCE - Linux Intelligent Native Coding Environment

• On my own:

  • On May 30th I will have the honor of being one of the PyCon Italia speakers

  • On June 12th I will be in Catania as a speaker at Coderful

AI Models News and Research

Takeaways for AI Engineers

• Takeaway 1: ARC-AGI-3 confirms that AGI requires agentic capabilities for adapting to environments without predefined rules, not just pattern matching.

• Takeaway 2: KV cache compression (TurboQuant) could enable both larger models running locally and enormously longer contexts on frontier models.

• Takeaway 3: Mistral might find its niche in specialized models (like Voxtral TTS) rather than competing on frontier large language models.

• Action Items:

• Try quantizing a local model following the “quantization from the ground up” guide to evaluate the quality/size trade-off on your own machine.

• Test Voxtral TTS for multilingual use cases, taking advantage of the 9 supported languages and low latency.

What’s happening this week?

The main news to report in the world of models is certainly the release of the new ARC-AGI-3 benchmark, in which frontier models solve barely 1% of the puzzles. There was a great need for a new benchmark that tested AGI because the previous ARC-AGI-2 was no longer challenging for frontier models. Looking at how the benchmark was designed, it is interesting to see how the capabilities being tested most are agentic ones, and in particular those that allow adapting to an environment where rules are not defined a priori. This suggests that people are beginning to think, as many have suggested in the past, that to reach AGI we must necessarily go through the capabilities of a robot that moves in an environment without predefined rules, but where rules can be derived from feedback received from the environment. The new approach by those who wrote the benchmark is certainly interesting.

The other important news in the world of models is certainly the release of TurboQuant, a new way to compress and quantize the KV cache. The article and paper come from Google researchers and promise extreme efficiency in KV cache compression and therefore, ultimately, context compression. What could happen soon are two things. The first is the ability to run even larger and more complex models with a decent context locally. The second is that frontier models will gain the ability to have even longer contexts than what we are used to now, and as we know, longer contexts mean what is normally called in-context learning.

I also recommend an article that explains quantization from the ground up very well. It discusses model quantization rather than KV cache as in the previous case, but I believe it is a useful read for anyone wondering how this technique works.

Another interesting reflection comes from the article that explains well why fine-tuning is less talked about than in the past, mainly due to cost and maintenance reasons.

Finally, not to be missed is the new launch of Mistral Voxtral, a truly small text-to-speech model that delivers excellent results in nine languages. Perhaps it is in these niches that Mistral can make its mark again, since its models certainly cannot compete with frontier ones, at least when it comes to large language models.

This week’s links

• ARC-AGI-3 is out — New benchmark for agentic intelligence: frontier models solve less than 1% of interactive environments.

• TurboQuant: Redefining AI efficiency with extreme compression — Google technique for compressing the KV cache while preserving geometric relationships useful to the model.

• Quantization from the ground up — Comprehensive guide explaining how model quantization works and its effects on quality.

• Mistral launches Voxtral TTS model — Text-to-speech model with 4B parameters, multilingual in 9 languages with low latency.

• Why aren’t we fine-tuning more? — Prompts today are enough for most use cases, making fine-tuning less necessary.

Agentic AI

Takeaways for AI Engineers

• Takeaway 1: Agents using the computer “like a human” is the key to reusing the enormous ecosystem of existing tools without rewriting them.

• Takeaway 2: Autonomous agent security is emerging as a category of its own: sandboxing, dependency scoring, and kernel isolation are the three main directions.

• Takeaway 3: Always-available agents (via Channels, OpenClaw) are changing the paradigm from “on-demand tool” to “persistent collaborator.”

• Action Items:

• Evaluate Nono or Brin to isolate your coding agents, especially if you work with autonomous agents on sensitive codebases.

• Try Claude Code Channels with Telegram or iMessage to experience the model of an agent always reachable from your phone.

What’s happening this week?

Two main trends to highlight in this section. The first is how we are increasingly moving toward agents capable of using the computer like humans to carry out their tasks. The point of this lies in the ability to reuse existing tools designed for humans. Much like when we talk about humanoid robots that can easily reuse all the tools we have built for ourselves, from door handles to frying pans. In the same way, using the computer the way a human does allows reusing a series of tools and programs that would otherwise need to be rewritten or heavily adapted. Along with this, the trend started by experiences like OpenClaw to make these agents always available is spreading: through what Claude Code has called Channels, for example, you get an effect very similar to what OpenClaw made possible first.

The second trend is somewhat related to this new way of using agents, always present on our computers and with ever more ability to interact with what they find on the computer and with all our accounts. What I am talking about is the trend toward developing tools that isolate agents and prevent them from doing harmful things, both at the level of actual sandboxes and in more creative, lateral-thinking approaches to the problem. In this regard, I recommend three projects called Starpod, Brin, and Nono, which are worth looking at. As you know, together with the other people who share the podcast with me, I am working on a similar project that we have called LINCE, which integrates these concepts of sandboxing and isolation of coding agents placed in a dashboard for rapid coordination of multiple agents, in order to have them always present and always active. I liked the projects I am recommending so much that we have already integrated Nono as an alternative sandbox to our native Linux sandbox, and we are also considering integrating Brin. Starpod solves a slightly different problem, but it is certainly something to consider for enterprise environments.

This week’s links

• Claude Code and Cowork can now use your computer — Computer Use available for Pro and Max subscribers on macOS.

• Perplexity tests Market Research tool for Perplexity Computer — Market research with premium sources via multi-model agentic system.

• Claude Code Channels: push events into a running session — Push events from Telegram, Discord, and iMessage into Claude Code sessions.

• Starpod — Platform for deploying multi-tenant AI agents at scale.

• Brin — External dependency scoring service for AI agent security.

• Nono — Open-source sandbox with kernel-level isolation for AI agents on macOS and Linux.

AI Assisted Coding

Takeaways for AI Engineers

• Takeaway 1: The acquisitions of Astral (OpenAI) and Bun (Anthropic) confirm that coding is the main battleground for AI leaders.

• Takeaway 2: Chinese models like GLM-5.1 are closing the quality gap in coding at aggressive prices, increasing competitive pressure.

• Takeaway 3: Claude Auto Mode is a step forward in automatic permissions, but it does not replace a proper sandbox.

• Action Items:

• Explore Cline Kanban as a possible alternative or complement to Backlog.md for coding agent orchestration.

• Test GLM-5.1 on a non-critical coding project to verify the quality/price ratio compared to frontier models.

What’s happening this week?

OpenAI acquiring Astral pairs with Anthropic having acquired the company behind Bun a few months ago. The two big names in AI are clearly focusing on software development and competing for the companies that produce the most interesting dependency management systems in the Python and TypeScript worlds. It is certainly worth noting and shows how central coding is for these companies right now.

Another piece of news I like to highlight is the release of GLM-5.1, which has coding results approaching those of Claude Opus. As you probably remember, GLM is the flagship model of a Chinese company called Z.ai that is trying to compete with frontier models for coding at very aggressive prices. Although the execution speed is not that of frontier models, the accuracy is getting closer and closer.

Also worth noting is the new Claude Auto Mode, which allows automatic permissions that are a bit less aggressive than disabling all risky controls. There is an option to do this in Claude Code, but it should absolutely be managed within a sandbox. I talk about sandboxes in the previous section and I am very focused on this with the LINCE project. Claude Auto Mode reduces some of those risks, although sandboxes are absolutely always recommended.

Cline Kanban is an interesting project and somewhat a competitor to Backlog.md, which I have often mentioned both here and on the podcast as one of my foundational tools for agentic development. It is definitely worth a deeper look. I have not yet had the time to do so, but I plan to this week. If anyone has strong opinions on this, please let me know in the comments.

I leave you to read the link on Cursor Composer 2 built on Kimi 2.5 and the transparency issues reported there.

This week’s links

• OpenAI acquires Astral — Acquisition of Python tools Ruff and uv to integrate them into Codex.

• Cursor Composer 2 built on Kimi 2.5 — Cursor model based on Moonshot AI’s open-source Kimi, transparency concerns.

• Cline Kanban: multi-agent orchestration — CLI-agnostic kanban board for managing multiple coding agents in parallel.

• GLM-5.1 Coding: approaching Claude Opus 4.6 — 94.6% of Opus capabilities at $3/month from Z.ai.

• Claude Auto Mode — Automatic permissions in Claude Code with integrated safety classifier.

Business and Society

Takeaways for AI Engineers

• Takeaway 1: The shutdown of Sora and the focus on the automated researcher confirm OpenAI’s pivot from consumer to enterprise, leaving Google nearly alone in the Western consumer market.

• Takeaway 2: The collapse of the Disney $1B deal reveals how unsustainable AI video generation costs still are, even for OpenAI.

• Takeaway 3: The Sanders video with Claude raises the question of how much power and authority we are conferring upon AI in decisions that matter.

• Action Items:

• Watch the Bernie Sanders video with Claude and read Paolo Gervasi’s comment on LinkedIn to form your own opinion on the topic.

• Read the complete Claude 2026 overview to map which new features (Channels, Auto Mode, Computer Use) are already usable in your workflow.

What’s happening this week?

Let’s start with two pieces of news about OpenAI that, even though it may not seem like it, are closely connected. The first is that OpenAI hastily announces the shutdown of Sora. You will remember that Sora was their model and everything around it for creating realistic videos, somewhat like Veo for Google and many others. They had set it up very much as a social platform and something to give to consumer users, and it had been rumored for some time that the costs were too high to be sustainable. But the story within the story is that based on Sora, a few months ago, OpenAI had closed a stock swap agreement with Disney worth one billion dollars, which with this project shutdown falls apart completely. Evidently the costs were truly too high to sustain, if Sam Altman decides to give up one billion dollars from Disney.

The other news comes from inside OpenAI: the company is going all in on building a fully automated researcher, aiming for a multi-agent system by 2028. How is this connected to the Sora shutdown? Because it demonstrates how much OpenAI is focusing on the enterprise and business-to-business market, leaving the consumer side behind as a market choice. If you remember, all the evident investments made in Codex to become competitive with Claude also point in this direction. And who remains in the Western consumer market? Practically only Google. But Google is certainly used to thriving in the consumer market.

I don’t know if you have seen the video of Senator Bernie Sanders discussing the impact of AI with Claude. I very much align with the opinion I read on LinkedIn by Paolo Gervasi, who provides an extremely accurate and irreverent take on it, comparing it to the ancient Greeks who went to the oracle to seek its judgment, thereby bestowing upon it a divine status that perhaps the oracle did not deserve. I leave you to reflect on this. I also discussed it on the podcast with my colleagues, if you want to listen.

I close with an article that tries, with some effort, to put together all the news from Anthropic in 2026. Chat, Cowork, Code, Projects: all the Claude Code news. I could have placed this article in any of the previous sections. It sits here in Business and Society because the speed of new feature releases on Claude Code, and in this world in general, are reshaping the way of doing business and the impacts they are having on society. Happy reading.

This week’s links

• OpenAI is throwing everything into building a fully automated researcher — Target “AI intern” by September, multi-agent system by 2028.

• OpenAI shuts down Sora, Disney $1B deal collapses — Sora shutdown and collapse of the Disney $1B deal as focus shifts to IPO and AGI.

• Senator Bernie Sanders discusses the impact of AI on privacy and democracy with Claude — Conversation on data collection, targeted advertising, and legal safeguards.

• Claude 2026: Everything shipped and how to use it — Complete overview of Claude 4.6: Chat, Cowork, Code, Projects.

If I had to find a recurring theme in this newsletter, and perhaps in those of the past few weeks as well, I believe it’s undoubtedly agentic coding and more broadly the development of agentic systems. But for now, not distributed across the network as one might have thought at the beginning of this development, rather very much centered on the user’s machine. This will probably change over time and, as we’ve seen many times, cycles and recycles within computing: it has often happened in the past that a centralized solution ended up on individual users’ machines only to return to distributed solutions.

Think about it: we went from mainframes to personal computers and then back to the cloud, but this is just one of the many examples I could give of this trajectory, and it’s what is somewhat happening in the world of AI as well. We went from chatbots, centralized and completely controlled by the vendor, to coding agents or personal agents (think not only of Claude Code, but also OpenClaw or Claude Work), and then perhaps in the future we’ll see agents distributed in the cloud. The latter hasn’t happened yet, but all the conditions are there for it to happen. So keep your eyes open, keep reading the newsletter and always maintain your own critical thinking about what’s happening. Get your hands dirty trying some of the things I suggest and do everything you can to jump on this fast-moving train.

Before I leave you to the news and my analysis of what happened this week, let me share what has happened, is about to happen, or will happen in my public agenda, for those who want to follow my talks or meet me in person (I love exchanging opinions with anyone who’s willing):

• Podcast with Alessio and Paolo:

  • On Wednesday, my interview with Massimo Re Ferré, PM at AWS Kiro, was released.

  • We’re working on more interviews and episodes with very interesting guests.

  • You already know about our GitHub repository with tools and configurations for AI coding from the Linux terminal. This week we released a complete dashboard... almost an IDE for agents, but all from the terminal: LINCE - Linux Intelligent Native Coding Environment

• On my own:

  • On March 24th I’ll be at Voxxed Day in Zurich. Alessio and I are presenting a talk on AI assisted coding

  • On March 25th I’ll be speaking at this meetup in Milan on Vibe Coding and Agentic Engineering

  • On May 30th I’ll have the honor of being one of the PyCon Italia speakers

  • On June 12th I’ll be in Catania as a speaker at Coderful

AI Models News and Research

Takeaways for AI Engineers

• Takeaway 1: Anthropic’s 1M token context qualitatively changes working with coding agents, eliminating the context management bottleneck
  
  

• Takeaway 2: Chinese vendors are converging on models optimized for agentic scenarios (MiniMax M2.7, GLM-5-Turbo): agentic AI is the competitive battlefield of the moment
  
  

• Takeaway 3: If DeepMind is building metrics for AGI, it’s because the perceived distance is concretely shrinking
  
  

• Action Items:
  
  

  • Try Claude Code with 1M context on a complex multi-file task

  • Read the DeepMind paper on the cognitive framework for AGI to calibrate expectations on where we really are

What’s happening this week?

Let’s start with a relevant piece of news from Anthropic, which has extended the context length of both the Opus and Sonnet models to one million tokens. Having one million tokens significantly changes the experience of using Claude Code, especially because it allows you to perform very long and complex operations without the need to clear the context or keep track of these operations in alternative ways. It’s definitely a feature worth trying.

Chinese model vendors are certainly not standing still either. MiniMax launches its M2.7 model, which has excellent benchmark results especially for agentic functionality. The same goes for GLM-5-Turbo, also optimized for agentic scenarios. Both models are recommended for use with OpenClaw, which is, or at least seems to be, the real reference point right now for Chinese models. In practical use for coding, I said in previous weeks that the experience with Claude is still superior. But I must admit that I also use one of these models.

Very interesting instead are the news coming from research, starting with World Models that are advancing AI further by simulating the complexity of the real world. But also an interesting piece of research from DeepSeek on using an index within attention, better capturing the semantic meaning of the sentence being processed.

Last but not least, in the research space, a cognitive framework released by Google DeepMind to measure progress toward AGI. Beyond the paper, which is very interesting to read and I recommend, I’d like to emphasize that if DeepMind, with the visibility it has on model evolution, is designing a framework to measure progress toward AGI, it’s because we’re getting ever closer to that point.

Links of the week

• 1M context now available for Opus 4.6 and Sonnet 4.6 — 1M token context window at standard pricing for Claude Opus 4.6 and Sonnet 4.6, including Claude Code

• World Models: Computing the Uncomputable — World Models simulate real-world complexity to enable prediction and planning through neural networks

• Measuring progress toward AGI: a cognitive framework — Google DeepMind proposes a cognitive taxonomy with 10 key abilities to measure progress toward AGI

• MiniMax launches M2.7 model — M2.7 model available via API with autonomous debugging capabilities and research agent harnesses

• GLM-5-Turbo — Z.ai’s foundation model optimized for agentic scenarios with 200K context and MCP support

• Faster Sparse Attention with IndexCache — Patch for SGLang and vLLM that eliminates up to 75% of indexer computations in DeepSeek Sparse Attention

Agentic AI

Takeaways for AI Engineers

• Takeaway 1: OpenAI is building a complete ecosystem for agentic coding: model (GPT 5.4), security monitoring, and subagents in a single coordinated strategy
  
  

• Takeaway 2: Subagents are now a consolidated cross-platform pattern (Claude Code, Codex): those not using them are leaving performance on the table
  
  

• Takeaway 3: Context engineering is the key discipline for making agentic systems work well, and SwirlAI’s article maps the five fundamental patterns
  
  

• Action Items:
  
  

  • Read the “State of Context Engineering in 2026” article as a practical guide for optimizing context in your agents

  • Try subagents in Codex or Claude Code to experience the agentic delegation pattern on a real task

What’s happening this week?

OpenAI demonstrates that it has developed great interest in coding and positions itself as a serious alternative, according to some even better, to Claude Code. This week I invite you to focus on the three articles I’m reporting from OpenAI, because all three are significant in this strategy.

GPT 5.4 has been a major step forward especially in its agentic usability within Codex and is the first model and agent, together with Codex, from OpenAI that truly seems capable of handling a wide variety of tasks, both code and non-code. Furthermore, OpenAI has released a monitoring system for autonomous coding agents, designed to detect misalignment risks and study their behavior, which further underscores their interest in this market. The same goes for the fact that Codex now supports subagents, a pattern widely used in the Anthropic world and beyond, which allows launching autonomous secondary agents managed by the main agent while saving context and optimizing work.

Moving away from the OpenAI world, I’d like to highlight OpenShell in this sector, a secure runtime made by NVIDIA for running autonomous agents. Essentially it’s a solution based on Kubernetes with declarative policies written in YAML. Truly an advanced solution that goes well beyond, probably, just writing code.

Lastly, I’d like to point out a very interesting article about context, called “State of Context Engineering”, which contains truly four or five very interesting insights. In my opinion it’s a must-read right now to deeply understand how to effectively manage context in your agentic systems. It ranges from skills and their progressive disclosure to context compression, intelligent routing, but also topics related to RAG or external tools like tools or MCP servers.

Links of the week

• GPT 5.4 is a big step for Codex — First OpenAI agent with true agentic usability, precise instructions and ability to handle diverse tasks

• Monitoring Autonomous Coding Agents — OpenAI monitoring system to detect misalignment risks in internal coding agents

• Subagents and custom agents in Codex — Codex releases subagents in GA with support for custom agents defined via TOML files

• OpenShell — Secure NVIDIA runtime for autonomous agents with sandbox and declarative YAML policies on Kubernetes

• State of Context Engineering in 2026 — Five key patterns for managing context: progressive disclosure, compression, routing, RAG and MCP

AI Assisted Coding

Takeaways for AI Engineers

• Takeaway 1: OpenAI acquires Astral (uv, Ruff, ty) and promises to keep them open source: the word “open” in their name might finally make sense at least for tools
  
  

• Takeaway 2: Skills are the highest-impact extension point for coding agents: those not using them are underutilizing their agent
  
  

• Takeaway 3: The coding agent market is fragmenting with serious alternatives (Cursor Composer 2, Codex) challenging Claude Code on price and performance
  
  

• Action Items:
  
  

  • Read the Anthropic article on skills and start adding them to your coding agents

  • Try LINCE Dashboard to manage multiple agents in parallel from the terminal

What’s happening this week?

The acquisition of Astral by OpenAI speaks volumes about how much OpenAI has developed interest in the coding market. For those who don’t know, Astral is the company behind three of the main open source development tools for Python. I’m referring to uv, Ruff, and ty, which are now joining the Codex ecosystem. Just as they did with OpenClaw, OpenAI promises to keep the projects completely open source, which if confirmed would give meaning to the word “open” in their name, given that with models they have a completely different policy.

Cursor instead, which seemed to have been somewhat forgotten, releases its first truly frontier coding model. Composer 2, at a fairly low price, has substantial performance improvements that according to the vendor would even surpass those of Claude.

From Google comes the announcement of a new design tool called Stitch, which we had already seen peeking out in Google Labs, and which will transform the way of working and collaborating with AI in 3D and 2D environments, with the ability to generate functional React applications from designs alone, meaning not from code but from the application’s design itself.

One of Anthropic’s internal developers wrote a beautiful article on how skills are used internally at Anthropic and how they were developed. I strongly recommend reading this article if you’re adding skills to your toolkit for your coding agent. And if you’re not doing that, you should. So read that article, learn how to do it and start evaluating the addition of skills among the things you use to improve the coding experience with coding agents.

Finally, a mention from the personal front. Together with the other folks at Risorse Artificiali, this week we made available on GitHub a tool for using multiple agents efficiently and effectively within the Linux terminal. LINCE Dashboard has support for session persistence and also voice input capability. In the meantime, Anthropic has made voice input available on Linux as well, but trust me, ours works much better. LINCE Dashboard configures itself as a unique environment where you can use multiple agents even on different directories and therefore different projects in parallel, without ever missing an input request from one of them while you work in parallel on something else. Additionally, each agent is sandboxed to ensure security on your system, which I’ll never tire of repeating is one of the fundamental things when using a coding agent or any other kind of agent.

Links of the week

• Lessons from Building Claude Code: How We Use Skills — How Anthropic uses skills internally: functional folders, progressive disclosure and high-impact “Gotchas” sections

• Cursor Composer 2 — Frontier coding model at competitive pricing with substantial improvements on CursorBench and SWE-bench

• OpenAI acquires Astral — uv, Ruff and ty join the Codex ecosystem; OpenAI promises to keep them open source

• Early look at upcoming design tool from Google — Stitch: 3D workspace with AI that generates functional React applications from designs

• LINCE Dashboard — Zellij plugin for managing multiple Claude Code instances with session persistence and voice input

Business and Society

Takeaways for AI Engineers

• Takeaway 1: OpenAI is targeting an IPO by transforming ChatGPT into an enterprise productivity tool: the shift from consumer novelty to sustainable revenue is the real signal
  
  

• Takeaway 2: China is democratizing AI with mass adoption programs that have no equivalent in the West
  
  

• Takeaway 3: Open source in the AI era needs new mentorship frameworks to manage the noise from automatically generated contributions
  
  

• Action Items:
  
  

  • Form your own opinion by reading the four links and share it in the comments

  • Evaluate how the “3 Cs” framework can apply to your open source projects that receive AI contributions

What’s happening this week?

In this section I invite you to read the four links I’m proposing without giving you too much of my own reading, because I believe it’s important that you have your own opinion and your own critical thinking on the links I propose. I’m happy to discuss any opinions in the comments, but I believe that the four links, while not being front-page news, are very significant for understanding which direction the world of AI is heading, with the United States and China leading the trends that shape the market.

Links of the week

• OpenAI preps for IPO by end of year — OpenAI targets stock market listing by 2026, ChatGPT must become an enterprise productivity tool

• How China is getting everyone on OpenClaw — Baidu and Tencent promote OpenClaw with mass adoption campaigns across all demographics

• Rethinking open source mentorship in the AI era — The “3 Cs” framework for strategic mentorship against the noise of AI-generated contributions

• Google’s Personal Intelligence expanding to all US users — Google’s assistant accesses Gmail and Photos for personalized responses, now available to everyone

The usual intense week with Meta, which further delays the release of its new LLM models, while acquiring Moltbook, effectively certifying that we are heading towards an agent-based economy. Professor Ethan Mollick, whom I have cited many times in this newsletter and whom I greatly respect, also writes about how the AI world is already shifting from what he calls co-intelligence to a model where humans use their own intelligence to orchestrate multiple agents that do the heavy lifting. It’s a significant and in some ways epochal shift, especially coming from someone who has always strongly theorized the concept of co-intelligence.

But there are many other news stories and many other new tools we discuss in this newsletter, in addition to the fact that I’ve reintroduced a section for this issue where I discuss the main research papers related to the trends I highlighted earlier. It’s something else I’ve been thinking about in recent weeks, namely persistent memory, skills, harness development and how agents are increasingly viewed as entities for reinforcement learning, beyond the single model they use, as dispositive entities.

Before leaving you to the news and my analysis of what happened this week, let me share what has happened, is about to happen, or will happen in my public agenda, for those who want to follow my talks or meet me in person (I love exchanging opinions with anyone willing to do so):

• Podcast with Alessio and Paolo:

  • On March 12th we were at the JUG in Milan to record our first live episode.

  • We are working on more interviews and episodes with very interesting guests

  • We created a GitHub repository with tools and configurations for AI coding from the terminal on Linux. Obviously open source, so check it out and contribute: LINCE - Linux Intelligent Native Coding Environment

• Solo:

  • On March 19th I’ll be at the AI aperitivo, not sure yet if I’ll be doing a Lince demo... but we can talk about it regardless :)

  • On March 24th I’ll be at Voxxed Day in Zurich. Alessio and I are presenting a talk on AI assisted coding

  • On March 25th I’ll be speaking at this meetup in Milan on Vibe Coding and Agentic Engineering

  • On May 30th I’ll have the honor of being one of the PyCon Italia speakers

AI Models News and Research

Takeaways for AI Engineers

• Takeaway 1: Competitive value is shifting from the model to the integrated product.

• Takeaway 2: Meta confirms its post-Llama 4 struggles: the Avocado delay signals a growing gap.

• Takeaway 3: Code generation is evolving towards complete product generation.

• Action Items:

• Assess how much your workflows depend on isolated models vs. integrated products.

• Explore the new Gemini integrations in Google Workspace and Maps to understand the level of maturity achieved.

What’s happening this week?

In this week’s model news (or rather, more product news than model news) I’m focusing on slightly different aspects than what I normally pay attention to. I usually follow model releases closely, but this week the only model news is rather negative: Meta further delays the launch of the new Avocado models and generally what are essentially the Llama 5 models. This release is delayed at least until May, and what’s leaking are performance and accuracy issues. Meta really isn’t making a good impression on the market since Llama 4.

The other news instead focuses on what is a fairly strong trend: the shift from isolated systems to much more integrated systems, where models collaborate directly with products. In this regard, Google’s updates are noteworthy, both for Maps and for Workspace updates, where Gemini models are deeply integrated with Google’s products.

Last but not least, the mention of Replit Agent 4, which I cite here rather than in the AI Assisted Coding section because I believe the shift from pure code generation to collaborative generation of an entire product suite is significant.

Links of the Week

• How We’re Rethinking Maps with Gemini — Google’s Ask Maps uses Gemini for personalized real-time answers and destination recommendations.

• Claude Now Creates Charts, Diagrams and Interactive Visualizations — Imagine with Claude generates and edits charts, diagrams and interactive visualizations directly in conversation.

• Meta Delays New AI Model Release Over Performance Concerns — Meta’s Avocado model doesn’t compete with leaders; release postponed at least to May over performance issues.

• Gemini Workspace Updates — New Gemini features integrated in Docs, Sheets, Slides and Drive for enhanced productivity and collaboration.

• Replit Agent 4 — Infinite design canvas and parallel AI agents to build backend, frontend and slide decks in a single integrated environment.

Agentic AI

Takeaways for AI Engineers

• Takeaway 1: The A2A protocol v1.0 marks the shift from isolated agents to interoperable, production-ready multi-agent ecosystems.

• Takeaway 2: Karpathy’s AutoResearch shows agents iteratively improving models: a concrete step toward autonomous self-improvement.

• Takeaway 3: Three architectural patterns are consolidating for agents: persistent memory, programmable skills and harnesses as autonomy infrastructure.

• Action Items:

• Study the three patterns (memory, skills, harness) and assess which are already present in your agentic architecture.

• Explore the A2A protocol v1.0 and its Agent Cards to understand how to enable cross-platform communication between your agents.

What’s happening this week?

In this section there’s truly an embarrassment of riches when it comes to choosing which news to focus on, but I can’t help but start with the announcement of the A2A protocol in version 1.0, since I actively participated in this work with my team, also maintaining the Java SDK and TCK for the entire protocol.

But leaving personal matters aside, an honorable mention goes to Karpathy’s AutoResearch, which has been making waves in the community for about two weeks. It involves using agents in a guided research loop to improve a model’s training. I’ve said it many times, both here and on the podcast, that seeing models capable of improving themselves brings AGI to mind very closely. For me, that’s one of the turning points. We may not be there yet, but seeing iterative improvements, managed entirely by an agent, is certainly impressive.

Then there are three trends I’ve been highlighting for some time. Persistent memory for agents, skills as a way to extend agents and program their behaviors, and finally a trend I’ve been emphasizing for a few weeks now: harnesses. By harness we mean all those artifacts (tools, agents, memory or anything else that can be used by the LLM) to behave as autonomously and decisionally as possible, to become an agent. I’m including an article for each of these trends, which I consider significant cultural knowledge for any AI engineer.

Finally, Perplexity demonstrates that the idea of letting agents use a computer directly is realistic and not just a toy made by the community like OpenClaw. It’s a bit like when we talk about humanoid robots that have that form factor to be able to use all the tools we designed for the human form factor. In the same way, agents capable of using existing software, even if designed for human use, can have the competitive advantage of reusing a huge base of already available tools.

Links of the Week

• Agent Skills: Progressive Disclosure as a System Design Pattern — Three-level pattern (discovery, activation, execution) for managing agent context efficiently.

• A2A Protocol v1.0: Standardized Agent Communication — Open protocol for discovery, communication and coordination between AI agents across different platforms and organizations.

• The Anatomy of an Agent Harness — Models contain intelligence, the harness makes it useful: core components for transforming LLMs into agents.

• Google Always On Memory Agent — Open source system for persistent agent memory, without vector database, under MIT license.

• Karpathy’s AutoResearch — AI-driven research loops for iteratively improving model training on a single GPU.

• Perplexity’s Personal Computer — AI agents managing tasks by delegating to other AIs on a Mac Mini, like an automated project manager.

AI Assisted Coding

Takeaways for AI Engineers

• Takeaway 1: 2026 is shaping up as the year LLMs enter code review: Claude Code Review is the first concrete signal.

• Takeaway 2: The extension ecosystem for Claude Code is maturing rapidly, with projects like Everything Claude Code and SuperClaude enriching the agentic experience.

• Takeaway 3: Chrome DevTools MCP opens browser functionality to any agent, not just coding ones, with official Google support.

• Action Items:

• Try Claude Code Review on your PRs to evaluate the quality of automated reviews compared to the manual process.

• Configure Chrome DevTools MCP in your development environment to explore agentic debugging possibilities.

What’s happening this week?

There are memes in the community about how you go to bed, wake up and every morning find a new Claude feature, and they pretty much reflect reality. Just this week there are at least three major announcements in the Anthropic world. The first and most important is that they released in preview for Team and Enterprise customers a new Claude Code feature called Review for managing pull request reviews. Just last week I was talking about how LLM usage is shifting from pure code generation to other phases as well. 2026 could be the year we see LLMs become a significant part of the code review toolchain. This seems like the first signal.

The second Claude link I’m highlighting is called Everything Claude Code and it’s interesting because it’s one of the winners of the Anthropic hackathon. It’s a series of agents, commands and skills designed to improve the Claude Code experience, something very similar to SuperClaude which I’ve already discussed many times. It’s on my to-do list this week to try it extensively to see if the experience is genuinely better than SuperClaude and other already available projects.

Meanwhile at Google they’re announcing Chrome DevTools as MCP, and it’s an important announcement because beyond the development aspect it allows opening browser functionality to any agent, coding or not. Something we’ve certainly already seen happen with OpenClaw, but this time with full Google support.

Links of the Week

• Claude Code Review — Automated code review system with multi-agent team for in-depth pull request analysis, available for Team and Enterprise.

• Everything Claude Code — 16 specialized agents, 65+ skills and 40+ slash commands to optimize Claude Code workflows.

• Claude Interactive Mode Documentation, /btw — Side questions during active work without interrupting tasks or adding to conversation history.

• How Coding Agents Are Reshaping Engineering, Product and Design — The bottleneck shifts from writing to reviewing code; generalists gain the most advantage.

• Chrome DevTools MCP — Direct connection to active browser sessions for agentic debugging, no extensions or headless browser needed.

Business and Society

Takeaways for AI Engineers

• Takeaway 1: Meta’s acquisition of Moltbook confirms big tech’s interest in an agent-based economy.

• Takeaway 2: The Anthropic Institute signals that legal, economic and AI governance challenges are becoming strategic priorities on par with technical development.

• Takeaway 3: Ethan Mollick redefines the relationship with AI: from co-intelligence (AI helping humans) to AI management (humans orchestrating autonomous agents).

• Action Items:

• Read Ethan Mollick’s full article “The Shape of the Thing” to deepen your understanding of the shift from co-intelligence to AI management.

• Watch OpenAI’s open source acquisition strategy as an indicator of which tools will become platform standards.

What’s happening this week?

In this section we start again from Meta, which acquired, or rather hired, the person who created Moltbook, since it’s an acquisition of a company made by a single person. For those who don’t remember, Moltbook is a social network for agents that seems to be exactly in Meta’s core business, but also confirms the interest from major companies in an agent-based economy.

Meanwhile OpenAI continues with its acquisitions of open source platforms. Just as happened with OpenClaw, at least in acquiring open source platforms and keeping them open it’s living up to its name that starts with Open, something it has never done, or almost never, with its models.

And while Nvidia is also investing in Mira Murati’s startup with a multi-year partnership, I prefer to focus on two articles. One from Anthropic, presenting the Anthropic Institute, an institute founded to focus on the legal, economic and global governance aspects of AI. And one from Professor Ethan Mollick, who examines AI’s transition from what he has always called co-intelligence, meaning intelligence augmented by humans through the use of AI, towards instead an intelligence that must be used by humans for managing AI and the many agents that can be used in parallel to accomplish complete tasks. I recommend reading this article carefully because Professor Ethan Mollick certainly expresses this concept better than I can, and I certainly don’t want to try to summarize it when I think a complete and thorough reading is essential.

Links of the Week

• The Shape of the Thing — Ethan Mollick examines the shift from co-intelligence to AI management and autonomous agents.

• Introducing the Anthropic Institute — Institute dedicated to legal, economic and global AI governance aspects, led by Jack Clark.

• Nvidia Invests in Mira Murati’s Thinking Machines Lab — Multi-year partnership with at least one gigawatt of chips for frontier model training and serving.

• Promptfoo Joins OpenAI — Open source AI safety and evaluation platform acquired by OpenAI, will remain open source.

• Meta Acquired Moltbook — Meta acquires the AI agent social network built on the OpenClaw framework.

Research Papers

Takeaways for AI Engineers

• Takeaway 1: The papers confirm the agent harness trend: skills, tools and memory are the infrastructure transforming AI from informative to dispositive.

• Takeaway 2: Reinforcement learning applied to agents (not just LLMs) paves the way for enterprise agents trained for specific use cases.

• Takeaway 3: SkillNet proposes an open model for reusable and composable skills, a useful reference for anyone designing agentic architectures.

• Action Items:

• Read SkillNet for inspiration on how to structure and connect skills in your agents.

• Explore the distinction between RL on LLMs and RL on agents introduced by KARL to understand the implications for your system design.

What’s happening this week?

A research papers section that was missing from this newsletter for a while. I’m reintroducing it to bring you four very significant papers I’ve read in recent weeks that confirm the trends highlighted in the previous sections: the need for long-horizon memory (Memex(RL)), with reinforcement learning that allows agents to use it better, but also the entire trend developing around agent harnesses (AutoHarness), namely skills, tools and everything related to the iterative refinement of the instruments agents can use to transition from an informative artificial intelligence to a dispositive one.

In the same direction goes SkillNet, a paper that defines an open infrastructure for reusable AI skills, with multidimensional evaluation and connections between them. It’s worth reading even just for ideas on how to better write and connect your own skills.

The KARL paper discusses knowledge agents via reinforcement learning. It’s interesting for demonstrating that through reinforcement learning, agents, particularly research ones but not only, can be trained for specific enterprise cases as distinct entities for clients. Here we’re talking about applying reinforcement learning to agents, meaning the reasoning and action part, and not just the LLM part. It’s an important distinction.

Links of the Week

• AutoHarness: Automatic Code Harness Synthesis for LLM Agents — Automatic generation of protective structures for agents through iterative refinement with environmental feedback.

• SkillNet: Creation, Evaluation and Connection of AI Skills — Open infrastructure for reusable AI skills with multidimensional evaluation and 200,000+ skills in the repository.

• KARL: Knowledge Agents via Reinforcement Learning — Enterprise research agents trained with RL, with Pareto-optimal performance compared to Claude 4.6 and GPT 5.2.

• Memex(RL): Scaling Long-Horizon LLM Agents via Indexed Memory — Indexed memory with RL for long-horizon agents, overcoming the limits of finite context windows.

Welcome to this week’s newsletter. Lots of important news: OpenAI releases GPT-5.4 with remarkable performance, while Alibaba launches the Qwen 3.5 family with a 9-billion parameter model that beats the 120-billion open source GPT — the news of the week for models. Google responds with Gemini 3.1 Flash-Lite, focusing on speed and low costs. On the agents front, OpenClaw’s influence is felt everywhere: from Cursor automations to the thesis that MCP is dead in favor of CLIs. For AI-assisted coding, we present LINCE, our open source project, and discuss how traditional code reviews are destined to change. Finally, in business, the Anthropic-Pentagon clash evolves, OpenAI raises 110 billion dollars, and Amodei reminds us that critical thinking remains our last true advantage.

Before I leave you to read the news and my analysis of what happened this week, let me tell you what has happened, is about to happen, or will happen in my public agenda, for those who want to follow my talks or meet me in person (I love exchanging opinions with anyone who wants to):

• Podcast with Alessio and Paolo:

  • On March 12th we’ll be at JUG Milan to record our first live episode. Don’t miss it

  • On Saturday we released an episode where we talk extensively about AI coding, agents, and lots of news

  • We’re working on other interviews and episodes with very interesting guests

  • We’ve created a GitHub repository with tools and configurations for AI coding from the Linux terminal. Obviously open source, so take a look and contribute: LINCE - Linux Intelligent Native Coding Environment

• On my own:

  • I was interviewed again on the Open Source podcast. This time I talk about agents, AI, AGI. Released here on the 26th. Listen to it and send me your comments

  • On March 24th I’ll be at Voxxed Day in Zurich. Alessio and I present a talk on AI assisted coding

  • On March 25th I’ll be a speaker at this Milan meetup on Vibe Coding and Agentic Engineering

  • On May 30th I’ll have the honor of being one of the PyCon Italia speakers

But let’s start with AI research, because this week there’s also relevant news on the models front.

🧠 AI Models News and Research

Takeaways for AI Engineers

• Takeaway 1: The competition on models is played on three axes: pure performance (GPT-5.4), efficiency/cost (Gemini 3.1 Flash-Lite), and small high-performance models (Qwen 3.5). There’s no longer a single winner.

• Takeaway 2: Qwen 3.5-9B beating gpt-oss-120B demonstrates that model size matters less than architecture: Chinese open source models are redefining the performance/parameters ratio.

• Takeaway 3: NotebookLM with cinematic videos marks the shift from “AI that summarizes” to “AI that produces complete multimedia content”.

• Action Items:

• Try GPT-5.4 and Qwen 3.5-9B on a concrete task in your workflow to compare real performance and costs.

• Experiment with NotebookLM Cinematic Video Overviews to evaluate if it can replace traditional presentation tools.

What’s happening this week?

As always, lots of news in the world of models. Let’s start with the new model from OpenAI, GPT-5.4, which brings many new features and truly remarkable performance, both from what I read in benchmarks and from the first opinions I’ve seen on social media. This seems to be OpenAI’s response to the good work Anthropic is doing with its Claude models, both Opus and Sonnet. Google responds instead with Gemini 3.1 Flash-Lite, focusing mainly on speed and low costs: it’s the smallest and fastest of the Gemini 3 series. But if we’re talking about small and fast models, the absolutely news of the week — but perhaps the news of the week in general for models — is the release of Qwen 3.5 models. As always for Qwen, it’s a family of natively multimodal models with different sizes, starting from 0.8 billion parameters up to very large models, mixture of experts, with great performance. Particularly interesting is the article comparing the 9-billion version that beats the 120-billion open source GPT version in reasoning and benchmarks. A truly remarkable result for Chinese models, which comes from Qwen, which I remind you is made by Alibaba, therefore one of the world’s big tech companies and certainly the largest in China. Finally, I point out the new feature, currently in testing for only some users, of NotebookLM which, using Gemini 3 and Veo, is able to generate videos that are no longer just slide presentations but real documentaries.

This week’s links

• Introducing GPT-5.4 — GPT-5.4 with 1M token context, tool search, improved vision and 33% fewer factual errors compared to GPT-5.2.

• Deep Dive: Qwen 3.5 — Qwen 3.5 with native multimodality, 262K token context and hybrid architecture for edge deployment from 0.8B parameters.

• Gemini 3.1 Flash-Lite — The fastest and most affordable model in the Gemini 3 series, starting at $0.25/M input tokens.

• Cinematic Video Overviews in NotebookLM — NotebookLM generates cinematic videos from user sources using Gemini 3 and Veo 3.

• Qwen3.5-9B Beats gpt-oss-120B — Qwen3.5-9B surpasses gpt-oss-120B on benchmarks, available open source with Apache 2.0 license.

🤖 Agentic AI

Takeaways for AI Engineers

• Takeaway 1: OpenClaw’s influence is visible everywhere: persistent memory, goal-driven automation, and CLIs as the interface for agents are becoming dominant patterns in the industry.

• Takeaway 2: The “MCP is dead” thesis finds practical confirmation in the explosion of dedicated CLIs (Google Workspace CLI at the forefront): existing, well-documented tools beat new protocols.

• Takeaway 3: GAM demonstrates that effective agentic memory isn’t just “save everything”, but on-demand synthesis with an approach inspired by just-in-time compilation.

• Action Items:

• Explore Cursor Automations to build recurring agents in your development workflow.

• Read the GAM paper to evaluate how to apply the Memorizer/Researcher approach to memory management in your agents.

What’s happening this week?

In this week’s news about agents, it seems quite evident to see an influence from OpenClaw. Let me explain. One of OpenClaw’s characteristics was certainly having strong automation based on what it learned from memory. We find this characteristic both in Cursor automations — and here the parallel is quite strong. Cursor Automations introduces agents that run on schedules, create their own sandboxes, and especially have access to a memory tool that allows them to learn from past executions. It’s exactly the logic of the “factory that produces software” — a concept that those who follow OpenClaw will immediately recognize. We also find it in the tests that Google is doing for what they call Learning Hub, where agents learn autonomously based on defined objectives. These two things closely resemble what OpenClaw does in this area. Or at least we can say that, if it’s not a direct influence, the same forces that led to OpenClaw’s development are also leading others to do research in the same direction. Another of OpenClaw’s characteristics is using CLIs instead of MCP. In this sense, both the article that takes a strong position saying that MCP is dead and especially the release of many CLIs in recent weeks for doing the most varied things are interesting. The key point of the article is simple but powerful: LLMs are already good at figuring things out on their own, all they need is a CLI and documentation. New protocols aren’t needed when the tools already exist and work well for both humans and agents. Last but not least, the one from Google engineers to interact with all of Workspace, from Gmail to Calendar to Google Drive and everything related to Workspace. Finally, I point you to a research called General Agentic Memory via Deep Research that’s worth reading. It’s a memory framework for agents. There are several interesting ideas in this research and I invite you to read it, particularly paying attention to the approach that somewhat resembles the just-in-time compilation found in some languages, but applied to context and natural language. In practice, GAM uses two components — a Memorizer that maintains lightweight summaries and a Researcher that retrieves and synthesizes relevant information only when needed. It’s an elegant alternative to the classic “save everything in a vector store” approach that dominates today’s agentic landscape.

This week’s links

• Cursor Automations — Always-on agents on schedule or events with cloud sandbox and memory to learn from past executions.

• Google Workspace CLI — Unified CLI for all Google Workspace services, designed for humans and AI agents with 100+ skills.

• GAM: General Agentic Memory Via Deep Research — Agentic memory framework with JIT approach: Memorizer for lightweight summaries and Researcher for on-demand synthesis.

• Google Tests Learning Hub with Goal-Based Actions — Gemini “Goal Scheduled Actions”: AI autonomously adjusts tasks toward defined objectives.

• MCP Is Dead. Long Live the CLI — CLIs are more practical than MCP for humans and agents: existing, well-documented, and universal tools.

💻 AI Assisted Coding

Takeaways for AI Engineers

• Takeaway 1: LINCE demonstrates that Linux and the terminal remain the most natural environment for AI-assisted development: sandbox, backlog, and voice assistance integrated in a single session.

• Takeaway 2: Traditional code reviews are becoming the bottleneck of AI-assisted development: we need new models based on intentions and acceptance criteria, not line-by-line inspection.

• Takeaway 3: The introduction of evals in Anthropic’s skill-creator marks a paradigm shift: tested context beats reduced context for improving coding agents’ performance.

• Action Items:

• Try LINCE and contribute to the open source project with feedback, bug reports, or pull requests.

• Register for the Packt Publishing workshop on AI refactoring with ast-grep and Claude Code (March 14, 2026).

What’s happening this week?

Let’s start with something a bit self-referential but that I care a lot about. Together with the other guys from the Risorse Artificiali podcast, we started an open source project that we called LINCE, which stands for Linux Intelligent Native Coding Environment. A complicated name to make public what we use every day. In practice, we put together a series of scripts, configurations, and also some software that we developed with the help of intelligent agents to help us in our daily work as AI-assisted developers. It’s basically having an integration of Claude Code with a backlog, with a voice assistant that we called VoxCode, and with a sandbox made entirely in Linux user space. I know you’re probably thinking that many of these things already exist natively in Claude Code, but the point is that most of these don’t work or don’t work well within a Linux system. And we believe that Linux can instead be the system in which to do development within the terminal, since it’s the operating system that best integrates the terminal of all. If you want, go take a look, try it, leave us comments, feedback, open some bugs if you find any, or maybe send us some pull requests. Thanks.

One of the things we might look into is also how to automate, or better make simpler and more direct, code reviews. Because code reviews are becoming precisely the bottleneck and perhaps also one of the things that will need to be revised as the code generated by intelligent agents becomes increasingly greater. The article I propose to you, titled “How to Kill the Code Review,” is very interesting, where it discusses how the traditional code review method can become unsustainable in the AI era and how instead we could focus more on other criteria, including the acceptance of so-called development intentions. Read it, it’s worth it.

Just as it’s worth taking a look at the article that talks about the importance of having inserted evals in the creation of skills by Anthropic. As the article explains well, it’s an important paradigm shift that’s worth exploring.

Finally, I point you to a 90-minute workshop organized by Packt Publishing that covers the aspects of refactoring using AI coding. The trainer is also the author of a library called ast-grep and uses precisely the AST approach to guide Claude Code in the refactoring phase, greatly reducing regressions and making the refactoring process much more linear. I believe that mixed approaches like this can be absolutely significant for further improving the AI-assisted coding experience. I’m already registered for that workshop, if you want, take a look.

This week’s links

• How to Kill the Code Review — Traditional code reviews are unsustainable with AI: need to focus on specifications and acceptance criteria.

• LINCE - Linux Intelligent Native Coding Environment — Agentic workstation on Linux terminal with sandboxed Claude Code, task board, and voice assistance.

• Anthropic Brings Evals to Skill-Creator — Evals integrated into Anthropic’s skill-creator to automatically test and validate AI skills.

• Safely Refactor Production Codebases with AI — Workshop — Workshop (March 14, 2026) on safe refactoring with ast-grep and Claude Code on production codebases.

🏢 Business and Society

Takeaways for AI Engineers

• Takeaway 1: Amodei reiterates that critical thinking is the last true human competitive advantage, while coding becomes a commodity: a clear message about where to invest your skills.

• Takeaway 2: The Anthropic-Pentagon clash and the subsequent OpenAI-Department of War agreement raise unresolved questions: are ethical red lines real constraints or negotiating tools?

• Takeaway 3: OpenAI at $730B valuation and 900M weekly users demonstrates that the consumer AI market is now mainstream, regardless of the technical debate on models.

• Action Items:

• Read the Anthropic paper on labor market impacts to understand where AI is already changing employment dynamics in your sector.

• Watch Amodei’s full interview in Bangalore to deepen your understanding of his vision on power concentration in AI.

What’s happening this week?

By now you’ll have figured it out, when Dario Amodei speaks I certainly don’t miss his interview. A new one came out, a full interview he gave in Bangalore, where he focuses on how coding skills are in decline and how much critical thinking can be the competitive advantage to preserve for human beings. He also talks about how power concentration with AI can become an even bigger problem than it has been in the past.

And indeed, as you well know, during this period Amodei and Anthropic have taken a position regarding the U.S. Department of War and the Pentagon, withdrawing from a million-dollar agreement. This thing has had various developments: I’m reporting to you the latest response from Amodei and Anthropic regarding this clash, in which they were accused of being a risk to the national security supply chain. They give a very strong response, which you can find in the article I reported. Obviously the American Department isn’t standing still and in the meantime has made other agreements, specifically with OpenAI, who declare they have put red lines against the arguments that caused discussion and that pushed Anthropic to withdraw. Personally, it seems strange to me that Anthropic withdrew because those red lines were crossed and then the American Department of War signed an agreement with another company respecting them instead. Something doesn’t add up.

Meanwhile OpenAI continues to do its business and has raised another 110 billion dollars, reaching a valuation of 730 billion dollars: 900 million weekly active users, 50 million consumer subscribers, and 9 million business subscribers. I’d say the company is doing well anyway, despite some doubts it raised in recent months compared to competitors, who seem to have moved forward faster.

I conclude by pointing you to another paper from Anthropic that analyzes the labor market and the real impacts that AI is already having: different from what we perhaps expected a few months ago, but extremely interesting to read nonetheless.

This week’s links

• Where Things Stand with the Department of War — Anthropic responds to the designation as a national security supply chain risk, announces legal action.

• Labor Market Impacts of AI — New Anthropic framework to measure the real impacts of AI on labor markets.

• Dario Amodei — Full Interview — Full interview in Bangalore: coding in decline, critical thinking as human advantage, power concentration in AI.

• OpenAI’s Agreement with the Department of War — Classified agreement with red lines against mass surveillance, autonomous weapons, and automated decision-making.

• OpenAI Raises $110B at $730B Valuation — $110B round, 900M weekly users, 50M consumer subscribers, 9M paying business users.

In this issue of the newsletter I’m sharing a couple of strong opinions. The first is essentially captured in one of the action items from the last section:

“When you read about layoffs ‘because of AI’, always look for the follow-up statement: the business context often tells a very different story”

Obviously I’m referring to the recent 4,000 layoffs at Block and the AI washing observed around the news and the company’s announcements.

The second opinion, which comes mainly from my daily use of AI assisted coding, is that Claude Code is today the most natural choice in that field — even though Codex and others are growing their user base, they’re still several lengths behind. I’d add that the updates coming from Anthropic always seem very well thought out to improve the developer experience and performance. In my view, the reason is that even for Anthropic’s own internal development, Claude Code is the primary contributor.

Before I leave you to read the news and my analysis of what happened this week, let me tell you what has happened, is about to happen, or will happen on my public agenda — for anyone who wants to follow my talks or meet me in person (I love exchanging opinions with anyone who’s up for it):

• Podcast with Alessio and Paolo:

  • On March 12 we’ll be at the JUG in Milan to record our first live episode. Don’t miss it

  • Saturday’s episode came out — we’re back to talking extensively about AI coding, agents, and lots of news

  • We’re working on more interviews and episodes with very interesting guests

• Solo:

  • I was interviewed again on the opensource podcast. This time I talk about agents, AI, AGI. Out here on the 26th. Listen and let me know what you think

  • On March 24 I’ll be at Voxxed Day in Zurich. Alessio and I are presenting a talk on AI assisted coding

  • On March 25 I’ll be a speaker at this meetup in Milan on Vibe Coding and Agentic Engineering

  • On May 30 I’ll have the honor of being one of the PyCon Italia speakers

But let’s start with AI research, because this week too there’s relevant news on the models front.

🔬 AI Models News & Research

Takeaways for AI Engineers

• Takeaway 1: AI competition has shifted from the quantity-of-releases axis toward architectural innovation: DeepSeek V4 with Engram and Qwen3.5 with optimized MoE show that the frontier advances through efficiency, not just raw power

• Takeaway 2: Google consolidates its multi-front strategy: after Gemini 3.x on LLMs, Nano Banana 2 covers image generation with native recognition capabilities and coherence — no longer separate models but an integrated ecosystem

• Takeaway 3: Voice as a natural interface with models is an accelerating trend: tools like Wispr Flow signal a paradigm shift in human-machine interaction that goes beyond simple transcription

• Action Items:

• Test Nano Banana 2 for image generation with focus on text and coherence

• Follow the DeepSeek V4 release and the Engram architecture

What’s happening this week?

A relatively quiet week in the world of models... or almost. Sure, there are no 3 SOTA releases or 5 new Chinese model drops like in recent weeks, but there are at least a couple of very relevant things, and others that nonetheless confirm the AI landscape is still in great ferment when it comes to performance improvements (in terms of quality and power) of language models and beyond. Let’s start with the main announcement of the week: the arrival of Nano Banana 2, Google’s new image generation model. Clearly it’s part of Google’s strategy to advance their offering on all fronts — so after last week’s Gemini 3.1 announcement on the LLM side, here comes the stable diffusion model (although perhaps calling it “just” stable diffusion is limiting). What’s new? A lot: obviously great quality, especially on human figures and text, strong coherence between images and image editing capabilities. But not only that — native ability to recognize generated images, and what the creators define as “a great knowledge of the world” to generate realistic settings from simple prompts. The second noteworthy news is the release by Alibaba of the new Qwen 3.5 model family (which I already mentioned last week, but which deserves a deeper look). As always, a family of models — not just one — with impressive benchmarks across the board. In short, China’s biggest big tech is certainly not sitting still, neither watching the US nor the internal competition coming from startups like Moonshot, Z.ai, or DeepSeek. Speaking of DeepSeek, there are persistent rumors of an imminent DeepSeek V4 release. Beyond the controversy over alleged distillation using American SOTA models (honestly a bit hollow coming from those who used copyright-protected data and text to train their own models), what I want to highlight from a technical standpoint is that this would be the first model to use an Engram architecture. It would take a whole article to discuss how Engram reduces the quadratic complexity of sparse attention and therefore the VRAM usage for the KV cache — it’s beyond the scope of this newsletter. But it’s yet another confirmation of how DeepSeek is betting on innovation rather than brute force.

Let’s close with a note on a cross-cutting trend: voice interaction with PCs and models is becoming increasingly common — Wispr Flow is a concrete example. I believe this is a significant, solid, and very interesting trend.

This week’s links

• Nano Banana 2 — Google’s new image generation model: high quality on human figures and text, multi-image coherence and “world knowledge” for realistic settings.

• DeepSeek V4: Rumors vs Reality for the Next Big Coding Model — Analysis of the DeepSeek V4 rumors: Engram architecture, 1M+ token context and ~$0.27/M token pricing, in an already very competitive market.

• Anthropic: Detecting and Preventing Distillation Attacks — Anthropic reveals industrial-scale illicit distillation campaigns on Claude by DeepSeek, Moonshot and MiniMax through approximately 24,000 fraudulent accounts.

• Wispr Flow — AI voice-to-text app for any app and device, with auto-edit, 100+ language support and unlimited free access during the Android launch.

• Qwen3.5: Towards Native Multimodal Agents — Alibaba releases Qwen3.5, MoE family with 397B parameters (17B active), 256K context, 201 languages, 19× faster than Qwen3-Max, Apache 2.0 license.

🤖 Agentic AI

Takeaways for AI Engineers

• Takeaway 1: Architectural guardrails, not just in the prompt: context compression can cause critical instructions to be lost — infrastructure-level security independent of the LLM is needed

• Takeaway 2: Agent autonomy and decision-making capability are the critical variable for production success — measuring them is a priority, not optional

• Takeaway 3: Agents on human UIs: like humanoid robots, interface inefficiency is acceptable because the infrastructure already exists

• Action Items:

• Make sure your agentic guardrails are architectural, not just in the prompt

• Read the Anthropic research on agent autonomy

What’s happening this week?

Let’s start with an X post that generated a lot of buzz: Summer Yue’s. For those who don’t know her, she’s responsible for Safety & Alignment at Meta’s Superintelligence lab. The post describes how she lost control of OpenClaw, which was about to delete her entire inbox (apparently she managed to avert the disaster). Beyond the considerations about her role or about OpenClaw running amok when given too much freedom, I like to highlight that she had given an instruction in the system prompt not to do it — but (apparently due to context compression) that instruction was lost. In the end, kudos to her for posting it instead of keeping it to herself. Hopefully it will help everyone (and the enterprise world) understand that strong guardrails outside LLM control are essential when delegating potentially risky actions.

The other two links talk about agents with ever-greater capabilities, able to emulate human computer use with growing autonomy and decision-making capacity. I invite you to read the Anthropic research because this autonomy and decision-making capability are the keys to the success or failure of agents and of an agent economy.

I cited Perplexity’s new agent to show you that — just like in robotics with humanoid form factors — it’s sometimes more convenient to have agents use interfaces designed for humans, even if they’re far less efficient than machine-to-machine interfaces. Why? Simply because those UIs already exist.

This week’s links

• Anthropic Research: Measuring AI Agent Autonomy in Practice — Anthropic framework for evaluating independence and decision-making capability of AI agents in various deployment scenarios, in the context of agent safety.

• Introducing Perplexity Computer — General-purpose digital worker that unifies AI capabilities in a single system, autonomously operates human interfaces and can run for hours or months.

• Summer Yue on X — OpenClaw inbox incident — Meta Superintelligence’s Safety lead shares how OpenClaw nearly deleted her inbox: 9.8 million views, a practical lesson on agentic guardrails.

💻 AI Assisted Coding

Takeaways for AI Engineers

• Takeaway 1: The duration of a successfully completed autonomous task is a fundamental KPI for measuring agent maturity: Codex’s 25 hours and Cursor’s 30% autonomous PRs are the new reference benchmarks

• Takeaway 2: Claude Code’s auto-memory is the most pragmatic form of vertical continuous learning available today: imperfect but conceptually powerful — it turns every session into persistent experience

• Takeaway 3: Security of AI-generated code is becoming a specialization in its own right: agents like Claude Code Security Research are not optional but necessary infrastructure in a world where code is increasingly generated

• Action Items:

• Set up and experiment with Claude Code auto-memory on your main project

• Read Thariq’s article on how to model the action space of agents

What’s happening this week?

Lots of news in what has been the most active category of recent months: AI assisted coding. Let’s start with the evolution of autonomous agents at Cursor and OpenAI. The former declare that around 30% of their PRs now come from autonomous agents with minimal human intervention. The latter report an impressive task completed by Codex in around 25 hours of work: as I’ve said many times, the length of an autonomous task successfully completed is one of the fundamental parameters for evaluating the evolution of agents.

As for the news, Claude Code dominates this space, as it has for the past several months. The pace of innovation at Anthropic for AI Engineers is genuinely hard to keep up with, but this week’s updates deserve a deeper look. The concept of auto-memory — where Claude understands what happened during a session and what might be meaningful as long-term memory — is a powerful concept. Probably still imperfect, but it’s as close as we can get to a lightweight form of continuous learning, at least within a specific vertical. Security is a fundamental theme in a world where much of the code is generated, and so specialized agents like “Claude Code Security Research” will become essential support for developers and a helpful tool for those primarily focused on security.

I’ll close by mentioning the interesting article from one of Claude Code’s creators, who teaches us how to model our workflows and skills to optimize human-machine interaction — and the article that attempts to explain why Claude is today the primary choice among coding agents for the vast majority of AI engineers (even though Codex has announced significant user growth, it remains a considerable distance behind).

This week’s links

• Claude Code Security Research Preview — Anthropic launches an AI preview to identify code vulnerabilities the way human security researchers would, with multi-stage verification, severity rating and mandatory developer approval.

• GPT-5 Codex: 25-Hour Coding Sprint — GPT-5.3-Codex autonomously completes a 25-hour project, generating ~30,000 lines of code with structured markdown memory and quality verification at every milestone.

• Why Developers Keep Choosing Claude Over Every Other AI — Analysis of why Claude Code is the primary choice: editing without corrupting surrounding code, reading the right files before making changes, multi-step tasks without losing the thread.

• Claude Code Auto-Memory — Claude autonomously saves context between sessions: CLAUDE.md for user instructions, MEMORY.md a notebook Claude updates on its own every session.

• Lessons from Building Claude Code: Seeing like an Agent — Framework for modeling agent action space: tools calibrated to model capabilities, strategic use of AskUserQuestion, choice between generic vs. specialized tools.

• Cursor Agent Computer Use — Cursor launches cloud agents in isolated VMs: over 30% of internal PRs now created autonomously by agents, with video monitoring and remote desktop control.

🏢 Business & Society

Takeaways for AI Engineers

• Takeaway 1: The “AI washing” phenomenon in layoffs is real and must be recognized: when a stock jumps 20% on announcements of cuts “because of AI” while the CEO admits post-COVID disorganized growth, the warning signs are clear

• Takeaway 2: Amodei’s stance on the Department of Defense is a rare case of ethical consistency in AI: declining a government contract on principle, in an industry where economic pressure is enormous, deserves attention as a model

• Takeaway 3: The arrival of Apple smart glasses would mark a turning point in consumer adoption of embodied AI: the Liquid Glass UI has long suggested Apple was preparing for this form factor

• Action Items:

• When you read about layoffs “because of AI”, always look for the follow-up statement: the business context often tells a very different story

• Follow Apple’s smart glasses announcements: they could redefine the consumer AI wearable market

What’s happening this week?

You can’t start anywhere but the Block layoffs. 40% of employees, about 4,000. Announced internally and on X, citing AI as the reason. And the stock jumps over +20% in a period that’s been terrible for the entire US market. If that’s not AI washing... and indeed Dorsey himself admits in a follow-up post (after market close) that Block had grown too fast and in a disorganized way during COVID. To which one should add considerations about the online payments market (Block’s main business) which is clearly struggling.

Let me be clear: I’m certainly not someone who denies AI’s impact on society and work — just read the newsletter from two weeks ago to understand how concerned I am and how fundamentally important I think it is not to be caught unprepared by this revolution. But I also say that it’s easier, more convenient, and more profitable on the stock market to blame AI rather than bad business decisions.

A very different kind of story is the strong stance taken by Anthropic and its CEO Dario Amodei on the use of Claude by the US Department of Defense. Consistent and principled. I liked it a lot... though I’m quite sure the Department of Defense will soon find another supplier — in fact, it already has in OpenAI... hopefully respecting the guardrails that Altman claims he has guaranteed, even if I imagine they’re a bit softer than those Amodei set, which is what caused the previous deal to fall through.

I’ll close with a very different kind of news: the rumors about Apple smart glasses. Honestly, ever since I saw the fully transparent “Liquid Glass” UI, I’ve been saying it’s screaming “glasses!!”

This week’s links

• Statement from Dario Amodei on discussions with the Department of War — Amodei refuses the US Department of Defense’s conditions on mass surveillance and autonomous weapons, maintaining Anthropic’s ethical safeguards despite the pressure.

• Jack Dorsey announces Block layoffs — Dorsey announces the layoff of 40% of Block’s workforce (~4,000 people), attributing it to AI and new work models with leaner teams.

• Jack Dorsey — follow-up post — In a follow-up post (after market close), Dorsey admits that Block had grown too fast and in a disorganized way during the COVID period.

• Apple AI Smart Glasses — Apple accelerates development of AI smart glasses with two integrated cameras, aiming to compete with Meta Ray-Bans in the emerging AI wearable market.

🔗 Learn more about me, my work, and how to connect: maeste.it – personal bio, projects, and social links.

This week I want to start with what I’ve been observing lately on social media. Calling it out probably won’t make me new friends, but I believe what’s happening in the world of software engineers (and related fields) is quite evident. There was a first phase, which I’d place roughly until Christmas, where the majority of software “insiders” were posting things like: “AI can’t replace a good engineer, it makes too many errors,” “Show me something that isn’t just a demo in a PR,” “Come on, AI can only write boilerplate code.” Pure denial. Now we’re in a second phase with posts like: “If AI gives us more speed, can someone explain why I’m working twice as hard,” “AI isn’t taking our jobs, it’s actually making them messier,” “We all need to become software architects, we were supposed to work less but they’re asking even more of us.” Take a look at the well-known Kübler-Ross change acceptance curve I’m showing below... and brace yourselves for the depression phase...

Before I let you dive into the news and my analysis of what happened this week, let me share what’s happened, is about to happen, or will happen in my public agenda, for those who’d like to follow my talks or meet me in person (I love exchanging ideas with anyone willing to do so):

• Podcast with Alessio and Paolo:

  • Wednesday we released an interview with Daniele Zonca on AI in the enterprise world

  • Saturday an old friend, Antonello Mantuano, came by for an interesting chat

  • On March 12th we’ll be at JUG Milano to record our first live episode. Don’t miss it

  • We’re working on more interviews and episodes with very interesting guests

• Solo

  • I was interviewed again on the opensource podcast. This time I talk about agents, AI, AGI. It drops here on the 26th. Listen to it and let me have your feedback

  • On February 26th I’ll be at this event in Milan (as an attendee, but happy to exchange ideas). Beyond my presence, the event itself is worth following

  • On March 24th I’ll be at Voxxed Day in Zurich. Alessio and I are presenting a talk on AI assisted coding

  • On May 30th I’ll have the honor of being one of the PyCon Italia speakers

🤖 AI Models News and Research

Takeaways for AI Engineers

• Takeaway 1: Sonnet 4.6 costs less per token than Opus 4.5 but uses ~2.5x more: smaller models compensate with more reasoning, and the real price/performance comparison is less linear than it seems.

• Takeaway 2: Google’s entry with Lyria 3 into generative music confirms this market is already concrete and consolidating, following Suno and other pioneers.

• Takeaway 3: Model competition is global and multimodal: Gemini 3.1 Pro (reasoning), Qwen 3.5 (vision, 201 languages), PersonaPlex (real-time voice) — the frontier advances on multiple axes simultaneously.

• Action Items:

• Compare the real TCO of Sonnet 4.6 vs Opus 4.5 in your use cases, considering total token consumption.

• Experiment with PersonaPlex for voice interaction with coding agents on Linux/open source.

What’s happening this week?

Another new model in Google’s Gemini family: with Lyria 3, Big Blue enters the AI-generated music market too, and does so in grand style and with great power as usual. And it’s far from a minor market — since the early deals with Suno and other platforms, it’s already moving a lot of money. The same will probably happen with video productions, but AI-generated music is already a reality now.

But the most relevant release in the Gemini household is Gemini Pro 3.1, which shouldn’t be confused with Gemini 3.0 Deep Think from last week: it’s a new version of the model for all subscribers. And it significantly improves results across all benchmarks, most notably a doubled score on ARC-AGI-2.

Anthropic also announces an important release with Sonnet 4.6 which, according to Anthropic’s benchmarks and internal reports, matches — or nearly matches — Opus 4.5 at a much lower per-token price. But to do so it uses many more tokens (estimated 2.5x), so on one hand the total cost is indeed lower than Opus 4.5 but not dramatically so, and on the other hand it suggests that smaller SOTA models achieve higher performance with more reasoning. Not unexpected, but an interesting indirect confirmation.

The Chinese are far from standing still either, with Qwen publishing version 3.5 of their flagship model. Natively multimodal, with an interesting hybrid architecture and support for a remarkable 201 languages. Also interesting is DuckDuckGo’s entry into the AI market, bringing their privacy policy to image generation as well.

I also want to highlight with great interest NVIDIA’s conversational speech-to-speech model. I’ll spend a few hours on it soon to see if it can help bring voice interaction with agents (coding and otherwise) to the open source world (Linux in particular), which is very dear to me.

Links of the week

• Gemini 3.1 Pro — Google releases Gemini 3.1 Pro with doubled ARC-AGI-2 score, significant advancement in abstract reasoning.

• DuckDuckGo AI Image Editing — Privacy-first AI image editing on Duck.ai, no account required and no data storage.

• Gemini Lyria 3 — AI music generation integrated into the Gemini app: 30-second tracks from text or images.

• Claude Sonnet 4.6 — Anthropic releases Sonnet 4.6 with 1M token context window, preferred over Opus 4.5 in 59% of cases.

• Qwen3.5 — Vision-language model with 397B parameters (17B active), hybrid architecture and support for 201 languages.

• PersonaPlex — NVIDIA real-time full-duplex speech-to-speech model for interactive voice conversations.

🕸️ Agentic AI

Takeaways for AI Engineers

• Takeaway 1: AI agent security is an architectural problem, not solvable with prompt-based safeguards alone: sandboxing, granular permissions, and dedicated logging are needed.

• Takeaway 2: Harness engineering is emerging as an evolution of prompt and context engineering: changing data, tools, MCP, and skills can have more impact on agent performance than changing the model itself.

• Takeaway 3: Agent autonomy is growing steadily and expert users are shifting from approving individual actions to strategic monitoring — a paradigm shift in human-agent interaction.

• Action Items:

• Review the security architecture of your agents: verify sandboxing, permission scope, and logging of autonomous actions.

• Experiment with harness engineering: modify your agents’ tools, data, and context before changing the model to improve results.

What’s happening this week?

Let’s start with something we discussed last week. The creator of OpenClaw has decided to join OpenAI. I’m confident that with the company’s support, he’ll bring more disruptive ideas to this young market. I strongly hope his work can continue in the community as well, because one of the most interesting aspects of OpenClaw was bringing Open Source back to the center of the debate.

Two main themes I want to highlight with the links in this section. The first concerns a growing attention to agent security, with architectural problems to address and best practices to explain and instill in developers and users. Security has always been a topic as central as it is neglected, and with generative AI it becomes even more important to understand the risks and how to mitigate them.

The second theme is measuring agent results and autonomy, from OpenAI and Anthropic benchmarks to those showing how changing the harness (i.e., everything used to extend an LLM: data, tools, MCP, skills, etc.) can change agent results. Keep the word harness in mind, because harness engineering is increasingly being discussed as an evolution of context engineering and prompt engineering.

Links of the week

• Secure Sandboxing for Local Agents — Cursor reduces agent interruptions by 40% with native per-platform sandboxing (Seatbelt, Landlock, WSL2).

• Harness Engineering for Deep Agents — LangChain’s coding agent jumped from Top 30 to Top 5 on Terminal Bench 2.0 with a single harness change.

• EVMbench — OpenAI benchmark for evaluating AI agents on smart contract vulnerabilities, both defensive and offensive use.

• OpenClaw creator joins OpenAI — OpenClaw’s creator joins OpenAI; the project remains open and independent within a new foundation.

• The problem isn’t OpenClaw. It’s the architecture. — OpenClaw’s vulnerabilities reveal structural risks in agent ecosystems: sandboxing and restricted permissions are needed.

• Measuring AI Agent Autonomy — Anthropic analyzes millions of human-agent interactions: growing autonomy, users shifting toward strategic monitoring.

💻 AI Assisted Coding

Takeaways for AI Engineers

• Takeaway 1: Open source in the era of AI agents is transforming: the value is no longer just in code written, but in the ability to translate ideas into software — and AI amplifies this capability.

• Takeaway 2: Configuring coding agents (CLAUDE.md, skills, workflows) is becoming a key competency: well-structured files and the “less is more” principle make the difference in output quality.

• Action Items:

• Review and optimize your CLAUDE.md (or AGENT.md) following the “less is more” principle: fewer instructions, more targeted.

• Explore Anthropic’s official guide on skills to create reusable workflows in your coding agents.

What’s happening this week?

Let’s start with an article from one of the founders of Hugging Face on how open source is changing in the era of agentic engineering. And it’s changing from so many perspectives that it’s worth exploring in the article. I’ll just leave you with a reflection I also shared on X about how much developer ego used to matter. But on the other hand, I think open source developers (and their ego) manifest more in putting ideas into code — sometimes brilliant ones — and AI can only help with that.

Other noteworthy articles for those doing AI Engineering this week come from Anthropic with their guide to creating skills (not a brand new article, but I believe I’ve never flagged it) and an interesting article on how to better write your CLAUDE.md (or AGENT.md) files.

Take a look at the other articles too, especially if you want to make the most of your OpenRouter subscription or experiment with next-generation vector databases.

Links of the week

• How Open Source Changes in the Agentic Coding Era — Reflection on the transformation of open source when AI agents autonomously contribute to code.

• ZVEC — Alibaba’s in-process vector database, lightweight and fast, for similarity searches without external dependencies.

• Free Models Router — OpenRouter meta-router that randomly selects among free models, useful for prototyping and testing.

• Complete Guide to Building Skills for Claude — Anthropic’s official guide to creating reusable skills for Claude agents, “tiny CLI” pattern.

• CLAUDE.md Masterclass — Complete guide on optimizing CLAUDE.md files for Claude Code, “less is more” principle.

🏢 Business and Society

Takeaways for AI Engineers

• Takeaway 1: AI as an exoskeleton doesn’t just enhance — it enables previously unthinkable work. The metaphor goes beyond simple amplification and redefines what’s possible.

• Takeaway 2: GPT-5.2 deriving an original result in theoretical physics is a concrete signal: AI is already generating new scientific knowledge, regardless of AGI timelines.

• Takeaway 3: Choosing AI today is no longer about choosing a model: Mollick’s framework (Models, Apps, Harness) helps navigate an increasingly layered ecosystem.

• Action Items:

• Read Mollick’s article and evaluate which layer (Models, Apps, Harness) has the most impact on your current workflow.

• Reflect on how AI is transforming your work: are you just enhancing existing tasks or enabling previously unthinkable activities?

What’s happening this week?

After last week’s strong stance on AGI, its timelines and its impacts, in this section I deliberately sought to bring different perspectives and reflections on what could be opposing viewpoints. So here you’ll find links about significant advances in using AI for scientific research (theoretical physics), but also those who theorize that AGI is distant. The viewpoint I prefer is that of those who compare it to an exoskeleton, a way to enhance those who use it, although even on this there would need to be a very clear distinction about what exactly is meant to avoid being misunderstood. My vision is precisely that of the exoskeleton that not only enhances but enables previously unthinkable work or completely transforms the perception of those who use it.

Also interesting is Ethan Mollick’s article to help choose the right tools in this transformative moment.

Links of the week

• A Guide to Which AI to Use in the Agentic Era — Ethan Mollick proposes a 3-layer framework (Models, Apps, Harness) for navigating AI tool selection.

• Why I don’t think AGI is imminent — Current Transformers have fundamental architectural limitations; AGI will likely require radically different approaches.

• GPT-5.2 Derives a New Result in Theoretical Physics — GPT-5.2 Pro proposes a new formula for gluon scattering amplitudes, verified by physicists from IAS, Harvard, and Cambridge.

• Stop Thinking of AI as a Coworker. It’s an Exoskeleton — AI as an amplifier of human capabilities, not a replacement: the exoskeleton model is more realistic and productive.

• ByteDance Building Out AI Team in US — ByteDance hiring nearly 100 employees for its AI division in the US, spanning research and content generation.

🔗 Learn more about me, my work, and how to connect: maeste.it – personal bio, projects, and social links.