This week
Suggest a nameObligation Marketing for AI Builders
The 7-Rung LadderThe 8-Type TaxonomyWrapper or WinnerThe Sample ColumnThe Signal
Updated through the day. Every headline links straight to the source. The two lines underneath are ours.
Long-running task reliability is the actual constraint on agentic coding right now, more than raw model reasoning. This is the kind of infrastructure detail that determines whether an agent can survive a multi-hour build session without drifting or losing state. Worth reading closely if you're building or evaluating agent harnesses rather than just calling an API.
Mollick's synthesis pieces tend to age well because he tracks actual usage patterns rather than lab press releases, so this is worth the ten minutes even without a single new fact. The value is in the framing of where the gap between demoed capability and deployed capability actually sits right now. Read it as a checkpoint for recalibrating your own roadmap assumptions, not as breaking news.
This is Anthropic being transparent about a real measurement problem: models that know they're being tested may behave differently than in deployment, which undermines the benchmarks builders rely on. If you're using BrowseComp-style scores to pick a model for a browsing agent, treat the numbers as a ceiling, not a guarantee. Worth reading if you build eval pipelines internally, since the same awareness effect likely applies to your own tests.
Mollick's guides are consistently the most useful plain-language mapping of the fragmented model landscape to actual jobs to be done, which matters now that picking a model means picking an agent stack, not just a chat window. For builders juggling Claude, GPT, and Gemini agents across different tasks, this is worth the ten minutes. Use it as a starting checklist, then verify against your own latency and cost constraints.
This is the unglamorous but important work of making coding evals actually measure what they claim to measure, since flaky infrastructure can silently swing scores as much as model quality does. If your team runs internal agentic coding benchmarks, this is a checklist for what to control before trusting your numbers. Small audience, real value for anyone building eval infrastructure.
This is a concrete demonstration of multi-agent orchestration on a hard, well-specified engineering task, which is a better test of agentic reliability than most demo benchmarks. If you're evaluating whether parallel agent teams can handle real compiler-grade complexity, this writeup is a useful reference architecture. Read it for the coordination patterns, not the compiler itself.
As agents take on more delegated work, the scarce skill shifts from prompting to something closer to managing a team, setting goals, checking outputs, and knowing when to intervene. This is a useful reframe for founders building agent-heavy workflows: the bottleneck moves from model capability to human oversight design. Worth reading if you're structuring how your team supervises autonomous agents day to day.
Interactive tool calls suggest Claude's UI is moving toward live, manipulable outputs rather than static text responses. Worth a quick watch if you're building on the API, but it's a product demo, not a capability shift you need to react to today.
This is a practical problem for anyone hiring engineers or running certifications now that candidates have AI in every tab. Anthropic's own approach is worth reading if you're rebuilding hiring pipelines or coding assessments, since the same tricks that beat their evals will beat yours.
This is the real story: Anthropic is taking the Claude Code interaction model, an agent that plans, executes, and iterates with minimal hand-holding, and pointing it at spreadsheets, docs, and ops work instead of just code. If Cowork ships with the reliability Claude Code has in dev workflows, it's a direct shot at the broader agentic-assistant market that Copilot and Gemini are also chasing. Builders should test it against their actual non-coding workflows now, before competitors standardize on it.
Agent evals are still an unsolved, contested practice, and most teams are copying eval patterns built for single-turn chat models onto multi-step agents where they don't fit. This is a decent primer to hand to a new team building agent QA, but it's guidance, not a benchmark or new tooling. Read it before you build your next eval harness rather than after.
Mollick is one of the more reliable translators of what's actually changed in agent capability versus what's marketing, and this piece frames Claude Code as evidence that tool-equipped agents cross a real usefulness threshold when given the right scaffolding. The practical takeaway for builders: the bottleneck has shifted from model quality to tooling and permissions, so audit what your agents are allowed to touch before assuming they need a better model.
The jaggedness framing is useful shorthand for why AI progress feels inconsistent: certain narrow capabilities leap forward while adjacent ones stay flat, and Nano Banana Pro apparently cleared a bottleneck that made a previously marginal use case suddenly viable. For builders, the actionable move is to re-test tasks you'd previously written off every few months rather than assuming last quarter's limitation still holds.
Browser control is table stakes now that OpenAI, Google, and Anthropic are all racing to ship computer-use agents. The question is reliability on real sites with logins, captchas, and dynamic layouts, not the demo. Worth testing against your actual workflows before trusting it with anything unsupervised.
This is the unglamorous infrastructure work that determines whether agents actually survive production, state management, checkpointing, recovery from partial failure. If you're running agents beyond single-session tasks, this is more useful than another benchmark post. Read it before you build your own harness from scratch.
Tool use quality is the actual bottleneck for agent reliability, not raw reasoning, so platform-level improvements here matter more than they sound. If you've shelved agent projects because tool-calling was flaky, this is worth a re-test. For builders on Claude specifically, this closes gap with competitors who've had more mature function-calling stacks.
Mollick is one of the more reliable synthesizers of where the field actually moved versus where the hype pointed. The agent framing is now consensus, so the value here is less the thesis and more his read on pacing and what's still missing for reliable deployment. Worth a skim for the framing you'll reuse in your own pitch decks.
Combining MCP with code execution is a meaningful efficiency play, letting agents write and run code instead of chaining tool calls one at a time, which cuts latency and token cost. If you're running MCP-based agents at any scale, this pattern is worth adopting directly. It also signals where Anthropic sees MCP heading: less a protocol curiosity, more core infrastructure.
Permission fatigue is the main reason developers keep Claude Code on a short leash, so real sandboxing that lets it act more autonomously without constant approval is a genuine unlock. This matters for anyone running Claude Code in CI or unattended workflows where a human isn't there to click approve. Worth testing against your current guardrails before you loosen them.
These roundups are useful precisely because Mollick tests broadly and isn't selling anything, so his picks carry more signal than typical listicles. Treat it as a checkpoint to sanity-check your own stack rather than gospel, since the field moves faster than any static recommendation. Good for onboarding new team members quickly.
Skills as a packaging concept matters because it's Anthropic's answer to the plugin and tool-sprawl problem that's plagued agent frameworks industry-wide. If this gets traction, it becomes a distribution layer, third parties building and shipping Skills the way they once shipped ChatGPT plugins. Watch adoption numbers over the next two quarters rather than the launch post itself.
Mollick's framing of 'infinite PowerPoints' captures the core problem with agent demos: volume of output isn't the same as useful output. Worth reading for the framing more than any new data, since it's an argument piece rather than a benchmark. Builders should treat it as a prompt to audit whether their agent's output is actually being used, not just generated.
This is Anthropic writing down the operational lessons from building Claude-based agents at scale, which means it's less theory and more field manual. Context management is the unglamorous bottleneck that determines whether an agent pipeline is reliable or flaky in production. Any team running multi-step Claude agents should treat this as a checklist against their own architecture.
Using agents to write and test their own tool interfaces is a practical loop that closes a real gap: most tool-calling failures trace back to badly specified tool schemas, not model weakness. This is directly actionable for anyone building on Claude's tool-use API today. Expect this pattern, agent-assisted tool design, to become standard practice rather than a novelty.
Mollick is one of the few commentators worth reading on how model behavior actually shifts workflows, and his framing of GPT-5 as an agent that 'just does stuff' captures a real usability change. The take for builders: if your product still treats the model as a chat oracle instead of a task executor, you're behind the interaction pattern users now expect. Worth reading for the behavioral observation, not the benchmark claims.
The thesis that robotics is becoming a data problem is not new, but SemiAnalysis usually backs it with numbers on compute and deployment economics that make it actionable. Worth a skim for investors scouting the physical AI category before the next funding wave prices it in. Builders in robotics should treat this as a checklist of where the industry actually stands, not a hype piece.
This lowers the friction for non-technical users to extend Claude Desktop with MCP tools, which matters for adoption more than for capability. It's a packaging improvement, not a new capability, but packaging is often what determines whether MCP servers actually get used outside developer circles. Worth a quick look if you maintain an MCP server and want easier distribution to end users.
This is a rare direct look at how Anthropic structures orchestration, subagent delegation, and evaluation for a production multi-agent system, which is more useful than most third-party agent frameworks published this year. If you're building anything with multiple Claude agents coordinating on a task, this is closer to a reference architecture than a blog post. Worth implementing patterns from directly rather than reinventing coordination logic from scratch.
This is a synthesis piece from one of the more rigorous voices in AI research, mapping the mechanisms behind why letting models think longer actually helps. For builders tuning reasoning-heavy pipelines, it's a useful primer on when test-time compute is worth the latency and cost, not just a trend to chase. Read it before you decide whether your product needs a reasoning model or just better prompting.
This is Anthropic writing the playbook for its own tool, which matters because Claude Code adoption is growing fast among professional developers. If you're already running agentic coding workflows on Claude, treat this as the closest thing to an official spec for what actually works in production. Worth a direct read for anyone past the demo stage with coding agents.