Browse Artificial Intelligence Blogs (26)

Emanuele Bartolesi shares a practical fix for high CPU/disk usage on Windows 11 when running Claude, Codex, and GitHub Copilot tooling: adding targeted Microsoft Defender Antivirus folder exclusions. The post also calls out the security tradeoff and walks through the exact Windows Security steps to apply exclusions safely.

Samu Niemelä shares practical takeaways from FabCon 2026 on how Microsoft Fabric is maturing, from Fabric IQ grounding Copilot and agents in governed business semantics to new on-demand compute and stronger monitoring and governance features for running Fabric at scale.

Rob Bos shares a short pointer to his Azure Heroes session on how he works with GitHub Copilot, with a link to download the slides.

Hidde de Smet explains why “agent-done” work can still create downstream toil, and how GitHub’s Agentic Engineering System (AES) helps teams make delegation reviewable and observable. The article proposes three practical handoffs—evidence packets, enforced stopping points, and release receipts—to reduce “handoff debt” and keep agent output aligned with team capacity.

Thomas Maurer argues that Azure Local should be evaluated as the infrastructure foundation of Microsoft Sovereign Private Cloud, not just as a hypervisor replacement. He breaks down connected vs disconnected operations, Azure Arc control-plane options, and the platform capabilities (AKS, data services, Foundry Local, GitHub Enterprise Local) that shape sovereignty and resilience.

DevClass reports on Microsoft’s migration of the GitHub Copilot runtime from TypeScript/Node.js to Rust using AI agents, including token costs, release cadence, performance benchmarks, and the practical risks of compiler-passing regressions when LLMs generate Rust at scale.

Jesse Houwing breaks down a nasty PSScriptAnalyzer failure in GitHub Actions where Invoke-ScriptAnalyzer intermittently crashed with a missing Get-Command, then shows how Copilot-assisted investigation, benchmarking, and targeted fixes turned it into a deterministic, faster analyzer with evidence reviewers can rerun.

Hidde de Smet lays out a practical way to judge whether a repo is actually ready for AI coding agents, using GitHub Copilot cloud agent as the concrete example. It focuses on repeatable setup, shared commands, focused tests, CI enforcement, and security boundaries so agent sessions aren’t wasted on missing prerequisites.

John Edward explains Microsoft’s general availability release of MCP-compliant tools in Copilot Studio agent workflows, and why standardized tool access matters for building enterprise AI agents that can reliably interact with proprietary systems, dynamic knowledge sources, and custom actions under existing governance.

Topi Nuotos explains why his team replaced a shared Excel tracker with a Microsoft Fabric App, and how Fabric Apps adds an application layer on top of Fabric for building data-driven web apps with preconfigured infrastructure.

Jesse Houwing explains why GitHub Copilot cloud agent sessions can’t be spawned from GitHub Actions using GITHUB_TOKEN, and how GitHub’s accountability model (identity, billing, and auditability) shapes what “agentic workflows” can do today. He then lays out practical orchestration patterns that work, with concrete YAML examples.

Jesse Houwing explains how to stop GitHub Copilot agents from confidently inventing details about fast-moving tools by grounding them in a local clone of the real repository, then forcing answers to be backed by file-and-line citations from the source.

John Edward covers a Copilot Studio authentication update that adds Microsoft Entra ID-based identity for both delegated user access and service-to-service (S2S) scenarios, aimed at making enterprise agent deployments easier to secure and integrate with existing applications.

John Edward lays out a practical checklist for taking an AI agent from demo to production using Microsoft Copilot and Azure AI Foundry, focusing on architecture choices, grounding with enterprise data, controlled tool permissions, evaluation, monitoring, and cost/latency controls.

John Naguib lays out a practical architecture for building self-improving AI agents on Azure, focusing on controlled feedback loops (evaluate, learn, test, approve) rather than uncontrolled self-modification. The guide covers agent runtime, tool calling, RAG, memory/experience stores, evaluation, observability, and governance for production use.

John Naguib explains a Copilot Studio billing change taking effect on September 1, 2026: existing agents and workflows built with the GitHub Copilot harness will start consuming Copilot Credits. The post breaks down what’s affected, how credit consumption works (authoring vs runtime), and what admins can review in PPAC to avoid cost surprises.

Hidde de Smet explains Agent Plugins 1.0, a small packaging standard that lets teams ship portable Agent Skills and MCP server definitions once, while keeping Copilot-specific extras in a namespaced folder. The post covers the required file layout, manifest and MCP schemas, and enterprise governance controls for plugin and MCP server policy.

John Edward explains how to apply FinOps practices to high-volume Azure AI workloads, focusing on the real cost drivers behind model usage, compute, and request patterns. The article lays out practical tactics—visibility, right-sizing, scaling, batching, caching, and guardrails—to keep AI spend predictable without sacrificing latency or reliability.

DevClass reports on the Agent Plugins 1.0 specification, a cross-vendor effort to package agent skills and tool connectivity in a portable, file-system-based format. The goal is to make agent capabilities modular and reusable across compatible clients like VS Code and GitHub Copilot.

John Edward covers a Microsoft Defender update that surfaces AI-generated Microsoft Purview Insider Risk Management triage summaries directly in the Defender alert queue, helping SOC analysts and insider risk investigators triage alerts faster while keeping the full investigation workflow in Purview.

John Edward breaks down what GitHub Copilot does (and doesn’t) send to the service, how training and retention settings vary by subscription, and the practical security risks teams should plan for when using AI-assisted coding in real projects.

John Edward explains how to build an AI-powered IT support agent on Azure, using Azure AI Foundry with Azure OpenAI Service and (optionally) Azure AI Search for RAG-based answers grounded in internal documentation, plus ideas for automating common help desk actions like ticket creation and password resets.

Hidde de Smet audits a local SKILL.md “skills” library spread across Claude Code, a shared .agents catalog, and GitHub Copilot’s VS Code setup, showing how silent failures (missing files, duplicates, stale references) accumulate over time and how to stocktake them with a checklist and a couple of shell one-liners.

John Edward explains why AI agents that look great in demos often break down in production, and what teams need to engineer around the model to make agents reliable at scale.

Rob Bos shares a curated set of GitHub governance references he regularly sends to teams, covering enterprise platform baselines, GitHub Actions supply-chain controls, GitHub Advanced Security rollout and triage practices, and GitHub Copilot governance topics like premium requests, extension governance, and MCP-related security notes.

Hidde de Smet breaks down why spec-driven development can either reduce risk or quietly add “delivery debt”, especially in regulated environments. He outlines six common process cost centers, a three-lane model (full/light/no-spec), and a small set of KPIs to tell when structure is paying off.