Wednesday, 1 July 2026

The real shift happening right now isn't in model scale or benchmark scores — it's in *what these models are allowed to do*. We're watching AI move from reading to acting, and the security implications are forcing us to grow up fast.

Start with Anthropic's Claude Science. On the surface, it looks like a natural extension of Claude Code — a specialized tool for researchers and pharma companies to accelerate discovery work. But what actually matters is the precedent. By carving out domain-specific versions of foundational models, Anthropic is implicitly admitting that one-size-fits-all AI doesn't cut it anymore. The same reasoning applies across life sciences, coding, and soon everywhere else. This fragmentation isn't a weakness; it's a feature. It means better safety boundaries, clearer accountability, and models trained on relevant data.

More interesting to me, though, is what happens when these models become agents. Anthropic's Claude Sonnet 5 can now plan, use browsers and terminals, and run autonomously. JetBrains is integrating this directly into its IDE. These aren't toys — millions of developers will use them. The problem is that autonomous action introduces a new attack surface. Microsoft's recent research on MCP tool poisoning shows exactly what I mean: if you can manipulate a tool description, you can trick an AI agent into leaking data or executing malicious commands on a user's behalf. The agent doesn't even need to be compromised; the *tools around it* become the vulnerability.

By the way, this is where the conversation about what agentic AI *is* versus what we *want it to be* becomes urgent. Phillip Isola's framing of the question is worth sitting with — we're not just deploying agents, we're deciding what constraints and affordances they should have. That's a governance question, not a technical one.

The other angle that caught my attention is infrastructure. DeepSeek's DSpark framework achieves an 85 percent speedup in LLM inference, and Meituan just released what China claims is its largest domestically-trained model on local chips. These aren't isolated technical improvements; they're part of a longer game around computational independence and cost efficiency. Faster inference and cheaper training matter because they democratize capability. When your model runs at a tenth of the cost, you can afford to deploy it more widely, iterate faster, and let more people build on top of it.

The common thread across all of this is constraint and capability growing in parallel. We're building faster inference, domain-specific tools, and autonomous agents all at once. That's powerful, but it means the surface area for failure — whether through accident or malice — expands too. The question isn't whether we should deploy these systems; it's whether we're building the guardrails as fast as we're building the systems themselves.