Model Context Protocol.The open standard that gives LLMs real tools.
MCP is the protocol that turns an LLM into an agent. It defines how a model discovers tools, calls them, streams results back, and authenticates against your systems. The 2026-07-28 spec is generally available: stateless request/response core, header-based routing, explicit tool handles for multi-step state, MRTR for elicitation, and Tasks/Apps as versioned extensions. This hub gathers day-one field notes, migration checklists, EMA identity patterns, and registry hygiene that keep tool selection accurate in production.
What MCP solves
Before MCP, every team invented their own tool-call protocol. After MCP, you write a server once and any compliant model client can use it — Claude, GPT, local models. The wins compound: one shared auth profile, one discovery handshake, one schema format.
When to build your own server
Build an MCP server when you have a domain-specific tool that needs to be reused across agents — ticketing, billing, internal search. Use a public server when the integration already exists and is curated. Skip MCP entirely for one-off scripts; the protocol overhead is real if you only ever call one tool once.
The cost of an over-loaded registry
Every registered tool adds ~8–12 KB of schema overhead to every API call, plus selection noise that hurts accuracy. Audit your registry: anything not called in the last 30 days, drop from the default load. With MCP 2026-07-28 generally available, stateless routing on Mcp-Method headers and explicit tool handles replace sticky sessions, but header hygiene and cacheScope are now security properties, not just infra details.
Deep dives on Model Context Protocol (MCP)
November 15 agent guide: Claude Code 2.1.325 and Code Mode ops
November 15, 2026 closes the window with Claude Code fleet hygiene. Version 2.1.325 tightens sandbox defaults, plugin safety, and Code Mode edge cases. This Bacancy Technology brief turns Anthropic’s experimental Code Mode docs into an operational checklist.
November 7 agent guide: OpenCode Browse for signed-in browser agents
November 7, 2026 put browser agents back on the control-plane agenda. OpenCode Browse is an MCP server plus Chromium extension that lets agents use the real signed-in browser, with human handoffs for login and 2FA, session allowlists, and capture tools.
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 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
MCP Enterprise-Managed Authorization is stable: how IdP-provisioned connector access replaces per-server OAuth hell
EMA makes the organization IdP the decision-maker for which MCP servers a user can reach. Admins enable connectors once; clients exchange an Identity Assertion JWT for scoped tokens without redirecting every employee through OAuth per server. Anthropic ships it across Claude, Claude Code, and Cowork; VS Code supports it; Okta is the first IdP. Here is the pilot I run before July 28 stateless transport work lands.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Visual breakdowns on Model Context Protocol (MCP)
Latest in Model Context Protocol (MCP)
Bacancy covers Claude Code 2.1.325 sandbox defaults and Code Mode ops
Sierra releases Personal Agent Protocol 1.0; Shopify enables Poppy for all merchants
LMSYS launches SGLang Consortium; Claude Code 2.1.323 adds Code Mode
NVIDIA contributes OpenShell to CNCF Sandbox for agent runtime security
OpenCode Browse gives MCP agents the signed-in Chromium browser
Claude Code 2.1.319 backgrounds MCP tasks and adds denyInsteadOfPrompting
Claude Code 2.1.318 tightens cloud sessions and MCP deny URLs
Claude Code 2.1.317 adds MCP link cards, fail-closed hooks, and email checks
Speaking on Model Context Protocol (MCP)
How Model Context Protocol (MCP) 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 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 Automation for Enterprises
Operational agents that replace manual workflows — triage, support, ERP integration, content pipelines.
Explore the AI Automation for Enterprises solutionModel Context Protocol (MCP) — the questions teams actually ask
Train your team on Model Context Protocol (MCP)
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 Model Context Protocol (MCP) training tracksShip your first Model Context Protocol (MCP) system
Architecture design, production implementation on Claude API and MCP, full observability, and a real handoff. Working agents, not slides.
Explore Model Context Protocol (MCP) consultingAdjacent topics to read next
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.


