The coding agents tracker

Install agent-framework-builder-dotnet and agent-framework-builder-python into Claude Code, Copilot, Cursor or Codex with gh skill install or npx skills add, pin the version, wire the Learn MCP server, and keep the skill updated.

Use agent-sdk init, agent-sdk eval and agent-sdk github replay (@grok/agent-sdk 0.6.0) to build a pull request review bot, pin its behavior with evals, and test it against real PRs without pushing a commit.

Keep Claude Managed Agents, skills, environments and memory stores in git and reconcile them with `ant apply` (anthropic-cli 1.30.0+, current 2.9.0). The file layout for each kind, what claude-lock.json records and why you must commit it, how drift, --force and --prune behave, why memory stores attach through deployments rather than agents, and a GitHub Actions workflow that applies on merge.

The Anthropic Python and TypeScript SDKs now emit OpenTelemetry spans on their own: register a tracer provider before the first call and every messages.create becomes an anthropic.messages.create CLIENT span with gen_ai.* token, model and stop-reason attributes. Content mode, conversation IDs, user.id baggage, linking to the Claude Platform's server-side spans, streaming and tool runner behavior, and the env-var override trap, checked against anthropic 2.8.0.

Microsoft Agent Framework for .NET 1.28.0 removes A2AServerRegistrationOptions.AgentRunMode, so hosted A2A agents always answer with a message, and replaces the id/name/description overloads on A2AAgent and AsAIAgent with A2AAgentOptions. Here is what breaks and how to migrate.

Send diagnostics.previous_message_id on every Messages API call and Claude tells you which part of the prompt broke the cache: model_changed, system_changed, tools_changed or messages_changed, plus an estimate of the tokens you paid to rewrite. Request and response shapes, the pending and not-found states, streaming, a logging helper for anthropic 2.7.0, and the limits.

Stop editing the tools array between turns. Append a role: system message with tool_addition and tool_removal blocks (beta inline-tools-2026-09-15) so a Claude agent gains, loses or re-versions tools while the cached prefix and preserved thinking stay valid. Placement rules, defer_loading, schema changes, error codes and model support.

Use the Claude API's on-demand compaction parameter (beta compact-2026-09-04) to summarize a tool-calling agent loop before it outgrows the 1M window: when to trigger it, where to cut so tool calls and thinking stay valid, how to write the summarization instructions, and the stop reasons, errors and billing fields that trip people up.

ModelContextProtocol 2.4.0 ships ModelContextProtocol.Extensions.Skills, an experimental package that implements the SEP-2640 Skills extension: one call to publish a folder of SKILL.md directories, and client helpers that verify every file against a SHA-256 manifest.

On November 5, 2026 Microsoft added a Windows Arm64 migration scenario to the GitHub Copilot upgrade agent. Here is what the blockers look like in a real .NET project, what the agent can and cannot verify, and how to check the result yourself.

Copilot Fusion, generally available since October 28, 2026, is a runtime model router that picks a model and an execution pattern (Single, Cascade, or Critique) per prompt. Here is how the three patterns work, what Fusion Standard, High, and Max cost you in AI credits, how to lock the effort level with managed-settings.json, and the gotchas the docs bury.

ACP (Agent Client Protocol, v1) connects an editor to a coding agent; MCP (spec 2026-07-28) connects an agent to tools. They sit on opposite sides of the agent and are used together: ACP's session/new even carries the MCP servers the agent should start. Here is the feature matrix, the wire flow, and a working agent and client checked against @agentclientprotocol/sdk 2.4.0.

MXC is Microsoft's MIT-licensed SDK for running untrusted code, including model output, plugins and tools, under one deny-by-default policy that it maps to Seatbelt on macOS, bubblewrap on Linux and ProcessContainer on Windows. Here is what MXC SDK 1.0.1 and schema 1.0.0 actually define, how Copilot CLI hands it a policy per process, and what stays outside the box.

On November 3, 2026 the .NET team showed agent skills shipping inside NuGet packages as skills/<name>/SKILL.md. Here is the layout, how restore exposes it through project.assets.json, the two tools that read it today, and what is still missing.

The MCP Tasks extension (io.modelcontextprotocol/tasks, spec 2026-07-28, SEP-2663) lets a server answer tools/call with a durable task handle instead of a result. The client polls tasks/get, answers mid-flight questions with tasks/update, and can cancel or reconnect. Here is the wire protocol, what changed from the experimental 2025-11-25 version, when a task is worth it, and a working server and client checked against @modelcontextprotocol/ext-tasks 0.2.2.

Claude Tag is Anthropic's shared Slack agent: one org-owned identity per channel scope, with channel memory, admin-granted connectors, a GitHub App for draft PRs, and a monthly spend limit. Here is what it is, how setup and pairing work, how it differs from the old Claude in Slack and Claude Code in Slack apps, and the data-retention and billing details to check before you turn it on.

Microsoft Agent Framework for .NET 1.27.0 makes DefaultHttpRequestHandler throw HttpRequestException when its client-provider callback returns a client for a redirect destination. Here is why that hole existed, what breaks, and how to rewrite the callback.

A coding agent loses its context every session, so a project that runs for days needs its memory in the repository. Make the coordinator a small script and a JSON ledger, run every worker as a fresh `claude -p` session in its own git worktree with a hard scope and budget, and have the coordinator verify and merge the work itself. Tested with a stub worker; flags pinned to Claude Code 2.1.310.

The Anthropic SDK retries a failed call twice in about 1.2 seconds, which is fine for a chat request and wrong for a 200-turn agent run. Classify every failure into retry-after, capacity, transient or terminal, retry the model turn (never the tool call), share one pause gate across workers, catch the mid-stream overloaded_error that arrives as a 200, and checkpoint so a dead run resumes. Tested against anthropic 2.3.0 for Python.

A guard hook that crashes or times out lets the dangerous command through in most coding agents. Fail closed for pre-action guards, fail open for everything else, and make the script fail closed by itself because Copilot, Codex and Gemini CLI treat a timeout as allow. Compared on Claude Code 2.1.295+, Cursor hooks, Copilot CLI 1.0.105, Codex and Gemini CLI, with a portable guard script.

Moving an agent from claude-sonnet-4-6 or claude-opus-4-7 to claude-sonnet-5-5 or claude-opus-5-5 is not just a model ID swap. Thinking is always on, thinking-off and forced tool_choice now return 400, the effort defaults moved, Sonnet counts about 30% more tokens, and Claude Code ignores your old effortLevel on Opus 5.5. Here is the full checklist with before/after code.

If a specialist agent is just a model loop wrapped around a few read-only calls into your own services, collapse it into a skill served over MCP: a SKILL.md plus typed tools that the parent model calls directly. Keep it an A2A agent when it needs its own model, private context, a long multi-step workflow or an independent lifecycle. Here is the decision matrix, the measured cost of each path, and the Agent Framework 1.17 wiring.

Run the orchestrator on claude-opus-5-5, give implementer and reviewer subagents claude-sonnet-5-5, and send search, triage and summarizing work to claude-haiku-5-5 at medium effort. Here is the role matrix, the cost math per subagent run, Haiku 5.5's 100k-token price cliff, and the Claude Code model-resolution rules that silently override your choice.

Turn on the local sandbox for everyday Copilot CLI work, move to a cloud sandbox when the code or the task should never touch your laptop, and use a dev container when the team needs the same reproducible toolchain. Compared on Copilot CLI 1.0.104: what each boundary isolates, what it leaks, what it costs, and how to stack them.

Use /fleet for a one-off parallel task in your terminal, a dynamic workflow when the same multi-agent process has to run the same way twice, and GitHub Agentic Workflows when that process runs unattended on repository events. Compared on Copilot CLI 1.0.103 and gh-aw v0.93.6: who plans the split, limits, resume, permissions, write safety and billing.

A plugin hook fails with "Failed to run: Plugin directory does not exist" when the directory your session loaded the plugin from is gone: an update past the 14-day orphan window, a claude.ai sync that moved the folder to .trash, or a --plugin-dir you moved. Run /reload-plugins, read its summary line, and know which cases need a restart. Checked against Claude Code 2.1.310.

Microsoft Agent Framework 1.26.0 makes MapAGUIServer resolve the keyed AIAgent, its AgentSessionStore, and the isolation key provider per request, and adds a selector overload that picks the agent from the HttpContext.

Run /sandbox policy <command> to see what the sandbox blocked, then grant the path or host it needs, update Copilot CLI to 1.0.103 for the localhost, proxy and Linux fixes, and only bypass a command on purpose.

A claude -p run on Opus with an API key gives up after three consecutive 529s, about 1.5 seconds of backoff, no matter what CLAUDE_CODE_MAX_RETRIES says. Add --fallback-model, set CLAUDE_CODE_RETRY_WATCHDOG=1 with a max wait, or widen the 529 backoff with the OVERLOADED_RETRY delay variables. Checked against Claude Code 2.1.309.

Claude Code 2.1.289 and earlier resend every screenshot on every turn, so one refused request means every later turn is refused too. Update to 2.1.290+ and resume with claude --continue; the client then trims the oldest images to 510, 255, then 127. On an old build, /compact or /clear. Then stop the screenshots piling up.

Turn on GitHub Copilot computer use in Copilot CLI and the Copilot app on macOS and Windows, grant the macOS Accessibility and Screen Recording permissions, approve apps per session or always, write prompts that keep the agent read-only, and lock it down with deny rules and the features.computerUse managed setting.

ModelContextProtocol 2.3.0, released October 20, 2026, changes McpClient.ServerInfo from Implementation to Implementation? because 2026-07-28 servers may omit their identity from server/discover. Here is why, what breaks under warnings-as-errors, and the one-line fix.

On container protocol 2.0.0, Foundry hosted agents isolate conversations and sessions per Entra caller by default. When your own backend fronts many end users, you delegate with x-ms-user-identity, grant a custom impersonation role, and key everything your container stores by session ID plus user ID. Here is the C# for each layer and the traps that leak data between users.

Since Claude Code v2.1.295, a command or HTTP hook can set onFailure to "block" so a guard that crashes, times out, cannot start or prints invalid JSON stops the tool call instead of waving it through. Here is the config, what counts as a failure, the events where it does nothing, and the exit-0 trap no setting can catch.

Claude Code v2.1.296 lets a subagent auto-compact earlier than the main conversation. Set autoCompactWindow in the subagent's frontmatter or --agents JSON as a plain integer from 100000 to 1000000, and watch out for the 200k parsing trap, the CLAUDE_CODE_AUTO_COMPACT_WINDOW override, and the --agent session mode where the field does nothing.

Wire Cursor Rollouts (launched September 23, 2026) to your CI and to Datadog so every PR, including the ones a cloud agent wrote, gets a rollout plan before merge and per-environment checks at deploy, 20 minutes, 1 hour, 1 day and 3 days. Covers the DeploymentsService API, a GitHub Actions job, the Datadog MCP data source, and the gotchas that leave changes stuck in Pending.

A practical setup for Cursor Projects: prepare the repo so every worker starts warm, seed the Project's shared Context with a plan, conventions and a slice ledger, cut the work into disjoint PR-sized slices, and let subscriptions keep it moving. Covers Cursor 3.24, plan and admin gates, and the gotchas of a Context that lives outside git.

Request a GitHub Copilot code review from a script with the REST requested_reviewers endpoint, the GraphQL requestReviewsByLogin mutation, or gh pr edit, then control whether it runs at Lite or Balanced effort. Covers the bot login, the effort precedence chain, why the per-request effort field announced on October 2, 2026 is not in the published schemas yet, and how to read the effort that actually ran.

Azure MCP Server 3.0.0 shipped on October 12, 2026. Tool calls with unknown parameters now fail, options like subscription and tenant were removed from many tools, new Storage accounts disable Shared Key auth, and the server speaks the stateless MCP 2026-07-28 protocol.

Send GitHub Copilot app agent traces, token metrics and events to your own OTLP collector with the telemetry block in enterprise managed settings. Covers every telemetry key, the six content-capture classes, delivery via .github-private, MDM or a root-owned file, channel precedence, a collector config with bearer auth, and the gotchas that make exports silently go nowhere.

Enable GitHub Copilot local sandboxing in Copilot CLI 1.0.95 and the Copilot app, then lock down filesystem paths, outbound hosts, git/gh tokens and masked environment variables. Covers the settings.json keys, /sandbox policy, the bypass escape hatch, enterprise enforcement, and the gotchas on macOS, Linux and Windows.

Write a Copilot dynamic workflow with defineWorkflow in .github/extensions/<name>/extension.mjs, then run it headless with copilot workflow run in GitHub Actions. Verified on Copilot CLI 1.0.95 and @github/copilot-sdk 1.0.19: the --experimental flag, project-extension trust, flag order, exit codes, result files and permissions.

Genkit Dart 1.0.0 freezes the API, moves HTTP serving into core with GenkitRouter, and changes the streamed error frame. Shipped Flutter apps on a 0.17 client need sendLegacyErrorFrame.

Magentic orchestration is Agent Framework's port of AutoGen's Magentic-One: an LLM manager writes a fact sheet and plan (the task ledger), then grades every round with a JSON progress ledger to pick the next agent, detect stalls and replan. Here is how the loop works on Microsoft.Agents.AI.Workflows 1.24.0 and agent-framework-orchestrations 1.3.1, what it costs per round, and the limit defaults that let it run forever.

Semantic Kernel .NET 1.81.0 fixes a FileIOPlugin oracle: WriteAsync told the model a file outside AllowedFolders existed, was read-only, and where it lived. Measured before and after.

The GitHub Copilot SDK (1.0.18, October 8, 2026) is a thin client for the Copilot CLI runtime: your app speaks JSON-RPC to the same agent loop that powers Copilot CLI, with built-in file and shell tools, MCP, sub-agents, hooks, and BYOK. How it is wired, four things you can build with it, and the defaults that will bite you in production.

Microsoft.Agents.AI.Anthropic 1.24.0 drops the preview suffix and depends on Anthropic 12.53.0. Agents built from IAnthropicClient are now stable API, while the client.Beta extensions are marked experimental under MAAIANTHROPIC001, which extension-method calls do not trigger.

GitHub Agentic Workflows (gh-aw v0.91.5) compiles a Markdown file into a hardened GitHub Actions .lock.yml that runs Copilot, Claude Code, Codex, Gemini or Pi in a read-only, firewalled job and applies writes through safe-outputs. What it adds on top of Actions, the jobs it generates, and when a plain workflow with claude-code-action is still the better tool.

The Agent Harness is Microsoft Agent Framework's batteries-included runtime: one call (AsHarnessAgent in .NET, create_harness_agent in Python) wraps any chat client in a tool loop with todos, plan/execute modes, file memory, tool approval, compaction and OpenTelemetry. Here is what it actually sends to the model on Microsoft.Agents.AI.Harness 1.23.0, what it costs per call, and how to trim it.

A context window is everything the model can see in one request: system prompt, tool definitions, history, tool results, thinking and the reply. Here is what counts, what happens at the limit on claude-opus-5-5 and friends, and the six techniques agents use to work past it: deferred tools, context editing, compaction, memory, subagents and output filtering.

Tool calling is a protocol, not magic: the model emits a structured request matching a JSON Schema you supplied, your code runs it, and the result goes back as a message. The schema and its descriptions are rendered into the model's prompt and, with strict mode, into a decoding grammar, so they shape behaviour more reliably than any system-prompt instruction. Here is how it works on claude-sonnet-5-5 and OpenAI strict mode, with schema patterns that make invalid calls impossible.

In a workflow, your code decides the next step and the model fills in each step. In an agent, the model decides the next step and your code only executes it. That one question (who owns the control flow) determines cost, latency, testability and failure modes. Here is the distinction as Anthropic, Microsoft Agent Framework and LangGraph define it, with the same task built both ways in Python against claude-haiku-4-5 and claude-sonnet-5-5.

Microsoft Agent Framework .NET 1.23.0 honors assignments to FunctionInvocationContext.Function, so middleware can redirect a tool call to a different AIFunction. A new WrapWithPendingMiddleware helper keeps the rest of the chain in the loop.

An agent skill is a folder with a SKILL.md file that the agent loads on demand: only its name and description sit in the system prompt, the instructions arrive when a task matches, and bundled scripts run without ever entering context. Here is how that differs from a system prompt in cost, scope, invocation and trust, with the exact limits from the Agent Skills spec and Claude Code.

MCP is a JSON-RPC protocol that lets any AI host call tools, read resources and use prompts from any server, the way LSP did for language support. Here is how it works on the wire under revision 2026-07-28, captured from a real server, and why VS Code, Visual Studio, JetBrains, Xcode, Zed and Cursor all converged on it.

Microsoft.AspNetCore.Components.AI is an experimental Blazor package in .NET 11 RC1 that turns any IChatClient into a streaming chat UI with tool approvals, typed tool rendering, and shared state over AG-UI.

A coding agent refactors a component, renames a data-testid, and your Playwright suite goes red. Here is a three-layer setup, verified on Playwright 1.63.0 and Claude Code 2.1.197: locators that survive, a PreToolUse hook that blocks the rename, and a CI guard that lets the Playwright healer agent fix locators but never rewrite an assertion.

Every agent request pays for its system prompt, the provider's hidden tool-use preamble, and every tool schema before the user says anything. How to measure that fixed cost with differential count_tokens calls on the Anthropic API, the input_tokens endpoint on OpenAI, an MCP listTools probe, and /context in Claude Code, anchored to claude-opus-5-5, claude-sonnet-5, and @modelcontextprotocol/client 2.1.0.

The AG-UI protocol now has a standalone .NET SDK: AGUI.Server 1.0.0 streams any IChatClient as AG-UI events over SSE, and AGUIChatClient consumes an AG-UI endpoint as an IChatClient, down to .NET Framework 4.7.2. Agent Framework users get renamed APIs.

Dev containers, Docker Sandboxes microVMs, Lima VMs, and hosted cloud sandboxes all move Claude Code, Codex, or Copilot CLI off your host. What each one actually isolates, the exact commands to make it throwaway, and the two things none of them protect: your writable workspace and your git hooks.

Scoping a token does not stop a prompt-injected agent from leaking it. Moving the token out of the agent's process does. Three working setups: a 50-line gateway any agent can call, Claude Code 2.1.199+ sandbox masking with injectHosts, and Claude Managed Agents vaults, plus the measured leak that host-level injection still allows.

Move a repo, its Cursor cloud agents, automations, Bugbot, and CI from GitHub to Cursor Origin without a flag day: mirror first, rewire agents and CI while GitHub is still the source of truth, then cut over with Detach from GitHub or the reversible inbound_to_outbound mirror transition. Covers what breaks, the Origin CLI and API calls, a ref-parity check, and the rollback path.

Claude Code 2.1.277 reads AGENTS.md natively, so Cursor, Claude Code, and most Copilot surfaces can now share one instructions file. Here is the checklist for merging three drifted rule files into AGENTS.md, which bridge files to delete, the one Copilot file you still have to generate, and a CI check that keeps them from drifting again.

A side chat branches off what the agent already knows; a subagent goes and finds out something new. Claude Code's /btw has no tools at all, Cursor's /btw opens a full agent, and a plain subagent sees none of your conversation. A decision guide for Claude Code 2.1.278 and Cursor 3.11+.

Move a local stdio MCP server to a remote Streamable HTTP server behind OAuth on MCP spec 2026-07-28 and TypeScript SDK 2.0.0. Dynamic Client Registration is now deprecated, so use Client ID Metadata Documents first and keep DCR only as a fallback. Covers the steps, a measured CIMD/DCR test matrix, and the misleading error you get when the two sides disagree.

Microsoft Agent Framework .NET 1.22.0 adds AIAgent.AsIChatClient(), closing the round trip with IChatClient.AsAIAgent(). Your agent, with its instructions and tools intact, now plugs into any API that takes an IChatClient.

BYOK lets you point GitHub Copilot at a local Ollama model in VS Code, the Copilot CLI, and the Copilot app. You keep chat and agent mode. You lose inline completions, semantic search, embeddings, /delegate, and roughly 20 points of SWE-bench. Here is the exact trade.

Four ways to run Cursor Self-Hosted Machines workers for Cloud Agents, compared on isolation, pickup latency, session limits, per-session cost, and where the team service-account key ends up. Vercel Sandbox is the default pick, AWS Lambda MicroVMs if agents must reach your VPC.

A September 2026 comparison of GitHub Copilot code review, Cursor Bugbot, and anthropics/claude-code-action@v1 running the code-review plugin: what each one reads, what it skips, what it costs per review, and which to put on which repo.

Claude Code 2.1.274 still loads only CLAUDE.md. Bridge AGENTS.md with an @AGENTS.md import or a symlink, then avoid the three traps: imports that don't expand from a subdirectory, symlinks that Windows checks out as a 9-byte text file, and Edit refusing to write through the link. Includes a CI check and a SessionStart hook for repos you don't own.

"File is configured to be ignored by Copilot" or "Some files were excluded from the context" means a content exclusion rule matched. How to find the rule, why globs over-match, and how to narrow it.

Since Claude Code 2.1.77 a PreToolUse hook's allow cannot override a deny or ask rule. Find the matching rule with /permissions, then move the policy into the hook.

When a Stop hook, /goal condition, or CI-style gate demands a check the agent's environment can never pass, Claude Code keeps re-running it until the 8-consecutive-block cap (2.1.143+) ends the turn. Here is why it happens and the hook patterns that let the agent give up correctly.

Microsoft Agent Framework .NET 1.21.0 ships Microsoft.Agents.AI.LocalCodeAct 1.21.0-preview.260911.1, which no longer lets the CodeAct Python subprocess inherit the parent environment when Environment is null. On 1.20, generated code could read every host variable, API keys included.

Agent Execution Timed Out, ERROR_EXTENSION_HOST_TIMEOUT and Timeout waiting for EverythingProvider are one failure: Cursor's extension host missed its 60 s startup budget. Read exthost.log first, then fix the right cause: endpoint security, a VPN capturing loopback, a corrupt state database, or an extension.

Your MCP URL 307/308-redirects to another host, the client follows it, the Authorization header is stripped, and the target answers 401. Register the final URL.

OAuth succeeded but every MCP call gets 401 invalid_token? Make the PRM resource, the token's aud and your validator agree on one canonical server URL.

Use Cursor's /goal command to keep a cloud agent working toward one finish line across many turns. Covers writing a verifiable objective, pinning a Custom Mode playbook, pairing it with /loop and subscriptions, the CLI's durable goals, and how to stop a goal that ignores Stop.

Since August 21, 2026 mentioning @GitHub in Slack starts a Copilot cloud agent session the whole channel can steer. Here is the setup, the Slack Code channel model, why the pull request comes from an app identity instead of you, what the thread context capture actually exposes, and how the two separate billing meters add up.

Cursor's Self-Hosted Machines, shipped September 2, 2026, move Cloud Agent tool calls onto hardware you own while inference stays in Cursor's cloud. The agent worker CLI, My Machines vs Team Pools, the three outbound hosts, and the data that still leaves your network.

Claude Code 2.1.260 adds a likely-cause diagnosis to the Prompt cache (main) line in /usage and to the prompt_cache status line object. Instead of just counting misses, it tells you whether the tool set changed, the system prompt changed, or the TTL expired.

The agent-framework-hosting packages are conversion helpers, not a runtime. One Agent instance, one AgentState, and three thin adapters give you a Telegram bot, an A2A peer, and an MCP tool from the same process. Here is the wiring, the per-channel session-ID policy, and the four things each channel refuses to do.

GitHub's September 1, 2026 changelog lets Copilot submit an approving review that satisfies a repository's required-approval rule. It is off by default, scoped by file globs, and dismissed on new commits. Here is what actually changes in your branch protection.

Agent Framework ships an in-memory chat history provider and nothing else for .NET. Here is a Cosmos DB backed ChatHistoryProvider that survives process restarts, the container design that keeps a 200-turn session cheap, and the second provider you need if you want semantic recall across sessions.

A skill's body loads on demand, but its name and description sit in a listing that is always in the prompt, capped at 1% of the context window. Claude Code 2.1.261 adds /skill-doctor to say which loaded skills never get used and what each one costs, so you can prune them before the budget starts evicting the skills you do use.

The cold start of a subagent is not what costs you money. Measured across 117 real Claude Code subagent transcripts, startup context was 0.6% to 18% of each agent's total spend. Depth is expensive because every layer runs its own agentic loop and hands the layer above a summary instead of evidence. Here is the compression test that tells you which layer to delete.

Conversation history can live in your process, in your database, in the provider, or on the machine that ran the agent. Where you put it does not change your token bill, it decides your retention exposure, and it decides whether you can ever change providers. The numbers, the retention windows, and a storage shape that survives all three.

Until now the only way to hand every developer the same MCP servers was managed-mcp.json, a file at a system path that takes exclusive control of MCP. Claude Code 2.1.259 adds a managedMcpServers setting for HTTP and SSE servers, and quietly narrows what allowedMcpServers governs.

Defensive system prompts are heuristic. Information-flow control is not: label every piece of content with integrity and confidentiality, propagate most-restrictive-wins through every tool call, and check the label at the sink before it runs. An 80-line runnable harness, the Agent Framework FIDES implementation, and the false positives the pattern buys you.

ModelContextProtocol 2.0.0 flipped HTTP transport to stateless by default, which is the one change that can drop every client still speaking 2025-11-25. HttpServerSessionMode.StatefulForInitializeClients in 2.2.0 serves both revisions on one endpoint. Here is the ordered upgrade, the ten breaking changes that matter, and the discover-probe bug that only a 2.1.0 client fixes.

Instructions files are deterministic and always sent. AGENTS.md sits at the bottom of the documented repository precedence list. Copilot Memory is a separate store Copilot writes for itself, read by only three surfaces, and it is not in the precedence list at all. Here is the support matrix and the rule for deciding where each convention belongs.

The experimental /rubber-duck command in VS Code 1.135 hands the agent's plan, code, and tests to a model from another family for review. GPT-5.4 critiques Claude, and the cross-family choice is the whole point.

Agent Plugins 1.0.0 standardizes exactly two component types: skills and MCP servers. Slash commands, hooks, subagents, rules, LSP servers, permission config and secrets all stay vendor-specific. Here is the field-by-field matrix across Claude Code, Cursor, Copilot and Codex, and which layout to author in.

GitHub's August 27 and August 28, 2026 changelogs remove the 20,000 line review cap, start reviewing bot-authored PRs, and flip the default review effort from Lite to Balanced on September 28. All three push AI credit consumption up in the same month.

Claude Code 2.1.251 adds PreModelSwitch and PostModelSwitch hook events. The matcher fires on the canonical name of the model you are switching to, and exit code 2 cancels the switch.

Protocol revision 2026-07-28 deleted Mcp-Session-Id, the initialize handshake, resources/subscribe, ping, logging/setLevel and SSE resumability. An automated survey of 1000 open source MCP servers found 90% reference the session ID nowhere. Here is what the other 10% has to rewrite, with verified code on @modelcontextprotocol/server 2.0.0.

A symlink swapped after the check, deny rules that stopped applying through a symlinked search path, a marketplace command pointing outside its plugin, and a workflow script read before approval. Four fixes in one release, all the same bug.

A server that vanished from /mcp with no error is almost always an allowlist. Run claude mcp add on the same server: the add path prints the reason the load path swallows.

MCP9005 is advisory, but MCP9004 crashes at startup and stateless mode makes SampleAsync throw. Here is what each diagnostic means and how to fix it properly.

A headersHelper field on url marketplaces and catalog entries runs a local command that prints HTTP headers, so an internal plugin catalog behind S3 or an artifact repo can authenticate with a short-lived token. Here is the schema, the consent prompt, and the header names Claude Code drops.

MCP error -32022 means your client opened at 2025-11-25 but the server only serves 2026-07-28. Make one side dual-era instead of pinning a version.

Cursor shipped Builds for Cloud Agents on August 13, 2026: a bootable filesystem snapshot of an already prepared machine. Cursor reports 3x faster time to first token. The lever you control is the install vs start split in .cursor/environment.json.

Stop shipping SKILL.md folders inside every agent deployment. Serve them from an MCP server and pull them with UseMcpSkills on Microsoft.Agents.AI.Mcp 1.18. Includes the exact skill://index.json shape, a working C# server, the wire trace, and the SEP-2640 drift that will bite you.

Since August 3, 2026 you can pick a reasoning level next to the model when you start a Copilot cloud agent task. The Agent Tasks REST API has no equivalent parameter, so scripted dispatch cannot set it. Here is where the control exists, which levels each model exposes, what lands on the wire, and how to pin a default instead.

Semantic Kernel .NET 1.80.0 ships a breaking change: the OpenAPI plugin's default HttpClient no longer follows redirects, closing an SSRF bypass. Here is what changes and why your own HttpClient reopens the hole.

Claude Code and GitHub Copilot both ship allowedMcpServers and deniedMcpServers, but the matchers behave differently. serverName is a fallback that a single serverCommand entry silently disables, deny is a union while allow is not, and an invalid allowlist locks everything out.

Agent Plugins 1.0 says plugin.json at the root and mcp.json beside it. Claude Code 2.1.x wants .claude-plugin/plugin.json and .mcp.json. Here is what each client actually loads, tested against a real plugin, and the dual-layout directory that satisfies both.

MCP 2026-07-28 mirrors the JSON-RPC method and target name into HTTP headers so a gateway can route, throttle, and audit without parsing the body. Here is a working gateway, plus the header-body agreement rule that will bite you.

A write tool that asks before it writes needs three things the MCP SDK does not give you: an approval bound to the exact diff, a precondition on the file it previewed, and an integrity-protected requestState. Verified end to end on @modelcontextprotocol/server 2.0.0 against protocol revision 2026-07-28, including the argument-swap that gets past a naive confirm.

Mapping 200 internal REST endpoints to 200 MCP tools puts 200 KB of JSON schema in front of every request. The 2026-07-28 spec also made the usual escape hatch illegal: tools/list MUST NOT vary per-connection, so per-session dynamic registration is gone. Here are the three levers that still work, with measured wire sizes and verified code on @modelcontextprotocol/server 2.0.0.

Tightening a team's default permission mode to Manual is a one-line settings change interactively and a silent outage in CI, because headless runs turn every ask into a deny and still report success. Measured on Claude Code 2.1.224, including the trust gate that drops your allowlist but keeps your mode.

The 1M-token context window is now the default on Claude Opus 5, Opus 4.8/4.7/4.6, Sonnet 5, and Sonnet 4.6, with no beta header and no long-context premium. Here is when deleting the vector store actually pays off, the 10x cache-read rule that decides it, the ~30% tokenizer inflation that breaks your sizing estimate, and the seven-step migration with a verification line on each one.

Claude Code 2.1.224 adds claude self-hosted-runner, a public beta that executes cloud sessions on machines you provision. Here is the setup, the one-user runner rule, and what still leaves your network.

The GitHub, Postgres, and Slack MCP servers from modelcontextprotocol/servers were archived in 2025 and their npm packages are deprecated. They pin SDK 1.0.1, which cannot negotiate past protocol 2024-11-05. Here is the audit script, the current replacement for each, and the two pointers in the archive README that are themselves stale.

Cross-session messaging landed on August 7, 2026. ListAgents and SendMessage move plain text between your sessions, and crossSessionInbound decides what actually arrives.

Cursor did not delete rules. It split them. This checklist sorts a .cursorrules file and a folder of .mdc rules into the four things they should be in Cursor 3.11: an AGENTS.md, a small set of surviving rules, skills, and subagents, then bundles the result as a plugin.

GitHub's August 6, 2026 changelog adds allowedMcpServers and deniedMcpServers to copilot/managed-settings.json. URL and argv matchers, deny-wins precedence, and a fail-closed default the older name-based registry never had.

A step-by-step checklist for retiring a hand-rolled while-loop agent and running the same job on @cursor/sdk 1.0.26. The tool bodies survive, the loop does not, and three things you probably rely on have no equivalent: a system prompt string, a tool allowlist, and per-turn control.

Replace a hand-rolled classifier-plus-switch router with AgentWorkflowBuilder.CreateHandoffBuilderWith in Microsoft.Agents.AI.Workflows 1.17.0. What breaks, the six migration steps, and the gotchas around agent Ids, descriptions, and context broadcast.

GitHub's August 3, 2026 changelog adds a comment trigger to Copilot cloud agent automations, replacing the issue_comment workflow plus PAT plus REST dispatch that teams have been hand-rolling since June.

A named subagent starts cold, a fork inherits your whole conversation and shares your prompt cache, and a background agent is a second Claude Code session entirely. The trap is the naming: /fork stopped being the in-session fork at v2.1.212 and /subtask took over.

Use declarative YAML when the graph is a sequential routing decision that non-developers change often. Use code-first WorkflowBuilder the moment you need parallelism, custom executors, or a non-Foundry agent. Here is the decision, the action catalog limits, and the code both ways.

Manual gates every tool call on you. Auto mode gates them on a classifier with 32 built-in block rules. The mode that surprises people is neither: acceptEdits auto-approves rm, mv, and sed, not just file edits. Measured on Claude Code 2.1.123.

Microsoft.Agents.AI.GitHub.Copilot 1.16.0 shipped on July 30, 2026. The Copilot CLI runtime now sits behind the ordinary AIAgent abstraction, permissions are deny-by-default, and Squad plugs a whole agent team in as one AIAgent.

Claude Code only consults Edit(path) and Read(path) rules. A Write(src/**) allow or deny rule is accepted and then silently ignored. Use Edit() instead.

Visual Studio 2026 18.8 puts expert-authored .NET and Azure agent skills in the tool picker under a Built-in category, disabled by default. The default is the interesting part.

On 2026-07-31 Microsoft shipped a polyglot unit-test agent in dotnet/skills. The interesting part is the mandatory pre-completion gate that pseudo-mutates your assertions before the agent is allowed to say it is done.

Agent skills and MCP servers in GitHub Copilot code review went GA on 2026-07-29. Here is where the files live, why skills load from the head branch, and why every MCP tool call in a review is read-only.

Claude Code 2.1.212+ moves any main-conversation MCP tool call still running at two minutes into a background task. Set CLAUDE_CODE_MCP_AUTO_BACKGROUND_MS=0 to stop it, raise the threshold to move the line, or send progress notifications from the server.

Project MCP servers stuck at Pending approval are not misconfigured. Run claude interactively in the folder, accept the workspace trust dialog, then approve the servers.

Visual Studio 18.9 Insiders 2 adds a per-model thinking effort control with Low through Max levels, exposing the same reasoning-effort dial the underlying model APIs take.

Folder names starting with t, b, n, r or u make a Windows path parse cleanly as JSON and still resolve wrong. Use forward slashes or double every backslash.

ModelContextProtocol 2.0.0 landed on 2026-07-28 with the stateless HTTP transport on by default, Multi Round-Trip Requests replacing server-initiated elicitation, and an analyzer warning on ElicitAsync and SampleAsync.

On 2026-07-23 GitHub shipped the MCP 2026-07-28 revision ahead of the spec date. The notable part is the subtraction: no initialize handshake, no Mcp-Session-Id, no Redis.

Two ways to make a coding agent land its own work: Claude Code 2.1.198+ background sessions commit, push, and open a draft PR from their worktree with no config, or wrap any agent CLI in a git worktree plus gh pr create --draft. Covers the worktree guardrails, the subagent-vs-session distinction, the GITHUB_TOKEN trigger trap, and why there is still no off switch.

Cursor Router shipped on July 22, 2026. Auto now classifies every request and routes it to a different model, and the Cost, Balance, and Intelligence modes change both the quality you get and how you are billed.

By default a headless Claude Code run emits only tool_use and tool_result blocks from its subagents, so the delegated reasoning is invisible. Pass --forward-subagent-text (Claude Code 2.1.211+) to get subagent text and thinking in the stream-json output, and demultiplex it by parent_tool_use_id.

Version 2.1.219 raises the default subagent spawn depth from 1 to 3, adds a workflowSizeGuideline settings key, and ships a fail-closed sandbox network allowlist.

Claude Code, Cursor, and the GitHub Copilot coding agent all ship host allowlists for outbound traffic, and all three default to something looser than you want. The exact settings keys, a policy you can copy, and the four surfaces the allowlist does not cover.

Microsoft Agent Framework shipped Declarative Workflows 1.0 on July 23, 2026. Python's agent-framework-declarative 1.0.0 reaches parity with the .NET Microsoft.Agents.AI.Workflows.Declarative package, so multi-agent routing lives in YAML instead of C#.

The legacy HTTP+SSE transport used two endpoints and a sticky connection. Streamable HTTP uses one. Here is the step-by-step migration for the TypeScript and Python SDKs, the client configs you have to repoint, and the proxy buffering gotcha that makes the new endpoint look broken.

How to convert .github/prompts/*.prompt.md into .github/skills/<name>/SKILL.md so GitHub Copilot loads them automatically. What breaks, what maps 1:1, and how to verify each skill fires.

Version 2.1.218 moves /code-review off your main conversation into a background subagent, and fork-context skills now background by default. Here is what changed and how to opt out.

Pick Copilot coding agent when the work starts and ends on GitHub and you want issue-to-PR with native branch protection. Pick Cursor cloud agents when you want a live, editor-attached VM, multi-repo tasks, and to take over the run by hand. Full feature matrix, the 59-minute cap, the Actions-approval gotcha, and June 2026 billing for both.

Version 2.1.213 caps concurrent subagents and stops nested spawns by default, building on the per-session limits from 2.1.212. Here are the new defaults and env vars.

Claude Code compacts, then a single oversized file read or tool result immediately refills the window and it compacts again. Drop the item with /clear, read files in slices, and force big output to disk.

Sequential for pipelines, concurrent for fan-out, group chat for moderated rounds, handoff for routing, magentic for open-ended planning. The C# builders and how to choose.

An MCP server on Node 16 warns EBADENGINE at install, then dies with 'fetch is not defined' on the first tool call. Upgrade to Node 18+ (20+ for the 2.x SDK) or polyfill the web globals.

Claude Code logs every MCP server stderr line at [ERROR] and marks working servers as failed. If your tools still run, it is cosmetic. Here is how to confirm it and quiet the noise.

There is no single Skill type in the Microsoft Agent Framework, but you can package domain expertise as a reusable agent, reuse it in-process with AsAIFunction, and advertise it across frameworks as an A2A AgentSkill. Full walkthrough on Agent Framework 1.0 and .NET 11.

Validate the MCP config file when several servers disappear after an edit. Check JSON syntax, client-specific schemas, scope and encoding without assuming every client fails alike.

Copilot CLI 1.0.66 and SDK 1.0.5 (public preview, July 1 2026) add per-session AI credit limits. Cap what a single agent run can spend with --max-ai-credits, /limits set, or SessionLimitsConfig, and understand why it is a soft cap that can overshoot.

Claude Code 2.1.208 (July 14, 2026) adds vimInsertModeRemaps, so vim users can map two-key insert-mode sequences like jj to Escape in the prompt editor. Plus a screen reader mode and a corporate process wrapper.

Commit .cursor/mcp.json for the IDE, register shared servers under Dashboard > Integrations & MCP for cloud agents, and keep secrets out of git with ${env:...}. The full two-surface setup for Cursor 3.11 (July 2026), including why the repo file alone does not reach cloud agents.

Use Cursor 3.8's /automate skill to spin up a cloud agent that fires on GitHub events. Covers the five GitHub triggers added June 18, 2026, tool config, repo scope, and the Max Mode billing gotcha.

Claude Code's Week 28 releases (v2.1.202-v2.1.206, July 6-10 2026) teach auto mode to pause before an rm -rf whose path came from a variable that expanded to nothing, closing the classic rm -rf / footgun.

Cursor 3.11 (July 10, 2026) adds side chats, durable parallel agent threads you spawn with /side or /btw and pull back into the main conversation with an at-mention. Plus Cmd+K transcript search and new cloud agent hooks.

Cursor 3.11 (July 10, 2026) lets cloud agents run hooks that see the conversation itself. Wire up beforeSubmitPrompt, afterAgentThought, afterAgentResponse, and subagentStart in .cursor/hooks.json to log every prompt, thinking block, and delegated task, then gate the risky ones.

A step-by-step checklist for lifting a hand-rolled Anthropic tool-calling loop onto a standalone MCP server. The tool bodies move almost verbatim; what changes is where the schema comes from, how results are wrapped, and how errors cross the process boundary.

A step-by-step checklist for moving an existing LangChain agent off inline @tool functions onto a standalone MCP server that any client can call. Covers extracting tools into FastMCP, re-wiring the agent with langchain-mcp-adapters MultiServerMCPClient, the sync-to-async switch, transports, and the gotchas that bite mid-cutover.

GitHub Copilot's modernize-dotnet agent shipped as a portable plugin on July 9, 2026. It now runs in VS Code, the Copilot CLI, and on GitHub, with an assess to plan to execute workflow whose artifacts get committed to your repo for review.

A step-by-step checklist for moving a .NET app off the raw OpenAI 2.12 SDK onto the provider-neutral Microsoft.Extensions.AI 10.7 IChatClient. Covers the AsIChatClient bridge, the CompleteChatAsync-to-GetResponseAsync rewrite, streaming, tool calling, DI registration, and the gotchas that bite mid-cutover.

VS Code 1.128 (July 8, 2026) lets one Claude agent-host session hold several parallel chats, each with its own history, title, and model. Here is what chat.agentHost.enabled actually unlocks and how the quick-chat and BYOK pieces fit.

Claude Sonnet 5 (claude-sonnet-5) shipped June 30, 2026 and now backs the 'sonnet' alias in Claude Code. Its new tokenizer emits about 30% more tokens for the same text, so cost estimates and max_tokens limits tuned for Sonnet 4.6 need a recount.

A step-by-step checklist for moving an existing Semantic Kernel 1.77 .NET app to Microsoft Agent Framework 1.13. Covers the Kernel-to-AIAgent rewrite, plugins-to-tools, thread-to-session, the KernelFunction compatibility bridge, DI changes, and the gotchas that bite mid-cutover.

Claude Code v2.1.198 (July 1, 2026) flips subagents to background execution by default, so the main agent keeps working while they run, and background agents that touch code now auto-commit, push, and open a draft PR when they finish.

Both let one agent spawn isolated workers from a Markdown file, but Claude Code nests five levels deep with per-agent tool allowlists and worktree isolation, while Cursor keeps it to two levels with a single readonly switch and reads Claude's format for free. Pick by where your agents run, not by brand.

Build a skill to change how Claude works, a subagent to protect your context window, and an MCP server to reach a system Claude cannot otherwise touch. They solve three different problems, not one. Here is the decision, the mechanics, and the config for each.

Claude Code v2.1.200 (July 3, 2026) renames the 'default' permission mode to 'Manual' across the CLI, VS Code, and JetBrains, and stops AskUserQuestion dialogs from auto-continuing. The config value stays 'default', with 'manual' accepted as an alias.

Use CodeAct (the agent writes executable code as its action) when your tasks chain many tools, loop, or move large data, and you can afford a sandbox. Use the JSON tool-calling loop for a handful of discrete, high-stakes actions where a code interpreter is overkill or unsafe. CodeAct wins on token cost and multi-step success rate; tool calling wins on safety and simplicity.

MCP connects one agent to its tools, A2A connects independent agents to each other. They are not competitors. Add MCP first, reach for A2A only when you have multiple separately deployed agents. Here is the wire-level difference and the code.

Cato AI Labs disclosed CVE-2026-50548 and CVE-2026-50549, a pair of 9.8 CVSS flaws in Cursor's terminal sandbox. A poisoned MCP response or web result can escape the sandbox and run code. Cursor 3.0 is the fix.

Use stdio for a local server one client launches, use Streamable HTTP for anything remote or multi-client, and do not build new HTTP+SSE servers -- that transport was deprecated in the 2025-03-26 MCP spec. Here is the decision, the wire-level differences, and the code for each.

On 2026-06-30 Microsoft showed the Binlog MCP Server running unattended in a GitHub Agentic Workflow, so an agent reads the .binlog and comments a root cause the moment a CI build breaks.

High memory usage and context overflow are two different problems in Claude Code. Raise the Node heap for RAM, use /context and /compact for the window, /heapdump to diagnose.

If MCP tools disappear around Claude Code compaction, distinguish a failed connection from deferred tools, authentication, permissions and discovery before reconnecting.

Claude Code v2.1.191 (June 24, 2026) extends /rewind so you can restore conversation and code state from before you ran /clear, recovering context that used to be gone for good.

MCP error -32000: Connection closed reports a closed transport in the TypeScript SDK. Diagnose startup failures, later disconnects, paths, stdout and HTTP separately.

The new sandbox.credentials setting in Claude Code v2.1.187 denies reads of credential files and unsets secret env vars before sandboxed Bash commands run. Here is why the default read policy was a hole, and how to close it.

Wire the Agent Governance Toolkit into a Microsoft Agent Framework 1.0 agent so every tool call is checked against a YAML policy and written to a tamper-evident audit trail. Full C# middleware, policy file, and a hash-chained audit sink.

Cursor 3.9 ships a plugin system and a unified Customize page so skills, rules, MCP servers, commands, and hooks travel together as one versioned unit.

Cursor 3.7+ lets you run Bugbot before you push with the /review command. Here is how local review works, how the patch ID dedup stops you paying twice, and the one thing it cannot do yet.

A step-by-step guide to taking a Microsoft Agent Framework agent from your laptop to a managed Foundry Hosted Agent: the C# host code, the azd deploy flow, identity, scaling, and the gotchas that bite in preview.

When a GitHub Actions job goes red, the Fix with Copilot button hands the failure to the Copilot cloud agent: it reads the logs, pushes a fix to your branch, and tags you for review. Here is where the button lives, the May 18 / June 4 2026 rollout, the Approve and run workflows gotcha that stalls re-runs, how billing works per session, and when to reach for the REST API instead.

POST a prompt to /agents/repos/{owner}/{repo}/tasks and Copilot's cloud agent spins up, writes code, and opens a PR. Here is the exact request, the X-GitHub-Api-Version: 2026-03-10 header, the user-to-server token gotcha that breaks GitHub App installs, a polling loop over the eight task states, and a fan-out script that dispatches the same migration across many repos.

Microsoft shipped Microsoft.AITools.BinlogMcp on 2026-06-17, an MCP server that exposes 15 tools so Claude or Copilot can diagnose build failures and slow targets straight from a .binlog file.

As of the June 11, 2026 change, GitHub Agentic Workflows run on the built-in GITHUB_TOKEN. Add copilot-requests: write, drop the PAT, recompile the lock file, and let safe-outputs apply writes from a privileged step. Full issue-triage example, the token fallback chain, and the two cases where you still need a custom token.

Claude Code v2.1.183 (June 19, 2026) blocks git reset --hard, git clean -fd, and terraform/pulumi/cdk destroy in auto mode unless you asked for them, closing the agentic loophole where one bad turn nukes uncommitted work.

Define named subagents on agents in the Cursor SDK, let a code-reviewer delegate to a test-writer through the built-in Agent tool, and understand the real nesting depth cap: a subagent spawned by another subagent cannot spawn further ones, despite the changelog's 'and so on'.

By default a local Cursor SDK agent runs every tool call without asking. Set local.autoReview to route Shell, MCP, and Fetch calls through the classifier, then steer it with the autoRun block in permissions.json. With code, the three-step evaluation order, and why none of it is a security boundary.

For months availableModels restricted the model picker but left the Default option wide open. Claude Code 2.1.175 adds enforceAvailableModels so admins can finally pin a strict model allowlist.

The Cursor SDK already persists agent state to disk so Agent.resume() can pick a conversation back up after a crash. This walks the SqliteLocalAgentStore default, the JsonlLocalAgentStore you can commit to git, and how to implement the LocalAgentStore interface for Postgres, Redis, or an in-memory CI store.

Pass local.customTools to a Cursor SDK agent and the model calls your in-process functions through the built-in custom-user-tools MCP server. No stdio handshake, no separate process, no transport bugs. Local agents only: cloud agents throw ConfigurationError.

Use Quartz.NET when an LLM job must run on a real cron and never overlap itself, Hangfire when each run must survive a restart and retry on rate limits, and a plain BackgroundService only for a loose in-process loop. A decision matrix with the cron and concurrency gotchas that pick for you.

Rule-based checks are your floor and they are non-negotiable; LLM-as-judge is the ceiling you add when code quality, not just correctness, is what you ship. Here is the decision, with cost, latency, and the SWE-bench gap that proves why.

Claude subagents give you orchestration-level parallelism out of the box: one agent spawns isolated sub-contexts that run concurrently. OpenAI Assistants never had that, and it shuts down August 26, 2026, so new parallel work belongs on the Responses API plus your own fan-out. Here is how the two models actually differ and which to reach for.

Claude Code v2.1.169 (June 8, 2026) ships a --safe-mode flag that disables every customization for clean troubleshooting, and a /cd command that moves your session to a new directory without breaking the prompt cache mid-run.

The cache read and write multipliers are identical on both models, so the break-even point is the same. What differs is the minimum cacheable prefix (1,024 vs 4,096 tokens), the per-token dollar savings, and a new Opus 4.7 tokenizer that counts up to 35% more tokens. With claude-sonnet-4-6 and claude-opus-4-7 pricing math.

Two ways to call Claude from C#: the official Anthropic .NET SDK directly, or the provider-neutral Microsoft.Extensions.AI IChatClient that wraps it. When each wins, what you lose at the abstraction boundary, and why it is not actually either/or. With claude-opus-4-8 and claude-sonnet-4-6 examples.

Anthropic shipped a free security-guidance plugin for Claude Code that scans the agent's own edits for vulnerabilities in three layers, from a no-cost pattern match to an agentic review on commit.

At Build 2026 GitHub shipped Copilot SDK 1.0 GA with a first-class .NET package. You can now drive the same planning, tool-calling, and multi-turn agent runtime from C# code, BYOK included.

For a new .NET agent in 2026, start on Microsoft Agent Framework 1.0. Semantic Kernel is in maintenance mode. Here is the side-by-side and the one case where SK still wins.

Anthropic is splitting programmatic Claude usage off your subscription on 2026-06-15. Here is what counts as programmatic, the per-plan credit, and how to keep your CI agents from silently stalling.

All three hit 1.0. Pick Microsoft Agent Framework if you live in Azure and .NET, LangChain/LangGraph for vendor-neutral graph orchestration, LlamaIndex for retrieval-grounded agents.

Use custom tool calling for one app you own end to end, MCP for any integration you want reused across Claude Code, Cursor, and ChatGPT, and OpenAPI plugins only as a bridge when you already have a spec. MCP is the cross-client standard in 2026; plugins are legacy.

Claude Code wins on raw agent quality and predictable flat pricing, Cursor wins as the editor you live in with the best multi-model routing, and GitHub Copilot wins when the work starts and ends on GitHub. The June 2026 token-billing shift is the tiebreaker for cost.

For a large .NET 11 / C# 14 solution, Claude Code wins on agent quality and runs anywhere a terminal does. Cursor wins if your team wants a GUI and tab completion, as long as you can live without C# Dev Kit. Aider wins on cost and openness.

After an MSIX update, Claude Desktop on Windows reads claude_desktop_config.json from a virtualized path while Edit Config opens the old %APPDATA% one. Edit the file under AppData\Local\Packages\Claude_pzs8sxrjxfjjc and restart.

Anthropic shipped Opus 4.8 on May 28, 2026 with Dynamic Workflows, a research preview in Claude Code that writes a JavaScript orchestration script to run tens to hundreds of subagents in parallel, capped at 1,000 per run.

GitHub MCP tools show up but every call returns empty or 'Bad credentials'? The token is unset. Put the PAT in the env block, verify with curl, done.

This banner is a pause, not a failure. It maps to the API's pause_turn stop reason (default 10 server-tool iterations). Click Continue, or in code re-send the assistant response. Full fix here.

Dart 3.12 ships dart mcp-server, the official MCP bridge into the Dart and Flutter toolchain. Register it once in Claude Code, Cursor, or Codex CLI and your agent gets hot reload, pub.dev search, and live widget introspection without copy-pasting a DTD URI.

Claude Desktop's claude_desktop_config.json only validates stdio servers. Drop a 'url' field in and it silently strips the entry, crashes on startup, or boots with zero tools. Use a custom connector for remote URLs and mcp-remote as a stdio bridge for local HTTP servers.

Step-by-step guide to the Cursor in Jira integration (launched May 19, 2026): install the Marketplace app, assign a ticket to @Cursor, wire repository access and automation rules, and read the PR the cloud agent links back.

Aider is git-first by default. To edit files outside the repo, pass them on the command line, use /read for reference docs, drop --no-git for unversioned dirs, or symlink. Five working patterns with exact flags.

Five MCP servers can burn 55k tokens and wreck tool-selection accuracy before Claude does any work. How to fix it in Claude Code 2.1.x with ENABLE_TOOL_SEARCH and alwaysLoad, on the raw API with the tool search tool and defer_loading, and on the MCP connector with mcp_toolset. Anchored to claude-opus-4-7, claude-sonnet-4-6, and the 20251119 tool search variants.

If you came from Semantic Kernel looking for 'skills,' the Microsoft Agent Framework 1.0 calls them function tools and builds every one from AIFunctionFactory.Create. Here are the three ways to author one in C# -- an inline lambda, a named method, or a class of related tools -- plus what the declarative YAML 'file' approach can and cannot do.

Your agent's tool call fails with Pydantic's 'Extra inputs are not permitted'. The model added a field your structured argument forbids. Turn on strict tool use so the grammar blocks it, relax the validator, or recover in the loop.

Diagnose MCP ECONNREFUSED safely: check the listener and address, wait with a deadline, retry nested connection errors, and distinguish TCP readiness from MCP initialization.

Cursor 3.4 (May 13, 2026) lets one cloud agent environment include multiple repositories, adds Dockerfile build secrets, layer-cached rebuilds that run 70% faster, and an agent-led setup step that validates credentials before the first run.

Copilot Chat reads your .github/copilot-instructions.md fine, but Agent mode and *.instructions.md files often look ignored. Here is the actual checklist: settings, file locations, applyTo globs, and how to prove the file made it into context.

Cursor's Apply silently cancels on big files because the Fast Apply model has an implicit size ceiling. Shrink the edit scope, clean git state, or fall back to a unified diff. Six ranked fixes for Cursor 3.3.

Diagnose MCP disconnects across Windows and WSL: check the actual launcher, stdio output, NAT versus mirrored networking, and evidence of process termination.

On May 17, 2026 GitHub flipped the default Copilot model on Business and Enterprise plans from GPT-4.1 to GPT-5.3-Codex. GPT-4.1 stays free until June 1, then it falls under usage-based billing. Here is what changes for pinned models in your repo and CI.

A 429 rate_limit_error on claude-sonnet-4-6 in a long agent loop is almost always ITPM, not RPM. Read retry-after, cache the system prompt, and gate on anthropic-ratelimit-input-tokens-remaining. Step-by-step fix with code.

.NET 11 Preview 4 bundles the mcpserver project template directly into the SDK. No separate Microsoft.McpServer.ProjectTemplates install, no preview feed dance. Pick stdio or HTTP transport, opt into Native AOT, and dotnet new mcpserver -o MyServer is the whole setup.

Aider 0.86 hit the token limit mid-refactor. The fix is /clear, /drop, --map-tokens, and switching to architect mode with Claude Sonnet 4.6's 1M window. Step-by-step repro, error breakdown, and config.

Why your Claude tool call fails schema validation, in both flavours: the API rejecting your tool definition at request time, and Claude returning a tool_use block your runner cannot accept. Concrete fixes for each, with strict mode, oneOf/anyOf, additionalProperties, and the retry loop pattern.

Diagnose MCP stdio startup failures: separate protocol stdout from logs, use a complete SDK server, check launch paths and buffering, and configure startup timeouts.

A 2026 walkthrough for wiring RAG into Claude Code 2.1.x: when agentic grep stops scaling, how to attach a hybrid BM25 + dense vector MCP server, how to wrap a retrieval CLI in a custom skill, and how Anthropic's contextual embeddings technique pushes recall above 92%. Anchored to claude-sonnet-4-6, claude-opus-4-7, and Claude Context 0.x.

A 2026 playbook for keeping Claude Code's 200k token context lean in a monorepo: launch from the subtree you are touching, split CLAUDE.md into nested files that load on demand, push path-scoped rules into .claude/rules/, use skills and subagents for the noisy reads, and exclude other teams' files with claudeMdExcludes. Anchored to Claude Code 2.1.x, claude-sonnet-4-6, and claude-opus-4-7.

On May 11, 2026, Cursor shipped effort levels for Bugbot. Default finds 0.7 bugs per review, High pushes it to 0.95, and Custom lets you describe in plain English when each mode should kick in.

Place rolling cache_control breakpoints across messages, respect the 20-block lookback, and refresh the 5-minute TTL automatically so a 50-turn agent loop pays the prefix once, not fifty times. Verified against anthropic 0.42 (Python) and @anthropic-ai/sdk 0.30 (Node) in May 2026.

Cursor 3.3 (May 7, 2026) ships async subagents that work on independent steps of a plan at the same time, a quick action that splits one chat into multiple pull requests, and a redesigned PR workflow that keeps reviews, commits, and changes in one place.

Build a working LLM-as-judge eval harness for a coding agent in Python: golden tasks, deterministic checks, a rubric judge on Claude Sonnet 4.6, calibration against human labels, and a CI gate that fails the build when scores regress.

GitHub deprecated claude-sonnet-4 on May 6, 2026 across Copilot Chat, inline edits, ask and agent modes, and code completions. Recommended migration target is Claude Sonnet 4.6. What to grep for in your repo before the next pinned model selection silently breaks.

Cursor is the best place to plan a refactor. Aider is the best place to execute it from a terminal with cheap models and atomic git commits. This guide shows the exact pipe: dump the Cursor chat to markdown, hand it to Aider as a read-only context file, and run an architect/editor split that finishes the work.

Create a Claude Code browser-testing subagent with an inline Playwright MCP server, explicit tools, an isolated browser profile, and evidence-based pass/fail reporting.

Wrap an Agent Framework Workflow in Microsoft.Agents.AI.DurableTask and each executor step is checkpointed. Crash, redeploy, restart - the run continues where it stopped.

Turn the unwritten rules in your repo into a SKILL.md that GitHub Copilot loads on demand. Frontmatter, descriptions that route, file references, and how to verify it actually fires.

Wrap an AIFunction in ApprovalRequiredAIFunction and the agent stops mid-run to ask permission. Here is how the request and response flow works in C#.

Wire a Microsoft.SemanticKernel 1.75.0 plugin into a hosted BackgroundService on .NET 11 and invoke its KernelFunctions on a PeriodicTimer schedule. Covers DI scopes, [KernelFunction] resolution, prompt-cache-friendly invocation, cancellation, and the lifetime gotchas that bite when you move a plugin off the request path.

Claude Code v2.1.128 (May 4, 2026) ships --plugin-dir support for .zip archives, makes EnterWorktree branch from local HEAD, and stops the CLI from leaking its own OTLP endpoint into Bash subprocesses.

Wire an EF Core 10 DbContext into a Model Context Protocol server so Claude Code, Cursor, or any compliant client can run safe, scoped queries against your database. Covers IDbContextFactory lifetime, read-only projections, schema discovery tools, AsNoTracking, parameterised filters, row-level scoping, and the destructive-tool gates you need before letting an agent touch UPDATE.

Cursor's new @cursor/sdk public beta exposes the same runtime, harness, and models that drive the desktop app, CLI, and web UI as a TypeScript package. You get sandboxed cloud VMs, subagents, hooks, MCP, and token-based pricing in a few lines of code.

Claude Code v2.1.126 ships claude project purge, a new CLI subcommand that deletes every transcript, task, file-history entry, and config block tied to a project path in a single shot. Includes --dry-run, --yes, --interactive, and --all.

Wire AIFunctionFactory.Create, ChatOptions.Tools, and ChatClientBuilder.UseFunctionInvocation in Microsoft.Extensions.AI 10.5 so an IChatClient can call your .NET methods automatically. Covers OpenAI and Azure OpenAI providers, the FunctionInvokingChatClient knobs that actually matter (iteration limits, concurrent calls, approval prompts, error handling), and streaming responses with tools.

Microsoft's new Microsoft.AgentGovernance package wraps MCP tool calls with a policy kernel, a security scanner, and a response sanitizer. Here is what each piece does and how the wiring looks in C#.

Take an existing Semantic Kernel plugin with [KernelFunction] methods and turn it into a Model Context Protocol server other agents can call. Covers the drop-in WithTools(kernel) bridge, the native [McpServerTool] rewrite, parameter binding, dependency injection, and the gotchas that bite during the cutover.

Wire up anthropics/claude-code-action@v1 so every pull request gets an autonomous Claude Code review with no @claude trigger. Includes the v1 YAML, claude_args for claude-sonnet-4-6 vs claude-opus-4-7, inline-comment tooling, path filters, REVIEW.md, and the choice between the self-hosted action and the managed Code Review research preview.

Claude Code v2.1.122 adds the ANTHROPIC_BEDROCK_SERVICE_TIER environment variable, sent as the X-Amzn-Bedrock-Service-Tier header. Set it to flex for a 50 percent discount on agent calls or priority for faster responses, without touching SDK code.

Stream Claude responses from an ASP.NET Core 11 minimal API end-to-end: the official Anthropic .NET SDK, TypedResults.ServerSentEvents, SseItem, IAsyncEnumerable, cancellation flow, and the gotchas that buffer your tokens silently. With Claude Sonnet 4.6 and Opus 4.7 examples.

cowork-terminal-mcp v0.4.1 bridges Claude Cowork's sandboxed VM to your host shell. One tool, stdio transport, hard-pinned Git Bash on Windows.

A practical guide to turning the JSONL files Claude Code writes under ~/.claude/projects/ into shareable PDFs using jsonl-to-pdf, with sub-agent nesting, secret redaction, compact and dark themes, and CI-friendly batch recipes.

Add prompt caching to a Python or TypeScript Anthropic SDK app, place cache_control breakpoints correctly, and read cache_read_input_tokens and cache_creation_input_tokens to compute a real hit rate. With pricing math for Claude Sonnet 4.6 and Opus 4.7.

A 2026 playbook for CLAUDE.md files that Claude Code actually follows: the 200-line target, when to use path-scoped rules in .claude/rules/, @import hierarchy and 5-hop max depth, the user-message vs system-prompt gap, the line between CLAUDE.md and auto memory, and when to give up and write a hook instead. Anchored to Claude Code 2.1.x and verified against the official memory docs.

Claude Code v2.1.119 expands --from-pr beyond github.com. The CLI now accepts GitLab merge-request, Bitbucket pull-request, and GitHub Enterprise PR URLs, and a new prUrlTemplate setting points the footer PR badge at the right code-review host.

Three ways to put Claude Code on a schedule that triages GitHub issues unattended in 2026: cloud Routines (the new /schedule), the claude-code-action v1 with cron + issues.opened, and the session-scoped /loop. Includes a runnable Routine prompt, a complete GitHub Actions YAML, jitter and identity gotchas, and when to pick which.

GitHub Copilot for VS Code shipped Bring Your Own Key on April 22, 2026. Wire your own Anthropic, OpenAI, Gemini, OpenRouter, or Azure account into Chat, or point at a local Ollama or Foundry Local model. Billing skips the Copilot quota and goes straight to the provider.

Build a working Model Context Protocol server in C# 14 / .NET 11 using the official ModelContextProtocol 1.2 SDK. Covers stdio transport, [McpServerTool] attributes, dependency injection, the stderr logging trap, and registration with Claude Code, Claude Desktop, and VS Code.

Build a working Model Context Protocol server in Python using the official mcp 1.27 SDK and FastMCP. Covers Pydantic schemas, the stdio stdout trap, mcp dev / mcp install, and registration with Claude Desktop and Claude Code.

Step-by-step guide to wrapping any command-line tool as a Model Context Protocol server using the TypeScript SDK 1.29. Covers the stdout trap, child_process patterns, error propagation, and a full working git server.

Visual Studio 2022 17.14.30 bundles the Azure MCP Server into the Azure development workload. Copilot Chat can hit 230+ Azure tools across 45 services without installing a thing.

Visual Studio 18.5 GA ships a guided Debugger Agent workflow in Copilot Chat that forms a hypothesis, sets breakpoints, rides along through a repro, validates against runtime state, and proposes a fix.

Visual Studio 2026 18.5.0 lets GitHub Copilot load Agent Skills from .github/skills, .claude/skills, and ~/.copilot/skills. Reusable SKILL.md instruction packs travel with your repo.

GitHub Copilot Modernization is pitched as an Assess, Plan, Execute loop for migrating legacy .NET apps. The assessment phase is where the value lives: an inventory report, categorized blockers, and file-level remediation guidance you can diff like code.

Microsoft Agent Framework hits 1.0 with stable APIs, multi-provider connectors, multi-agent orchestration, and A2A/MCP interop. Here is what it looks like in practice on .NET 10.

The .NET team shares ten months of real data on running GitHub's Copilot Coding Agent in dotnet/runtime: 878 PRs, a 67.9% merge rate, and clear lessons on where AI-assisted development helps and where it still falls short.

Microsoft's free generative AI course for .NET developers ships Version 2, rebuilt for .NET 10 and migrated from Semantic Kernel to Microsoft.Extensions.AI's IChatClient pattern.

How to wire Model Context Protocol (MCP) servers in C# on .NET 10 using microsoft/mcp. Covers tool contracts, input validation, auth, observability, and production-readiness patterns.