Browse All Posts (1451)

Pieter Vandenheede breaks down four practical BizTalk migration paths—do nothing (short-term), coexistence, domain-by-domain migration, and big-bang replacement—and provides a decision matrix to help teams choose an approach that fits their constraints and risk tolerance.

Allison announces an update to GitHub Advanced Security that lets enterprise admins enforce security configurations across organizations, preventing org and repo admins from overriding enterprise-level settings and helping security and compliance teams apply consistent policies at scale.

Allison announces a public preview feature where GitHub Copilot suggests allowed values while admins define repository custom properties, helping organizations build consistent governance metadata that can be used to scope rulesets across large fleets of repositories.

Sharon Xu announces Foundry Dev Pack, an all-in-one installer that sets up a Microsoft Foundry development environment across the terminal, VS Code, and coding agents, including Azure CLI/azd tooling and starter workflows for creating hosted agents.

Michaela Isaacs introduces pq-adbc-advisor, a self-serve notebook-based scanner that inventories Microsoft Fabric workspace items still using legacy ODBC drivers and helps teams plan the ODBC-to-ADBC cutover. It produces a per-item impact report, classifies cutover risk, and recommends concrete fixes to validate ahead of connector-specific deadlines.

stevenbucher announces public preview support for versioning custom Azure Policy definitions and initiatives, including how to create new versions, pin assignments to major/minor versions, and validate which version is effective via REST API, portal, CLI, and PowerShell.

Nivas Narayanasamy lays out a practical architecture for making private Azure VMware Solution workloads reachable by Azure AI Foundry agents without moving data. The post shows how to use MCP “bridge” servers on VNet-integrated Azure Container Apps, with ExpressRoute, private endpoints, Entra managed identity, and Key Vault-backed secrets to keep access private and read-only.

Mayuri Gupta announces the public preview of Azure Red Hat OpenShift hosted control planes, explaining how the control plane can run as a Microsoft-managed service while worker nodes stay in the customer subscription. The post covers operational benefits, Azure integrations (identity, monitoring, IaC), security controls, supported regions, and preview pricing.

Allison announces that GitHub has completed the planned shutdown of SHA-1 support in HTTPS for github.com and partner CDNs, with notes on which GitHub Enterprise offerings are affected and where to find the earlier deprecation details.

Pamela_Fox shares the full set of MCP Live session recordings and resources, covering the Model Context Protocol’s latest spec updates, MCP server/client development in VS Code and GitHub Copilot, enterprise governance with Microsoft Foundry Toolboxes, and evolving MCP authentication patterns.

Aaron Powell shows how to baseline and then raise unit test coverage in the Interview Coach app using Visual Studio’s code coverage tooling and GitHub Copilot’s Test Agent, moving from targeted tests for a single class to solution-wide analysis and test generation.

Justin Yoo walks through a sample “Interview Coach” app that uses the GitHub Copilot SDK as an agent runtime (outside the editor) to run an interview workflow: ingest a resume, ask behavioral/technical questions, store session context, and generate end-of-interview feedback using MCP tools and Agent Framework handoffs.

GitHub shows how to hand off an active GitHub Copilot app session into VS Code so you can keep working in your editor without losing context, including the task plan, conversation history, diffs, and an isolated git worktree, then push changes back to a pull request.

Microsoft Developer shows how to use GitHub Copilot with a Microsoft Foundry skill to review and refactor an existing “Sparkle Cupcakes” agent, aligning it with current Foundry patterns and SDK guidance while improving production readiness.

Satoshi Kubota proposes using a Data Center WordCode Layer (DCWL)—a fixed-length 32-bit word encoding originally aimed at Azure text-processing workloads—to speed up Copilot for Windows and other Windows client text-heavy pipelines such as local RAG, semantic search, and log analysis.

Stephen Toub walks through a large set of runtime and library performance changes in .NET 11, with runnable micro-benchmarks and disassembly examples. It covers JIT optimizations (devirtualization, escape analysis, bounds-check removal), a new runtime-driven async implementation, SIMD/codegen improvements, and faster paths across core libraries like networking, JSON, regex, and collections.

Andrew Lock introduces Device Bound Session Credentials (DBSC), a browser/server protocol that makes stolen authentication cookies much harder to reuse on another machine. He explains the threat model (cookie theft and session hijacking), how DBSC uses TPM-backed keys and signed challenges, and what endpoints a server needs to add to support it.

Pieter Vandenheede explains how to decide whether to keep BizTalk after Microsoft confirmed BizTalk Server 2020 is the final release, and what conditions make “staying” a deliberate (and limited) choice. He also outlines practical signals that it’s time to move and frames the shift from “if we migrate” to “how we migrate safely.”

Thomas Maurer explains how Adaptive Apps and the open-source Radius control plane help teams engineer, test, and prove application portability across Azure, Azure Local, and other Kubernetes environments by separating app intent from environment-specific implementations.

GitHub shares three practical workflow changes to reduce review fatigue and keep pull request backlogs under control when teams adopt AI coding tools, focusing on better prompt inputs, smaller changes via stacked PRs, and shifting reviews toward assessment rather than line-by-line editing.

nzthiago explains the new GA support for site-scoped certificates and end-to-end TLS in Azure Functions Flex Consumption, including certificate sources (Key Vault, managed certs, uploads), how to expose certs to code on Linux workers, and how to implement inbound and outbound mutual TLS safely.

Wuyi Weng explains how Azure SRE Agent can use an Azure Managed Grafana dashboard (via the MCP endpoint) as executable context to investigate GitHub Copilot telemetry in Application Insights, turning panel queries, variables, and descriptions into fast, accurate triage and per-session diagnoses.

Gaurav Bhardwaj walks through a practical “refund agent” example to show why AI agent observability needs more than green HTTP checks, and how to use Microsoft Foundry plus Azure Monitor (Application Insights and Log Analytics) to trace runs, evaluate tool-call correctness, set alerts, and bake in security and privacy controls.

Luis Quintanilla invites teams to submit real-world stories about building, modernizing, and improving applications with .NET, with the goal of featuring more community and customer examples at .NET Conf 2026 and across official .NET channels.

Mariyaali announces the general availability of the SQL DW operations skill for Microsoft Fabric Data Warehouse, which lets teams use natural-language prompts (for example via GitHub Copilot CLI) to run bounded, read-only diagnostics and get structured findings, evidence, and recommended next steps for common warehouse incidents.

Allison announces new configuration tiers for GitHub Copilot auto model selection—efficiency, balance, and intelligence—so teams can control how Copilot trades off cost, response quality, and response time per prompt, with billing based on the model selected.

GitHub introduces CVE Lite CLI, a local dependency vulnerability scanner for JavaScript and TypeScript projects, highlighting how it classifies direct vs transitive issues, validates fix versions with OSV, and outputs exact upgrade commands across npm, pnpm, Yarn, and Bun.

Pieter Vandenheede breaks down Microsoft’s BizTalk Server lifecycle update, what stays supported through 2028/2030, and why “support isn’t strategy” for long-term integration platforms. He outlines practical next steps: inventorying your integration landscape, planning timelines, and evaluating Azure Integration Services (including Logic Apps) as the direction Microsoft is investing in.

Rick Strahl explains why files under ASP.NET Core’s wwwroot are public by default, and how to protect dynamically generated “static” files (like admin logs) so they still respect authentication and authorization rules.

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.

This week's Weekly AI Roundup focuses on what it takes to run agents as real production workloads: Azure landing zone-based reference architecture, identity and observability baselines, and cost controls that make audits and FinOps practical. On the grounding side, Fabric and Foundry content reinforced that agent quality depends on a governed meaning layer, with ontology work, lineage graphs, and the growing "IQ" family shaping how truth flows into prompts and tool calls. MCP continued to mature with spec updates, enterprise-focused authentication direction, and more practical implementation patterns, while GitHub Copilot pushed further into agent workflows with managed permissions, reporting, and programmatic security rollouts. We also saw operational AI tighten up in Azure Copilot troubleshooting, faster multilingual speech recognition, and more evidence that closed-loop scientific and security agents need the same governance, evaluation, and lifecycle discipline as any other platfor

This week's GitHub Copilot updates pushed agentic workflows from "use at your own risk" toward something admins can govern and teams can run every day. Enterprise managed permissions for agent operations and JetBrains sandbox controls make it possible to enforce runtime guardrails (block, allow, or require approval) across common risk areas like shell access, files, and outbound domains. On the workflow side, the Copilot app, VS Code Agents, and CLI routing updates reduced friction in multi-step work, while code review and Code Quality autofix features moved PRs and static analysis closer to an "agent-assisted" default. Rounding it out, new usage metrics for VS Code Agents, a MAI-Code-1-Flash deprecation, and more guidance on MCP and BYOK setups give platform teams clearer levers for rollout, measurement, and cost control.

This week in DevOps, the focus shifted toward running fleets and pipelines with tighter guardrails and less manual work. Azure Arc pushed more hybrid and edge day-2 operations into the portal, while Azure Compute and Azure Copilot targeted faster VM startup paths and more structured troubleshooting inside RBAC boundaries. On the delivery side, GitHub and npm added policy-first controls around pull requests, caches, and account recovery, and Copilot moved deeper into review and remediation workflows with clearer model and sandbox governance options. We will walk through what changed, where it reduces operational toil, and what teams should validate before rolling these updates across environments.

This week's .NET roundup centers on shipping and hardening: .NET 11 Release Candidate 1 arrives with go-live support, and September servicing updates land across supported .NET and .NET Framework versions. On the developer experience side, C# 15 unions and closed hierarchies move from theory to practice in ASP.NET Core, with concrete guidance for JSON binding and OpenAPI anyOf contracts. We also look at cleaner Azure-to-App Service integrations using Managed Identity, new troubleshooting patterns for distributed .NET Aspire apps with Visual Studio and Copilot, local AI agent evaluation in .NET with Agent Framework and Ollama, and CodeQL updates that make ARM64 scanning workflows easier to run and maintain.

This week's ML roundup focuses on making AI systems more reliable by tightening the connection between governed data and agent grounding, from Fabric's lineage-first item relations API to table-level discovery in OneLake Catalog search. We also saw practical Spark work that pushes latency down and correctness checks earlier, including Structured Streaming real-time mode for fast quarantine and native JSON parsing in Fabric's Native Execution Engine. Finally, three production case studies (supply chain planning, closed-loop lab discovery, and feedback-to-work-item automation) show what agentic systems look like when they ship with traceability, safety controls, and human review.

This week's Azure roundup focuses on turning enterprise AI from pilots into repeatable platform work. Microsoft sharpened the recommended path: start with Azure landing zones for identity, networking, and policy, then use Microsoft Foundry to operationalize agents and Retrieval-Augmented Generation (RAG) with consistent guardrails. Governance and cost control are treated as day-2 requirements, with token limits, rate controls, and Azure API Management's AI Gateway highlighted as practical enforcement points. If you are building internal copilots, the guidance reads like a deployment checklist for standard auth (Microsoft Entra ID), telemetry (Azure Monitor), and spend attribution you can tie back to outcomes.

This week's Security roundup focuses on identity-first cloud defense and the controls that stop attacks at the first chokepoints: authentication, messaging, and the cloud control plane. Microsoft published a Cloud Web Applications Threat Matrix that turns ATT&CK techniques into concrete hardening priorities for App Service and serverless workloads, while new incident writeups show how passkey-themed lures, AI-assisted impersonation, and AiTM patterns translate into real Entra ID and M365 compromise paths. On the DevSecOps side, GitHub shipped enforceable guardrails (blocking PR merges with unresolved secrets, least-privilege cache access, and API-managed AI Scan rollout) alongside CodeQL updates, and the agent story matured with Citadel architecture guidance plus enterprise policies that constrain Copilot agent actions. Rounding it out are platform updates like user-bound delegation SAS in Azure Storage, managed-identity triggers for App Service integrations, network-aware migration pl

kedikala lays out a practical security framework for agentic apps on Azure, focusing on how to keep tool calls safe when untrusted content can steer an agent toward sensitive reads or risky writes. The post breaks controls down across identity, retrieval, request validation, execution constraints, and outcome verification.

GitHub explains how hill climbing can be used to iteratively improve AI agent performance by running targeted evals, benchmarking results, and using the feedback loop to steer responses toward higher accuracy over time.

Wiliam_Rosa breaks down how Spark Structured Streaming’s Real-time mode (as implemented in Azure Databricks) can cut anomaly-detection latency from seconds to sub-millisecond, using an Ethereum transaction pipeline that classifies events as ALLOW or QUARANTINE based on protocol invariants and sensitive-payload checks.