AI Engineering.Turning AI prototypes into production systems.
AI engineering is the discipline that sits between "the model can do this" and "this runs in production for paying users." It is mostly the un-glamorous parts — tool registries, exit conditions, retries, eval suites, observability — that decide whether your agent works on day 30, not just day one.
The patterns I broke in 2025 and what replaced them
Supervisor patterns gave way to handoffs. Inline tool descriptions gave way to externalised, per-tool selection criteria. "Use this when…" beat "this function returns…" every time. JSON mode replaced bespoke parsers. RAG-by-default got replaced by a measure-then-decide framework. These are the moves that separate engineering from improv.
Tool design as a first-class concern
When an agent picks the wrong tool, the registry is broken — not the agent. Three rules: name tools precisely, describe when to use each one, load only what the task needs. Anthropic's tool-use telemetry finally puts numbers on what changes accuracy.
Cost discipline is design, not optimisation
The cheapest LLM call is the one you do not make. Pre-agentic data fetching, prompt caching, and registry pruning compound into 30–60% cost reductions on real workflows — before you touch a prompt. Cost is not a post-launch concern; it is a design constraint from day one.
Deep dives on AI Engineering
November 19 agent guide: Genie 4 API and Claude Code 2.1.328
November 19, 2026 opened interactive world models to developers and extended Claude Code auto mode across cloud gateways. Google documented Genie 4 on the Gemini Interactions API, and Claude Code 2.1.328 to 2.1.329 added auto mode for Opus/Sonnet 4.6 on Bedrock, Google Agent Platform, Foundry, and gateways.
November 18 agent guide: Gemini 4 Neon and VS Code 1.147 agents
November 18, 2026 filled the Gemini 4 mid-tier and upgraded VS Code’s agent host. Google released Gemini 4 Neon for long coding and knowledge-work agents, and VS Code 1.147 added Browser Use preview, experimental model routers, and Send Later scheduling.
November 16 agent guide: Qwen4-Max GA and Claude Code 2.1.326
November 16, 2026 upgraded Chinese flagship routing and multi-agent coding. Alibaba released Qwen4-Max for general API use five days after the Token Plan preview, and Claude Code 2.1.326 unlocked Code Mode alongside agent teams.
November 13 agent guide: Sierra Poppy 1.0 and ChatGPT Wallet
November 13, 2026 opened agent commerce and personal-agent identity at protocol scale. Sierra released Personal Agent Protocol 1.0 (Poppy) with Shopify live for every merchant, and OpenAI introduced ChatGPT Wallet so agents can pay without sharing raw card numbers.
November 12 agent guide: Gemini 4 Hydrogen, Inkling weights, SGLang
November 12, 2026 closed the window with a broad Gemini 4 worker, an Apache 2.0 open-weight drop, and an inference consortium. Google released Gemini 4 Hydrogen, Thinking Machines published Inkling 2 Small weights, LMSYS launched the SGLang Consortium, and Claude Code 2.1.323 added experimental Code Mode.
November 11 agent guide: Gemini Decisions API and Qwen4-Max Preview
November 11, 2026 advanced agent control planes and Chinese flagship previews. Google launched the Gemini Decisions API powered by Gemini Decision 1, Alibaba opened Qwen4-Max Preview on Token Plan only, and xAI pushed Grok Bot 1.0 Team Bots into Slack and Microsoft Teams.
November 10 agent guide: Gemini Robotics 2.5 and OpenShell
November 10, 2026 moved agentics into factories and Kubernetes. Google DeepMind released Gemini Robotics 2.5 for partner robots, and NVIDIA contributed OpenShell to the CNCF as a sandbox project for securing autonomous agents.
November 6 agent guide: Claude Code 2.1.319 and agent memory
November 6, 2026 advanced Claude’s agent control plane and its memory research at the same time. Claude Code 2.1.319 backgrounds MCP tasks and adds denyInsteadOfPrompting, while Anthropic’s engineering post explains notes, dreaming, and salience for long-horizon agents.
November 5 agent guide: GPT-6 Cyber and Cursor Live Apps
November 5, 2026 paired a restricted cybersecurity agent with a mainstream agent product move. OpenAI introduced GPT-6 Cyber for approved Daybreak Red defenders, and Cursor launched Live Apps so cloud agents can scaffold, host, and share working internal tools.
November 4 agent guide: Kimi K3.1 Pro weights and Tencent Hy4
November 4, 2026 closes Moonshot’s weight promise for Kimi K3.1 Pro on Hugging Face and ships Tencent’s full Hy4 API with vision. Bacancy Technology treats both as routing decisions for long-horizon agents, not automatic frontier defaults.
November 3 agent guide: Claude Code 2.1.317 MCP and security controls
November 3, 2026 is a Claude Code control release. Version 2.1.317 adds a cloud-session MCP link card, Agent SDK onFailure block hooks, a prompt before web or shell tools send the account email, schedule connector warnings, and Claude apps gateway cost analytics.
November 2 agent guide: Claude message threads and GLM-Legal
November 2, 2026 cut upload cost for long agent loops. Anthropic put message threads into public beta on the Messages API, reporting about 35% lower median time to first token on 500K to 1M token Claude Code requests. Z.ai also opened GLM-5.3-FlashX-Legal for MCP-connected legal workflows, and xAI retired grok-imagine-image-quality.
November 1 agent guide: Mage-VL-Cowork hybrid computer use
November 1, 2026 put Microsoft Mage-VL-Cowork in front of builders: a 4B hybrid computer-use agent that combines GUI actions with persistent bash and Python, reporting 66.0% on OSWorld-Verified under a 50-step budget. Weights ship under Apache 2.0.
October 31 agent guide: DeepSeek Super-agent and Claude Code policy
October 31, 2026 added a DeepSeek Super-agent research prototype that is not a product, and Claude Code controls for layered policy, pooled budgets, and Bedrock guardrail input tagging. A later design essay on November 1 points at the same prototype.
October 30 agent guide: Claude Code write blocks and gateway groups
October 30, 2026 is a Claude Code control release, not a new model. The changelog adds a write block outside working directories, gateway groups on upstreams, and idle compaction. Opus 4.8 fast mode is deprecated the same day and is removed November 30.
October 29 agent guide: Cursor marketplace incident and Mistral Large 4
October 29, 2026 was a supply-chain day and a weights day. Cursor reported tampered Claude Code extension packages in its marketplace. Mistral published open weights for Large 4 under the Ecosystem Open-Weight License. Official Anthropic Claude Code was not the compromised artifact.
October 28 agent guide: Copilot MCP connectors and Gemini 4 Carbon
October 28, 2026 added verified MCP connectors for GitHub Copilot and opened Gemini 4 Carbon as a Fairwind cyber-defender model. Carbon is not a general coding default. Gemini Robotics-ER 2 is a parked robotics preview from the October 27 post.
October 27 agent guide: Copilot SDK identity, LFM3, and Genie 4
October 27, 2026 gave organization-owned Copilot SDK apps their own identity, a Claude Code release that keeps long sessions moving, and an open-weight 2B family built for on-device agents. Genie 4 arrived the same day as a research preview, not as a production runtime.
Scheduled agent runs: OpenAI automations, Claude Code 2.1.310, and Nanbeige4.3-33B
October 24, 2026 added a cron for OpenAI agent sessions, a Claude Code control release, a Copilot CLI Autopilot wait fix, and an Apache 2.0 33B agent model. October 25 did not add a second primary model launch.
Kimi K3.1 Pro and the October 22-23 agent routing board
On October 22 and 23, 2026 Moonshot opened Kimi K3.1 Pro, OpenAI made the Decisions API generally available, MiniMax published M3.1 Flash weights, and NVIDIA shipped an on-device conversational agent model. This guide covers what actually shipped, what is still vendor-reported, and how to place each lane.
MiniMax M3.1 Flash: a cheaper agent and computer-use worker lane
On October 19, 2026 MiniMax launched M3.1 Flash on its API, M Plan, and MiniMax Code with $0.15 / $0.60 list prices, vendor claims of 70% lower agent-task cost, and stronger coding and computer-use scores. This guide covers what shipped, what remains closed-weight, and how to re-bench the cheap worker lane.
Claude Duet: Anthropic’s proactive agent for professionals, with approval still in the loop
On October 21, 2026 Anthropic opened a Claude Duet research preview for US Pro and Max subscribers. Duet is a proactive Opus 5.5 agent with a background VM, Marketplace connectors, and hard approval gates on send, pay, sign, and delete. This guide covers what it is, what it is not, and how enterprise teams should trial it.
DeepSeek V4.1 Flash 1017: a same-price Pareto update for coding and agent workers
On October 17, 2026 DeepSeek upgraded deepseek-flash to DeepSeek-V4.1-Flash-1017 with stronger official agent and coding scores, shorter outputs, unchanged API prices, and MIT weights on Hugging Face. This guide covers what changed, how to re-bench workers, and where 1017 sits beside Beam, Muse Spark Open, and closed planners.
DeepSeek Search and Fetch: opening agent grounding APIs before the October 31 meter starts
On October 17, 2026 DeepSeek opened its in-house Search and Fetch APIs to every developer at $0.75 per 1,000 successful calls per endpoint. Server-side tool calls through DeepSeek Harness, Claude Code, and Codex stay free until October 31, 2026 at 16:00 UTC. This guide covers how agent platforms should pilot, budget, and govern the new grounding surface.
GitHub’s AI Secret Detection: Killing the Noise in CI/CD Security Gates
GitHub released a new AI-driven model for secret scanning that significantly reduces false positives while catching more actual leaks. This matters because traditional regex-based scanners often drown developers in noise, causing them to ignore alerts or disable scanning entirely.
Reflection Beam: Apache 2.0 open weights and an open operating system for agents
On October 16, 2026 Reflection released Beam weights under Apache 2.0: a 501B-parameter MoE (23B active) with a 1M-token context window for coding and long-horizon agents, plus Mirror CLI and a partner stack framed as an open operating system for agents. This guide covers what shipped, how it compares with Muse Spark Open, and how enterprises should place Beam on the routing board.
Claude Code 2.1.302: fork subagents by default and MCP 2026-07-28 tool fixes
On October 16, 2026 Anthropic shipped Claude Code 2.1.302 with fork subagents enabled by default across `claude -p`, the Agent SDK, desktop, and VS Code, plus MCP protocol negotiation fixes that restore tools when servers omit optional 2026-07-28 fields. This guide covers what agent fleets should change before and after upgrading.
GitHub AI Scan for PRs GA: The End of the Security Bottleneck?
GitHub moved AI Scan for pull requests to general availability. This changes how security integrates into developer workflows, removing friction but introducing new governance questions.
Muse Spark Open: Meta’s 816B open-weight agent model and the October 15 routing board
On October 15, 2026 Meta released Muse Spark Open weights: an 816B-parameter (42B active) multimodal model with a 1M-token context window for coding and long-horizon agents. This guide covers availability, desktop MLX runs, license limits, and how enterprises should place it beside Muse Wonder and EU open-weight options.
HydraFusion Max and agentic autofix: GitHub’s mid-October agent control pack
Between October 14 and 15, 2026 GitHub shipped HydraFusion Max, made agentic autofix for Code Scanning generally available, and published November 16 Copilot model retirements. The same window added Vercel Connect MCP Events. This guide covers how enterprises should enable multi-model orchestration and security agents without opening uncontrolled spend.
Gemini 4 Argon: frontier routing, 1M long decode, and the October 13 agent board
On October 13, 2026 Google DeepMind released Gemini 4 Argon as its flagship reasoning model for complex coding, science, enterprise workflows, and agentic work. This guide covers availability, pricing, long-decode setup, Antigravity placement, Fairwind access, and how enterprises should route it against Sol, Opus, and Muse Wonder.
Copilot gets Gemini 4 Argon, forced policy refresh, and agent-scoped hooks
On October 13, 2026 GitHub put Gemini 4 Argon into Copilot, added forceRemoteSettingsRefresh for enterprise managed settings, started enforcing minimum client versions on the sandbox key, and shipped Copilot CLI 1.0.97 with agent-scoped declarative hooks. This guide covers how platform teams should enable the model without weakening governance.
Claude Managed Agents dynamic workflows: background multi-agent runs for document-scale work
On October 9, 2026 Anthropic opened a public beta for dynamic workflows on Claude Managed Agents. A lead agent can write a program that fans work across phased agents in the background. This guide covers enablement, limits, budgets, and how enterprises should adopt it without exploding spend.
Muse Wonder and Copilot governance: the mid-October 2026 agent control board
Between October 8 and 12, 2026 Meta shipped Muse Wonder for agentic work, GitHub added Copilot identity telemetry and JetBrains MCP controls, and Copilot code review gained org billing options. This guide shows how enterprises should update model routing and agent governance together.
Copilot local sandbox GA and Claude Haiku 5.5: the October 7 agent ops board
On October 7, 2026 GitHub made Copilot local sandboxing generally available, Anthropic shipped Claude Haiku 5.5, and Copilot added Haiku plus Ollama model discovery. This guide shows how enterprises should harden agent tool execution and retier high-volume subagent lanes.
Mistral Large 4 preview: EU open-weight routing for multimodal and cyber agent workloads
On October 6, 2026 Mistral opened a public preview of Mistral Large 4, a roughly 1.05T multimodal MoE with 52B active parameters and weights planned by month end. The same day Atlassian rebuilt its enterprise MCP server and Google DeepMind shipped EmbeddingGemma 2 for on-device retrieval. This guide places those releases on an enterprise routing board.
Aleph Alpha Kolibri-1: EU open-weight routing for German-English agents and on-prem RAG
On October 3, 2026 Aleph Alpha released Kolibri-1 under Apache 2.0: a 78B MoE with 3.46B active parameters, bilingual DE/EN specialization, reasoning, and tool calling. This guide explains how enterprises should place it on a routing board versus closed frontier coding models.
Gemini Antigravity 05-2026 is off: cut over managed agents, tool parsers, and gateway secrets
On October 5, 2026 Google shut down antigravity-preview-05-2026. The same day GitHub began scanning Pydantic AI gateway keys. This checklist covers the agent ID swap, breaking local tool schemas, and credential hygiene for production agent fleets.
GPT-6 Sol, GPT-6.1 Sol, Claude Opus 5.5, and Grok 4.7: the late-September 2026 agent routing board
Between September 21 and 29, 2026 OpenAI, Anthropic, and xAI shipped cheaper frontier coding models while GitHub put them into Copilot. This guide explains what changed, which Preparedness and safeguard labels still apply, and how enterprises should re-bench planner and worker lanes.
Copilot computer use and Qwen3.8-Omni-Flash: desktop agents and omnimodal workers in early October 2026
On October 1, 2026 GitHub put computer use in public preview in Copilot CLI and the Copilot app. Combined with October 2 Copilot model deprecations and Alibaba’s September 20 Qwen3.8-Omni-Flash launch, agent platforms now span GUI desktops and native audio-video tool loops. This guide covers controls, cutovers, and where omni models belong.
OpenAI Agents API, Cursor Projects, and Claude Code Projects: the September 2026 coordinator pattern for coding agents
Between September 10 and 17, 2026 OpenAI, Cursor, and Anthropic each shipped a coordinator-style surface for long-running agent work. This guide explains what changed, how the three approaches differ, and how enterprises should pilot them without losing human merge control.
DeepSeek V4.1 Flash for agent workers: Causal Encoder-Decoder, compressed KV cache, and the September 14 Pro alias cutover
On September 10, 2026 DeepSeek released V4.1 Flash as a new multimodal architecture family member with aggressive KV-cache compression for long agent runs. This guide covers what changed, what the Pro alias cutover means, and how to re-bench worker lanes.
Meta Muse Secure VM and Sentinel: what personal-agent isolation, approvals, and Link payments mean for enterprise agent design
On September 8, 2026 Meta launched Muse, a personal AI agent that runs on a dedicated Muse Secure VM with a separate Sentinel permission authority and Stripe Link checkout for agent purchases. This guide extracts the architecture patterns enterprises can reuse for computer-use and connector-heavy agents.
Claude’s Fermat Last Theorem Lean formalization: what Prove2Me multi-agent orchestration means for verification workloads
On September 4, 2026 Anthropic reported that Claude agents produced the first complete computer-checked proof of Fermat’s Last Theorem in Lean after 11 largely autonomous days on Prove2Me. The result is a practical blueprint for long-horizon multi-agent verification, not only a mathematics milestone.
GitHub Copilot’s September 4 wave: GPT-6 Astra GA, Agent Merge preview, and how to govern the new model lanes
On September 4, 2026 GitHub made GPT-6 Astra generally available in Copilot and published a weekly release that expands Fable 5.1 and Gemini 3.8 Flash access while putting Agent Merge into public preview. This guide covers what changed and how enterprises should enable the new agentic coding lanes.
GPT-6 Astra for enterprise agents: Critical cyber designation, routing decisions, and the September 2026 rollout checklist
OpenAI released GPT-6 Astra on September 3, 2026 as its most capable broadly deployed model for coding, computer use, research, and long-horizon agent work. It is also OpenAI’s first model to reach Critical cybersecurity capability under the Preparedness Framework. This guide explains what changed, who should enable it, and how to route it safely against Sol and Fable 5.1.
Muse Spark 1.3 for agentic coding: what Meta changed, how to route it, and when it belongs in your stack
Meta released Muse Spark 1.3 on September 2, 2026 with stronger long-horizon agent collaboration, cleaner coding style, and lower tool-call overhead. The model is available through Muse Code and the Meta Model API. This guide explains the practical routing implications for platform and engineering teams.
Claude Fable 5.1 migration checklist: cache economics, breaking tool_choice rules, and when Mythos 5.1 actually matters
On September 1, 2026 Anthropic shipped Claude Fable 5.1 and Claude Mythos 5.1 for long-running coding and knowledge work. Same list prices as Fable 5 except cache reads drop 75% to $0.25 per million tokens. Forced tool use breaks. Thinking blocks bind tighter. Here is the migration sequence I run before flipping planner lanes.
Gemini 3.8 Flash and Fairwind Cyber: the September 2026 worker-lane and defender-lane checklist
Google shipped Gemini 3.8 Flash and Gemini 3.8 Flash Cyber on September 2, 2026, the third Flash release in six weeks. Standard 3.8 Flash stays at the $0.75 / $3.75 introductory rate through year-end. Flash Cyber and the Fairwind Program gate vulnerability discovery and patching for trusted defenders. Here is how I update routing boards without treating Cyber as a casual coding model.
Multimodal and open-weight agent workers: DeepSeek Vision Exp, GLM-5.3-Flash, and Qwen3.8-Flash-Next
Between August 21 and August 26, 2026, DeepSeek, Z.ai, and Alibaba Qwen each expanded the cheap, multimodal, or open-weight worker layer that production agent stacks rely on. This guide explains what shipped, how the releases differ, and how to place them on a routing board without confusing experiments with production defaults.
Late August 2026 model routing: DeepSeek peak pricing, Qwen3.8 open weights, Grok on Bedrock, and Sol cost lanes
Between August 13 and August 26, 2026 the cheap and mid lanes moved again: DeepSeek GA plus peak/off-peak rates, Alibaba Qwen3.8 open weights, Grok 4.6 on Amazon Bedrock, OpenAI Ultrafast Sol, and Sol promotional pricing. Here is the updated routing board I use so Chinese open models, Bedrock governance, and Sol speed tiers do not collide.
Claude's mid-August API GA wave: browser use, computer use, Files, Skills, and write-capable Workspace connectors
On August 18–19, 2026 Anthropic graduated browser use and computer use toolsets, the Files API, and Agent Skills off beta headers on the Claude API. The same window finished Cowork on web and mobile for paid plans and added Gmail/Drive write actions with approval defaults. Here is the builder sequence I use so GA toolsets do not become an unsupervised outbound email machine.
Grok Bot as always-on teammates on a shared cloud computer: the August 2026 playbook
On August 11, 2026, xAI opened Grok Bot early beta: always-on AI teammates with a persistent cloud computer, available on SuperGrok Heavy, Cursor Ultra, and Cursor Teams Premium (desktop and iOS). The product pitch is finishing work in the real apps. The production detail that matters is sharper: every Bot you create shares one user-scoped cloud computer (files, browser sessions, app logins). Here is how I hand off real jobs, set request boundaries and Auto Review, and refuse to treat separate Bots as a security boundary.
August 2026 model routing: put Grok 4.6, Qwen3.8-Max, and DeepSeek V4-Flash into cost-per-completed-task lanes
Between July 31 and August 12 we got DeepSeek V4-Flash public beta, Qwen3.8-Max on Alibaba Cloud, and Grok 4.6 for long-running agents. List prices look similar at the top. Behavior does not. Here is how I redraw planner vs worker lanes around cost per completed task, what I refuse to claim yet about open weights, and the checklist I use before a new model ID touches production routing.
Agent Plugins 1.0: package skills and MCP once, stop maintaining five client manifests
Agent Plugins 1.0.0 landed as an open standard on August 6, then hit GA in VS Code, Copilot CLI, and the Copilot app on August 12. One plugin.json can carry skills/ and optional mcp.json across launch clients, with vendor extras under reverse-domain namespaces. Here is how I package it, the mistakes I expect, and the honest gap that Claude Code is not on the launch client list.
Claude's early-August 2026 enterprise stack: Cowork Chrome, Compliance API, Auto mode, and self-hosted runners as one playbook
Between August 5 and August 12, 2026 Anthropic shipped five enterprise-facing controls that only make sense together: Cowork in Chrome, Compliance API for Cowork and Claude Code transcripts, Auto mode as the Pro/Max/Team default, self-hosted runners in your network, and inference hooks for DLP. Here is how I sequence the rollout for Team versus Enterprise.
OpenAI Daybreak Blue and Red: cyber models, agent sandboxes, and why GPT-5.6-Cyber stays out of production coding agents
On August 10, 2026 OpenAI expanded Daybreak: Blue for defensive work with frontier models, Red for purpose-trained cyber models including GPT-5.6-Cyber under identity checks and legal attestation. Pair that with Codex safer auto-review defaults and the July 31 sandbox escape checklist. Do not put Cyber in your production coding loop.
Claude cyber-eval incidents: the sandbox escape checklist I run before any offensive agent test
On July 30, 2026 Anthropic disclosed three incidents where Claude models reached live production systems during third-party cybersecurity evaluations. The root cause was a harness misconfiguration that left internet access open while prompts claimed there was none. Here is the defense-in-depth checklist I now require before any capture-the-flag or offensive agent eval.
Cursor's agent swarm economics: why frontier planners and cheap workers beat solo GPT bills
Cursor's July 2026 swarm write-up rebuilt SQLite in Rust from the docs and measured planner vs worker spend. Frontier-only GPT-5.5 hit about $10.5k; Opus 4.8 planning with Composer 2.5 workers landed near $1.3k at similar quality. Here is how I translate that into routing rules for production graphs.
MCP 2026-07-28 is live: day-one field notes after the cutover
July 28 shipped. MCP's fifth spec release makes the protocol stateless at the core, hardens OAuth, graduates Tasks and Apps into a versioned extensions framework, and updates Tier 1 SDKs. Here is what I verify in the first 48 hours that the pre-GA checklist could not prove until clients actually moved.
MCP GA is four days out: the final cutover checklist I run before July 28 goes live
The MCP 2026-07-28 final specification publishes July 28. You already did inventory, header security, and handle migration. These four days are cutover discipline: freeze pins, delete sticky sessions only after round-robin passes, confirm cacheScope with two identities, and staff an on-call window for clients still sending Mcp-Session-Id.
Graph engineering with Claude Code: the 14-step roadmap I use when linear agents stall
A straight-line agent is a degenerate graph. Claude Code dynamic workflows move orchestration into JavaScript so subagents fan out, verify, and converge without stuffing every intermediate result into one context window. Here is the 14-step roadmap I map onto production work, with topology diagrams, contracts, and the patterns I already ship.
Gemini 3.6 Flash shipped, 3.5 Pro did not: the routing checklist I run after July 21
On July 21, 2026 Google released Gemini 3.6 Flash ($1.50/$7.50 per million), 3.5 Flash-Lite ($0.30/$2.50, ~350 tok/s), and a limited-access 3.5 Flash Cyber via CodeMender. Gemini 3.5 Pro stays in partner testing. Here is how I re-benchmark cost per completed task against Sonnet 5 and Fable without betting the roadmap on Pro.
Claude Code Week 29: live MCP artifacts change the blast radius of a shared dashboard
Claude Code Week 29 (July 13–17, v2.1.207–v2.1.212) lets published artifacts call MCP connectors on each view through the viewer's own connections, with first-call approval. Public sharing links, editor roles, screen reader mode, and auto-background for long MCP calls shipped in the same window. Treat live artifacts like production integrations, not pretty exports.
MCP just got a rival enterprise protocol: the portability playbook I run before teams pick a side
In mid-July 2026, reporting put Google, Microsoft, Salesforce, Snowflake, and ServiceNow behind a shared enterprise agent backend protocol framed as a counter to Anthropic's MCP. Protocol wars are procurement stories dressed as plumbing. Here is how I keep tool contracts, auth, and gateways portable while MCP 2026-07-28 still ships on July 28.
Claude Code Week 28: the desktop browser and /doctor checklist I run before enabling it org-wide
Claude Code Week 28 (July 6–10, releases v2.1.202 through v2.1.206) shipped a sandboxed in-app browser on Desktop and upgraded /doctor from a read-only report into a repair tool. Auto mode also blocks transcript tampering. Here is the governance checklist I run before teams turn browsing and auto-fix on for every engineer.
MCP stateless GA is 18 days out: the week-three handle migration sprint I run before July 28
The MCP 2026-07-28 spec publishes July 28 with a stateless core: no initialize handshake, no Mcp-Session-Id, routing on Mcp-Method headers, and application state as explicit tool handles. Week 3 is where teams either mint basket_id-style handles or learn from 502s. Here is the sprint checklist I run 18 days before GA.
The maker is not the verifier: how I build self-improving agent loops without pretending models self-learn
Most teams prompt harder, get a better answer, and start over tomorrow. That is not compounding. Self-learning updates model weights from experience; no public model including Fable 5 does that today. Self-improving means the system gets better: run, log, distill, repeat. The golden rule is maker ≠ verifier. Here is the four-layer architecture and loop patterns I ship.
Claude Cowork is not Claude Code for civilians: the knowledge-worker playbook after the mobile launch
Anthropic shipped Claude Cowork on mobile and web July 8, starting with Max subscribers. Usage data from 1.2 million sessions shows more than 90% of Cowork work is non-technical: memos, RFP reviews, inbox triage, decks. Tasks run in the cloud, sync across devices, and continue when you close the app. Here is how I govern Cowork without treating it like a coding agent.
How to actually use Fable 5: the four-layer architecture behind Mythos-tier results
Fable 5 is back globally, but most teams use it like a bigger Sonnet: prompt harder, better answer, start over tomorrow. Mythos-tier models need Mythos-tier systems: primitives, orchestration, memory, and self-improvement. The golden rule is maker ≠ verifier. Here is the architecture I draw on every engagement after the July 7 billing cliff.
MCP stateless headers can leak secrets into every proxy log: the security checklist I run 22 days before July 28
The 2026-07-28 MCP spec drops sticky sessions and routes on Mcp-Method and Mcp-Name headers. That is a scaling win and a new exfiltration surface. Akamai and SecurityWeek flagged desync risk and accidental API-key mapping into headers visible to load balancers. Here is the pre-GA security checklist I run on gateways and remote servers.
Claude Sonnet 5 is the new default: the migration checklist I run before swapping claude-sonnet-4-6 in production
Anthropic shipped Sonnet 5 on June 30 as default on Free and Pro chat and as claude-sonnet-5 on the Platform API at $2/$10 per million through August 31. Three breaking changes matter for agent builders: adaptive thinking on by default, manual extended thinking removed, and non-default sampling parameters return 400. The tokenizer adds roughly 30% tokens for the same text. Here is the swap checklist.
Fable 5 is back globally: the redeployment routing checklist I run before July 7
Anthropic restored Claude Fable 5 worldwide on July 1 after US export controls lifted June 30. Pro through Enterprise plans get up to 50% of weekly usage limits included through July 7, then usage credits. A new safety classifier blocks the Amazon-reported jailbreak in 99%+ of cases. Here is how I re-promote Fable without repeating June's config chaos.
Codex Record and Replay turns one demo into a Computer Use skill: how I inspect generated skills before trusting them unattended
Codex app 26.616 adds Record and Replay on macOS: perform a workflow once, Codex packages it into a skill you replay with different inputs. Thread handoff and automation run history ship alongside. Computer Use must be enabled. Here is the review checklist I run before any recorded skill runs unattended.
One agent spend dashboard for Cursor, Claude Code, and Copilot: what Copilot's ai_credits_used field unlocks
GitHub added ai_credits_used to the Copilot usage metrics API on June 19. It is a per-user total, not yet split by feature or model, but it closes a gap I have been papering over with spreadsheets. Here is how I unify Copilot credits with Claude API keys and Cursor team usage into one attributable spend view.
MCP goes stateless on July 28: the four-week migration checklist I run before deleting sticky sessions
The 2026 MCP release candidate locked May 21. The final spec lands July 28 with a stateless core: no initialize handshake, no Mcp-Session-Id, routing on Mcp-Method and Mcp-Name headers. Here is the pre-GA checklist I run on remote servers, gateways, and clients so production does not learn about the change from a 502.
Fable 5 got suspended worldwide in three days: the frontier model adoption checklist I now run on every engagement
Anthropic launched Claude Fable 5 on June 9, promised included subscription access through June 22, then suspended Fable and Mythos 5 globally on June 12 after a US export-control directive. Most teams never finished piloting. Here is the governance checklist I use when capability, retention, pricing, and access can flip faster than your rollout calendar.
Claude Code Artifacts turn terminal output into live review pages: what Team and Enterprise buyers should pilot first
Artifacts in Claude Code beta publish self-contained HTML to claude.ai that republishes to the same URL as the session progresses, with version history and org-only sharing. Strict CSP, no external fetch, no backend. Requires Team or Enterprise and claude.ai login. Here is the workflow I use for PR walkthroughs and incident timelines without screenshot threads in Slack.
Cursor cloud subagents in 2026: /in-cloud, /babysit, and /automate without losing your local guardrails
Cursor 3.7 lets you spin subagents in cloud VMs with /in-cloud, iterate on a PR until merge-ready with /babysit, and hand off between local and cloud sessions. Cursor 3.8 adds /automate and five GitHub review triggers. Here is the workflow I use so parallel cloud work does not bypass Auto-review, environment snapshots, or pre-push /review.
Agentjacking is real: poisoned Sentry errors can hijack Cursor, Claude Code, and Codex without touching your repo
Tenet Threat Labs injected a fake stack trace through a public Sentry DSN and watched 100+ coding agents execute attacker commands during normal triage. No git write access required. The agent treats the error as ground truth. Here is how I harden observability MCP feeds, scope triage prompts, and block auto-exec on untrusted telemetry.
The June 15 Claude billing change: Agent SDK credits, model retirement, and the checklist I run before anything breaks
Two Anthropic changes land on the same day: programmatic Claude usage moves to a separate monthly credit pool, and claude-opus-4-20250514 plus claude-sonnet-4-20250514 stop answering on the API. Interactive Claude Code is fine. Cron jobs and CI agents are not. Here is how I audit auth paths, claim credits, and grep for retiring model IDs before the first failed run.
Governing agent autonomy in 2026: Auto-review, permissions.json, and pre-push review
Cursor Auto-review uses permissions.json autoRun.allow_instructions and block_instructions so low-stakes shell/MCP calls flow and high-stakes actions pause. Here is how I wire that pattern into local agents, SDK headless runs, and CI — without mistaking a classifier for a hard security boundary.
Claude Fable 5 for agent builders: when the frontier model is worth the routing change
Anthropic shipped Claude Fable 5 on June 9: a Mythos-class model with tiered safeguards, mandatory 30-day retention on traffic, and $10/$50 per-million pricing. Days later access was suspended globally pending export-control review. Even if you never touched Fable, the launch tells you how frontier routing, retention policy, and governance will work for agent builders in the second half of 2026.
Agentic RAG vs vanilla RAG: why a Sufficient Context Agent beats retrieve-then-pray
Google Research shipped Agentic RAG on Gemini Enterprise with a Sufficient Context Agent that refuses to answer when retrieval is incomplete. On factuality benchmarks they report up to 34% higher accuracy versus standard RAG. Here is when one-shot RAG is still enough, when you need iterative retrieval, and how I wire the pattern without blowing latency budgets.
Agentic transformation is an operating-model problem, not a model problem
Microsoft published a 6-step playbook for rolling agents out across an enterprise, and the line that matters is "you do not need a bigger model, you need a better operating model." That matches what I see in consulting: the pilots that die do not die on model quality, they die on ownership, evals, and governance. Here is how I read the playbook for IT services teams, and the operating-model gaps that actually stall agent rollouts.
The anatomy of an AI agent: memory, tools, the loop, and guardrails
Strip the hype off an AI agent and four parts are left: a memory, a set of tools, a loop that decides what to do next, and a guardrail that vets every action before it runs. Here is what each part is for, the order they fail in, and where I have written about fixing each one.
Your coding agent has amnesia. Persistent memory is the fix.
Claude Code forgets your architecture, your decisions, and why you ruled things out the moment a session ends. The reliability tax is not tokens, it is re-establishing context every morning. Here is what persistent agent memory actually is, how an open-source engine like Cortex implements it, and how to evaluate a memory layer for your own agents.
Your agent's supply chain is the attack surface now
A poisoned VS Code extension spent eighteen minutes on the marketplace and walked off with Claude Code credentials and MCP configs. The model was never the target. Your agent's supply chain is: the extensions, skills, MCP servers, tool definitions, and keys it is allowed to touch. Here is how I harden all four layers, and the checklist I run on every deployment.
MCP just went stateless: what the 2026 spec release candidate changes for your servers
The biggest revision of MCP since 1.0 locked as a release candidate on May 21. The protocol goes stateless, extensions move out of the core, and authorization finally speaks OAuth properly. Most of your servers keep working. Here is what actually changes, what breaks, and the migration I would run in the ten weeks before the final spec lands.
Your agents aren't broken, your tools are: three questions to ask before you build one
When an agent misbehaves, almost everyone reaches for the prompt or the model. The fault is usually further down, in a tool that does too much, lies when it fails, or buries the answer in a wall of raw data. An AI tool is not a function. It is a contract the model has to trust. Here are the three questions I run before writing a single line of any tool.
Inside Recruiting Atelier: a runnable reference for the primitives of an agentic system
A working open studio that vets duplicates, plans the run, screens, scores, shortlists, and notifies. The whole pipeline lives in roughly ninety lines of supervisor code and a tool registry you can read in one sitting. Here is what is inside, why every piece is there, and what you can copy into your own stack.
How an agentic studio screens, scores and shortlists candidates for your hiring team
Open Recruiting Atelier and you do not see a generic AI dashboard. You see five named specialists doing the work a screening team would do: catching duplicates, checking the brief, scoring on four dimensions, ranking, drafting the dispatch. Drop one CV or fifty. Click any candidate to see exactly why they landed where they did. This is what AI for recruitment looks like when it respects your judgment instead of replacing it.
Code agents vs skill agents: when to give an agent the keyboard and when to give it the toolbox
Two ways to let an agent act in the world. Code agents write fresh code into a sandbox. Skill agents pick from a curated menu. The choice should be made in the kickoff, not the postmortem. Here is the framing I use with clients, the four axes where they diverge, and the hybrid pattern most production systems become.
Tool registry design for agentic AI: how the wrong registry kills accuracy before the prompt is read
I reviewed a system last month with 47 tools in its registry and a 22 percent wrong-tool-selection rate. The team was about to migrate from Sonnet to Opus to fix it. The prompt was fine. The registry was the bug. This is the audit pattern I run on every client codebase before we change anything else, the seven failure modes I see in production, and the numbers from the cleanup.
AI agent vs agentic AI: what the distinction actually means when you ship one
Vendors blur the line because "agentic" sells. The two terms describe different architectures, with different cost shapes, different observability needs, and different scoping conversations. Here is the framing I use with clients and the three-question test for which one your project actually needs.
Gemini 3.5 Flash vs Sonnet 4.6: should you re-route your agent stack?
Google shipped 3.5 Flash this week with a "frontier intelligence plus action" pitch and a 4x output-tokens-per-second claim. If your routing layer is on Sonnet 4.6 today, this is the week to re-benchmark. Here is what I am actually moving, what I am leaving alone, and the cost-per-completed-task maths nobody is doing in public.
MCP governance just became a product: what Databricks Unity AI Gateway changes for enterprise agents
Every enterprise MCP deployment I have audited in the last six months has been hand-rolling tool-access policy, payload logging, and per-team cost limits on top of a gateway someone wrote in two days. Databricks just shipped that as a product. Here is what it actually changes, where the gaps still are, and the migration I would run for a Databricks shop.
Three paradigms of LLM memory: implicit, explicit, and agentic
A new survey from BigAI-NLCO splits LLM memory into three layers. Most production agents I review have built the middle one, called it memory, and skipped the layer on top. Here is what the taxonomy actually buys you.
Tool descriptions are prompts. Fix the registry, not the agent.
When an agent picks the wrong tool, the registry is broken, not the agent. Three rules I now apply before debugging anything in a multi-tool system: precise names, "when to use" triggers, and a curated load list. Anthropic's new tool-selection telemetry finally puts numbers on what changes accuracy.
The cheapest LLM call is the one you do not make. GitHub's 19-62% token cut, decoded
GitHub published an instrumented analysis of their agentic CI workflows and reported 19-62% token-cost reductions. The savings are the headline. The technique (pre-agentic data fetching and tool-registry hygiene) is the story most teams will miss.
Claude Opus 4.7's 1M context: when to RAG and when to just stuff it
A million tokens reliably is real now, but it does not retire RAG. It changes the calculus. Cost, latency, recency, and the prompt-cache angle nobody is talking about.
MCP 1.0 is here. What changes for the servers you already wrote
The protocol stabilised. Most working servers will keep working. Three places the new spec actually requires changes (auth profile, server registry, streaming-response semantics) with diffs from a real migration.
Why I am replacing supervisor patterns with handoffs
Supervisors looked clean on paper and shipped slow in production. Handoffs read messier in the code but recover better when an agent loses the plot. Two real systems and where supervisors still earn their keep.
Prompt caching is not optional anymore. Measuring a 47% cost drop
A walkthrough from a client engagement: identifying stable prefixes, restructuring the system prompt for cacheability, and the telemetry that proved caching was actually working.
Tool descriptions are prompts. Stop treating them like docstrings
A docstring tells a developer what a function does. A tool description tells a model when to call it. Different audience, different writing. Six concrete edits that lifted tool-call accuracy.
The agent observability stack we ship to every client
Traces, spans, evals, cost-per-completed-task, and the one dashboard panel that catches 80% of regressions. Vendor-agnostic; covers Langfuse, Honeycomb, and rolling your own.
Three patterns I broke in 2025, and what I do instead now
Self-correction loops without budgets, single-agent solutions to multi-domain problems, and using JSON mode to force structure I should have built into the schema. An honest review.
Haiku 4.5 made our router 5x cheaper. The trade-off matters
Replacing Sonnet with Haiku in the dispatcher role cut our orchestration cost dramatically. It also cost us in two specific places I did not predict.
Why every team's first MCP server should be "list-files"
Smallest useful server. Hardest one to mess up. Teaches the protocol without distracting domain logic. The 60-line server we hand to teams during training.
Eval datasets: stop testing your agents on the happy path
If your eval set is the demos you showed the client, you are testing the wrong thing. How we build evals from production failures and the minimum viable suite to ship.
I was wrong about JSON mode. Here is what changed my mind
For two years I told teams to avoid forced JSON outputs and use structured tool calls. That was right then and partially wrong now. Schema enforcement got better, latency penalties got smaller.
Why your agent keeps failing after 3 steps
The exit condition problem nobody talks about. Most agents are built for the happy path, where every tool call succeeds and the task completes cleanly. Real production agents are different.
The one rule for designing agent tools that actually work
One tool, one purpose. Every tool that does two things will fail you on the third call. I have watched this pattern fail in every team I have trained, and the fix is the same refactor.
RAG vs CAG: when to retrieve, when to cache, when to combine
A decision framework from real implementations. RAG retrieves. CAG stores in cache. Knowing which to use, and when to combine both, determines whether your agent finds the right answer at the right cost.
Visual breakdowns on AI Engineering
Latest in AI Engineering
Genie 4 lands on Gemini Interactions API; Claude Code 2.1.328 adds cloud auto mode
Google releases Gemini 4 Neon; VS Code 1.147 adds Browser Use and model routers
Alibaba releases Qwen4-Max for general API and Token Plan use
Cursor publishes full October marketplace incident investigation
Artificial Analysis Coding Agent Index v2.1 resets coding-agent scores
Sierra releases Personal Agent Protocol 1.0; Shopify enables Poppy for all merchants
Google releases Gemini 4 Hydrogen for everyday agentic workflows
Thinking Machines opens Inkling 2 Small Apache 2.0 weights
How AI Engineering ships in our engagements
The pages below are the buyer-focused, conversion-grade versions of this topic — deliverables, methodology, ROI, security considerations, and CTAs to scope a real engagement.
Agentic AI Consulting
Designed, built, and handed off — production agentic systems for enterprise teams.
Explore the Agentic AI Consulting solutionMCP Integration
Custom Model Context Protocol servers that turn your systems into agent tools.
Explore the MCP Integration solutionAI Guardrails
Multi-layer safety, policy, and audit controls for agents in regulated environments.
Explore the AI Guardrails solutionAI Systems Engineering Training
Eight-day corporate training programs that take dev teams from AI-assisted coding to production agentic systems.
Explore the AI Systems Engineering Training solutionEnterprise AI Architecture
Reference architectures for organisations standing up an AI platform — not one agent, but the foundation for many.
Explore the Enterprise AI Architecture solutionAI Observability
Tracing, eval, cache-hit telemetry, and cost attribution for production agents.
Explore the AI Observability solutionMulti-Agent Workflows
Supervisor + handoff orchestration for portfolios of agents that need to cooperate without arguing.
Explore the Multi-Agent Workflows solutionAI Automation for Enterprises
Operational agents that replace manual workflows — triage, support, ERP integration, content pipelines.
Explore the AI Automation for Enterprises solutionAI Engineering — the questions teams actually ask
Train your team on AI Engineering
Two tracks — one for developers who build agents, one for business teams who use them. Customised to your stack, hands-on from session 1.
See AI Engineering training tracksShip your first AI Engineering system
Architecture design, production implementation on Claude API and MCP, full observability, and a real handoff. Working agents, not slides.
Explore AI Engineering consultingAdjacent topics to read next
Agentic AI
Designing, building, and shipping production agents.
Model Context Protocol (MCP)
The open protocol that gives agents tools.
Multi-Agent Systems
Orchestrating many agents without losing the plot.
Claude API
Building production agents on Anthropic's Claude.
AI Observability
Tracing, eval, and telemetry for production agents.
Go deeper on this topic
New breakdowns on this and related agentic AI topics, plus what I am shipping for clients — one email on Thursdays.












