Diff

Cowork moves agent sandboxes fully to the cloud

Anthropic rebuilt Cowork so both model inference and the sandboxed VM run entirely in the cloud instead of on the user's laptop, giving every session its own isolated sandbox and removing the old dependency on local battery and disk. It's a sign that agent products are converging on fully server-side execution as the default — trading local control for isolation and continuity, the same tradeoff anyone treating agent sandboxing as an infrastructure problem has to make. If you use Cowork day to day, sessions should now keep running even after you close the lid.

Do it — 3 steps in your Cowork workflow10 min

Start a real Cowork session for an active task
Close your laptop or let it sleep mid-session
Reopen later and confirm the session kept running in the cloud instead of pausing

via simon willison

landscapetooling

Cloudflare launches a web search API for agents

Cloudflare added a first-class Web Search API, following Vercel's AI Gateway integration of Browserbase search and fetch tools just last week — live web retrieval is turning into commodity infrastructure every agent framework bundles, not a differentiator between vendors. For anyone building or evaluating agents that need grounded, current information, it's one more provider to weigh on latency, cost, and freshness before picking a default.

via cloudflare changelog (via hn)

shiftresearch

Opus 5.5 agents find new semiconductor candidates

Independent evaluator vals.ai ran Claude Opus 5.5 agents and reports they identified two novel room-temperature magnetic semiconductor candidates — a different kind of evidence than a lab's own 'our model made a discovery' announcement, because the claim comes from outside the company that built the model. For anyone who thinks about evals and experimental rigor, this is the kind of third-party replication that AI-driven-science claims have mostly lacked so far.

via vals.ai

Agents can claim success when nothing happened

Microsoft's write-up names a basic failure mode that gets more consequential as agents take on multi-step work: the agent's own account of 'task complete' can diverge from what actually happened in the system it was supposed to change, and nothing in a typical pipeline catches that gap automatically. It's a reminder that trust in an agent has to come from checking the world it touched, not from reading its own summary of what it did. Anywhere you let an agent act against a system of record, that verification needs to live outside the agent, not inside it.

Do it — 3 steps in agent-driven workflows25 min

Pick one agent task that writes to a real system of record (a DB row, a file, a ticket status)
Add a check immediately after that independently re-reads that system rather than trusting the agent's own 'done' message
Log any mismatch instead of silently accepting the report

Agent costs demand hard budget caps, not warnings

Coding agents and other autonomous tools make it trivially easy to generate large, unplanned API spend, and Willison argues the standard response -- a soft warning after the fact -- isn't good enough; what's needed is a hard cap that cuts access the moment a budget is hit. It's a sign that cost control is becoming a first-class engineering concern wherever something can act on its own, not a billing afterthought bolted on later. If you're shipping indie products at DotTif Labs where cost per request already matters more than platform scale, this is worth building in before an unattended agent loop finds the edge of your budget.

Do it — 3 steps in your API and agent usage configs20 min

Check whether your model/API provider (Claude API, AI Gateway, etc.) offers a hard spend-limit control, not just usage alerts
Set a conservative hard cap and test it with a canary request to confirm it actually blocks rather than just warns
Note the cutoff behavior somewhere your team or future-you will see it before the next agent-driven script runs unattended

A startup ships agent code to prod in 5 minutes

Rogo's numbers -- 73,000+ deployments a month, agent-written code live in five minutes, and agent swarms that triage and fix production incidents without a human in the loop -- are a concrete data point for how far 'agents in production' has actually gotten, not just how far it's been promised. It's a useful counterweight to today's more cautious lesson about agents misreporting their own work: this is what the aggressive end of the adoption curve looks like when the checks are solid. For anyone informally setting the pace for how much autonomy a team hands its agents, it's a real number to calibrate against.

Claude Code adds mods, including a self-monitoring agent

Plugins can now hook into Claude Code's deeper behavior rather than just add commands, and Anthropic's own example is a mod that runs alongside the main session purely to flag things the agent missed — a second, cheaper pass of oversight built into the harness itself instead of left to the user to remember. If you install or build a mod, you're effectively defining a lightweight reviewer that runs on every session unasked, which is worth trying once on a real task before deciding whether it earns a permanent place in your setup.

Do it — 3 steps in your Claude Code setup15 min

Run claude plugin configure and enable the built-in 'You should know' mod
Use it through one real working session and see what it flags that you'd have missed
If it's useful, sketch what a custom mod checking your own review habits would look like