Copilot Studio Bring Your Own Model: Microsoft Foundry Governance and Security

Copilot Studio Bring Your Own Model: Microsoft Foundry Governance and Security

TL;DR

Copilot Studio can use a model you host in Microsoft Foundry in a prompt through bring your own model (BYOM) on the standard harness. That doesn’t replace the agent’s primary orchestration model, and the Microsoft Copilot harness doesn’t support the prompt tool.

BYOM gives your platform team control over the deployment and its applicable guardrails, quota, diagnostics and Azure costs. Agent orchestration, identity and sharing remain with Copilot Studio and the wider Microsoft governance tools.

The documented connector uses an API key. A dedicated Foundry resource contains the risk of a resource-wide key better than a project in a shared resource.

In a hurry? Jump to the resource decision or the nine go-live checks, then come back for the detail.

Read more
GitHub Copilot Harness Security: Patch, Pin and Govern Your Coding Agents

GitHub Copilot Harness Security: Patch, Pin and Govern Your Coding Agents

TL;DR

In one week VS Code fixed ten security advisories, eight of them involving MCP servers, agent tools or the agent host, and froze the Local harness for removal in February 2027. Visual Studio moved Copilot Chat onto the Copilot harness, Copilot CLI tied its built-in MCP server to policy, and Git fixed a clone bug that an agent can trigger just by following Git’s own advice.

Treat the editor fleet like any other agent runtime. Patch to a version floor, pin everyone to the Copilot harness (the one that enforces managed sandbox and permission policy), police MCP, permissions and customisations through Copilot’s managed settings, and prove it with diagnostics, telemetry and a test you expect to fail.

In a hurry? Jump to the version floor, the managed baseline or how to prove it, then come back for the why.

Read more
AI Agents Exploit Leaked Keys in Minutes: Go Keyless on Azure

AI Agents Exploit Leaked Keys in Minutes: Go Keyless on Azure

TL;DR

A recent threat intelligence report describes an AI agent moving from searching GitHub for application secrets to exfiltrating Azure Key Vault data in five minutes. That’s one observed case, not a typical benchmark.

Use managed identities and federation instead of stored credentials, then disable key authentication once callers have migrated. Tokens can still be stolen, so least privilege, monitoring and incident response remain essential.

I spend a lot of my time in the layer between AI agents and the things they call. A model key in an app setting can look like a harmless shortcut during a proof of concept, but the gap between a leak and the response is getting harder to defend.

In a hurry? Jump to the keyless playbook or the nine checks before release, then come back for the threat and the tradeoffs. The product guidance below was checked on 15 November 2026.

What the threat intelligence report found

On 5 November, Microsoft Threat Intelligence reported that threat actors were using agentic tooling to search public GitHub repositories for exposed credentials, including application secrets and AI inference API keys. The agents analysed the results and carried out follow-on actions with little human intervention.

A stolen model key can fund someone else’s inference, while an exposed application secret can open whatever its identity is permitted to reach.

Read more
GitHub Copilot CLI vs Local vs Cloud: Agents Explained (2026)

GitHub Copilot CLI vs Local vs Cloud: Agents Explained (2026)

TL;DR

The four agent types I described in January are no longer the right map for VS Code. Choose a harness, where the session runs and a model, then set the role and permissions.

The Copilot harness is now the default. It shares a runtime with other Copilot products and runs through the Agent Host, so a session can outlive its editor window, but not a stopped host.

Cloud sandboxes let work continue without your laptop. Under GitHub AI Credit billing, sub-agents consume tokens at their own models’ rates, so context isolation is still useful, but it isn’t free.

Comparing GitHub Copilot CLI vs Local vs cloud? They aren’t three equivalent agent types. Copilot CLI is a terminal interface, Local is a VS Code harness, and cloud describes where the agent’s tools run. The Copilot SDK is the programmable way to embed the Copilot runtime in your own application, not another execution location.

This is Part 2 of my GitHub Copilot agents guide: the current comparison, including what changed since the original four types.

In a hurry? Jump to the updated decision guide, then come back for the architecture and the money bit.

Ten months is a long time in agent land

When Part 1 went out on 10 January, I split GitHub Copilot agents into Local, Background, Cloud and Sub-agents. It was a useful way to explain the workflows, but it mixed together where an agent ran, how you interacted with it and how it delegated.

Since then, VS Code has moved to weekly releases, GitHub has rebuilt Copilot billing, and the old boxes have stopped lining up with the controls in front of us.

The better mental model is one Copilot engine with many cockpits, alongside other providers’ harnesses. This post is a November 2026 snapshot, checked against the primary sources on 3 November, covering VS Code 1.144 and GitHub’s 28 October cloud rollout.

Read more
Play SHIP IT: The GitHub Universe 2026 Announcements Game

Play SHIP IT: The GitHub Universe 2026 Announcements Game

GitHub Universe 2026 brought a stack of updates across Copilot, developer workflows, automation, security and platform engineering. I built a more entertaining way to catch up.

SHIP IT is a 3D arcade game with five sectors and all 41 announcements from Universe 2026. Fly through the sectors, collect announcement cores, blast the blockers and beat each boss with what you learned.

GitHub Universe 2026, playable

Ready, player one?

Open the game, launch your mission and discover the announcements on the way to the main branch.

Play SHIP IT

No download. No sign-in. Keyboard and touch controls included.

Your mission

Each sector turns a major Universe theme into an arcade run. Collecting a core unlocks the announcement behind it, including the problem it solves, how it works, why it matters, availability and official links.

Miss an announcement and it circles back once. Finish a sector and you face a short quiz boss. Every answer, right or wrong, reveals the correct update, so the game keeps moving even when you miss one.

The Announcement Guide keeps everything you unlock in this browser. If you want the straight recap, open the Guide and turn on Show every announcement.

How to play

  • Use the left and right arrows or A and D to steer, then hold Space to fire.
  • Press Enter to start or continue, 1, 2 or 3 to answer a boss question and F for fullscreen.
  • On a phone or tablet, swipe to steer and tap to fire. On-screen controls appear automatically.

I designed and built SHIP IT as an independent interactive recap of GitHub Universe 2026. It is not an official GitHub product.

Read more
MCP Goes Stateless: No Handshake, No Sticky Sessions, Better AI Gateways

MCP Goes Stateless: No Handshake, No Sticky Sessions, Better AI Gateways

TL;DR

MCP 2026-07-28 removes the initialize handshake and protocol-level sessions, so each request can reach any server replica. For Azure gateways, the useful part is routing and rate limiting per tool from validated headers, without parsing JSON bodies.

Keep application state explicit, protect retry state and check streaming and tracing before removing affinity. Azure’s dedicated AI Gateway is still a preview, and its October resource change matters if you’re planning a pilot.

Running a remote MCP server behind a load balancer used to come with an awkward question: which instance remembers this client? If the server issued an Mcp-Session-Id and kept its session in memory, you needed affinity, shared storage or a deployment small enough to avoid the problem.

The 28 July specification release changes that model. Every request describes itself. A tool call no longer needs a handshake before it can do useful work, and the next call doesn’t have to find the same process.

I spend a lot of my time in the layer between agents and the things they call. From there, the interesting question isn’t just what changed in MCP. It’s what we can simplify in the gateway, what we can finally do per tool, and which responsibilities haven’t gone away.

In a hurry? Jump to the gateway checklist or the eight checks before go-live.

Updated 4 November 2026: the SDK sign-in guidance and AI Gateway migration notes below reflect documentation checked on that date.

Read more
AGENTS.md vs Copilot Instructions vs Cursor Rules vs CLAUDE.md: Which AI Context File to Use, and When (2026)

AGENTS.md vs Copilot Instructions vs Cursor Rules vs CLAUDE.md: Which AI Context File to Use, and When (2026)

TL;DR

  • AGENTS.md is the portable format for project instructions. Most major coding agents read it; Gemini CLI needs a setting.
  • Copilot also has its own instructions, rules for matching paths, custom agents and skills. .github/copilot-instructions.md reaches the most Copilot surfaces.
  • Within an AGENTS.md hierarchy, the nearest applicable file specialises its parents. Your explicit chat instructions take priority for the task.
  • Context files change agent behaviour. The research does not show that they reliably improve correctness, speed or cost.

Keep one lean source of verified project rules: AGENTS.md when several tools share the repo, or copilot-instructions.md for a Copilot team. Treat it as an operating guide, not a performance switch.

In a hurry? Jump to the quick comparison, then come back for precedence, the research and the decision guide.

If you use an AI coding agent every day, whether that’s GitHub Copilot, Cursor, Claude Code, Codex or Gemini CLI, you’ve felt this particular flavour of tedium: you keep typing the same rules into every prompt.

“Use Vitest, not Jest. Don’t touch /legacy. Named exports only. Return { data, error } from every endpoint.”

The agent obeys for one session, you close your editor, and tomorrow you type it all again. That isn’t a prompting problem. It’s a missing context layer: the middle tier between what you ask in the moment (the prompt) and the whole system you build around the model (the harness).

That layer has a name now. Several names, actually, and that’s exactly the problem: AGENTS.md, copilot-instructions.md, .cursorrules, CLAUDE.md, GEMINI.md, Skills, custom agents. They overlap, they compete, and they keep moving. In 2026 alone, Claude Code started reading AGENTS.md, Windsurf became Devin Desktop, and Copilot’s coding agent became the cloud agent. Almost nobody explains how they fit together or which one you should actually use.

This post untangles all of it: what each file is, how they interact, what the research says about whether they even work, and, most importantly, which file to reach for, and when.

TL;DR diagram: which file should you use?

Here’s the whole decision on one page. The rest of the post explains every box in it.

Decision tree for choosing an AI context file. With one tool: GitHub Copilot uses .github/copilot-instructions.md, Claude Code uses CLAUDE.md, Gemini CLI uses GEMINI.md, and Codex, Cursor, Devin, Jules or Zed use AGENTS.md. With several tools: one lean AGENTS.md as the shared source of truth, then bridges for Gemini CLI, Copilot Chat outside VS Code and instructions just for Claude. Nested files, rules for matching paths and SKILL.md files come only when you need them.

For example, Copilot in VS Code and Claude Code can share one AGENTS.md when there’s no CLAUDE.md. A Copilot team can start with .github/copilot-instructions.md. Cursor users alongside Copilot Chat in Visual Studio need both. A deploy or release procedure belongs in a SKILL.md, whichever instructions the repo uses.

Read more
AI Engineering Coach: Measure How You Actually Code with AI

AI Engineering Coach: Measure How You Actually Code with AI


🎯 TL;DR

AI Engineering Coach is an open-source VS Code extension from Microsoft that reads the local session logs your AI coding assistants already write, then turns them into a private analytics dashboard. It scores your prompting habits, flags anti-patterns, measures your AI-generated output, and surfaces repeated prompts you could promote into reusable skills.

It’s harness-agnostic (Claude Code, GitHub Copilot, Copilot CLI, Codex, OpenCode, and more), runs 100% locally, and does not cost you extra tokens for its core analytics. Think of it as a Strava for the way you work with AI.

Repo: github.com/microsoft/AI-Engineering-Coach

⚡ In a hurry? Jump to the install steps, then come back for the why.

The question nobody is measuring

Most of us now reach for an AI coding assistant before we reach for the keyboard. GitHub Copilot, Claude Code, Codex, Gemini CLI. They’ve quietly become the default surface for writing software. But here’s the uncomfortable question I kept coming back to:

Am I actually getting better at this, or am I just using it more?

We obsessively measure the AI: token counts, model benchmarks, latency. We almost never measure ourselves: the quality of our prompts, how often we review what the model generated before shipping it, whether we keep re-typing the same instructions, whether our repos even give the agent enough context to succeed.

That’s the gap the AI Engineering Coach fills. It doesn’t write code for you. It holds up a mirror to how you write code with AI, and that distinction is the whole point.

flowchart LR
    You([You, coding with AI]) -->|prompts · edits · tool calls| Tools["AI coding tools
Copilot · Claude Code · Codex · ..."] Tools -->|already write| Logs[("Local session logs
on disk")] Logs --> Coach["AI Engineering Coach
reads, never writes"] Coach -->|reflects back| Insights["Prompt quality · anti-patterns
output · reusable skills"] Insights -.->|so you level up| You style Coach fill:#cce5ff,stroke:#1f6feb,stroke-width:2px,color:#000 style Insights fill:#e6ffed,stroke:#2da44e,color:#000 style Logs fill:#fff4c2,stroke:#b7950b,color:#000

The loop nobody closes: your tools already write the logs. The Coach just reads them back to you, so the feedback finally points at you, not the model.

Read more
Governance for AI Agents (Part 1): The Gap, the OWASP Agentic Top 10, and Where AGT Fits

Governance for AI Agents (Part 1): The Gap, the OWASP Agentic Top 10, and Where AGT Fits


🎯 TL;DR

You’ve built a single agent, or wired up a multi-agent orchestration with LangChain / AutoGen / CrewAI / Microsoft Agent Framework. It works.

Now answer this: how are you covering the OWASP Agentic Top 10? How do you prove to a regulator that the agent did only what it was allowed to do? Prompt engineering and content filters don’t reach the layer where actions happen.

The Agent Governance Toolkit (AGT), an open-source Microsoft project I work on, puts a sub-millisecond deterministic policy decision in front of every tool call, gives every agent a cryptographic identity, and produces a tamper-evident audit trail.

This post is Part 1 of a series: what the governance gap is, what the OWASP Agentic Top 10 actually contains, and where AGT sits in your stack.

Repo: github.com/microsoft/agent-governance-toolkit

If you’ve shipped anything with LangChain, AutoGen, CrewAI, or Microsoft Agent Framework recently, you’ve probably hit the same wall I did. The agent works. It plans, calls tools, remembers things. And then you try to put it somewhere it can actually do harm, touch a database, hit a real API, run shell commands, talk to another agent, and you realise you have no good way to bound what it can do.

You have a model. You have prompts. You have a tool list. You don’t have a policy layer. So you do what we all do: stitch together if-statements, allowlists, regex filters on prompts, maybe a sandbox if you’re feeling fancy. It mostly works. Until it doesn’t.

flowchart LR
    U([User / Prompt]) --> M[LLM Planner
non-deterministic] M -->|tool call| T{{No policy layer}} T -->|just runs| DB[(Database)] T -->|just runs| API[(Production API)] T -->|just runs| SH[/Shell /] T -->|just runs| A2[Other Agents] style T fill:#ffd6d6,stroke:#c0392b,stroke-width:2px,color:#000 style M fill:#fff4c2,stroke:#b7950b,color:#000

The agent works. The governance doesn’t exist yet. That gap is what the OWASP Agentic Top 10 and every AI regulation is pointing at.

Read more
APIM Backend Fan-out: Shared Backend + rewrite-uri vs One Backend Per API (A Real Benchmark)

APIM Backend Fan-out: Shared Backend + rewrite-uri vs One Backend Per API (A Real Benchmark)


🎯 TL;DR: Shared Backend + rewrite-uri is performance-equivalent to one Backend per API.

The question: if you point 100+ APIs at a single APIM Backend entity and use rewrite-uri to reconstruct the path, do you pay a measurable latency / throughput / reliability penalty versus modelling one Backend entity per API?

Two identical APIM Premium instances, same Function App backend, same k6 load. Across 1.67M requests and ~32 minutes of stepped load (50 → 100 → 200 VUs): 882 vs 874 req/s, 146 vs 153 ms p95, 0 errors on both sides. All three pass/fail thresholds satisfied. Pick the pattern on operational simplicity, not performance.

Bonus finding: backend cold-scale will lie to you. The first run made the shared-backend pattern look 2× slower, that was Flex Consumption scaling up during APIM-A’s window, not a pattern difference. Always warm your backend before measuring.

Full benchmark, IaC, k6 scripts, KQL, and interactive dashboard: github.com/Ricky-G/azure-scenario-hub/tree/main/src/apim-backend-fanout-benchmark

Recently I ran into a scenario worth benchmarking properly: an APIM Premium estate with 100+ APIs that all ultimately call the same upstream service. The architectural choice is whether to model those APIs against a single APIM Backend entity and use rewrite-uri to reconstruct the right path on the way out, or to create one Backend entity per API. One backend is one thing to manage, one health probe, one circuit breaker, one place to flip URLs during a migration. One hundred is, well, one hundred.

Intuition splits cleanly down the middle on whether the shared pattern carries a hidden cost (connection pools are per-backend, surely?) or none at all (it’s just a string concat). I couldn’t find a clean controlled benchmark of this specific question, so I built one, fully reproducible in the Azure Scenario Hub. What follows is the methodology, the numbers, and the wrong answer the first run produced.

The Two Patterns

flowchart LR
    subgraph A["APIM-A · Premium 1 unit · SHARED backend + rewrite-uri"]
      A_API1[api-shared-01 /svc01/v1]
      A_API2[api-shared-02 /svc02/v1]
      A_APIn[...10 APIs]
      A_FRAG{policy fragment
set-backend-service
+ rewrite-uri} A_BE[(1 Backend entity)] A_API1 --> A_FRAG A_API2 --> A_FRAG A_APIn --> A_FRAG A_FRAG --> A_BE end subgraph B["APIM-B · Premium 1 unit · PER-API backend"] B_API1[api-perapi-01 /svc01/v1] --> B_BE1[(Backend 01)] B_API2[api-perapi-02 /svc02/v1] --> B_BE2[(Backend 02)] B_APIn[...10 APIs] --> B_BEN[(Backend 10)] end A_BE --> Func[(Same Mock Backend
Function App · 5ms baseline)] B_BE1 --> Func B_BE2 --> Func B_BEN --> Func
Read more

Choose your design

Only the look changes. Your posts, ads, comments and other integrations stay in place, with the same light/dark and cookie preferences.

Choose the look you prefer