Browse All Posts (123)

Sherry Xu, Prashant Ranjan, and Torsten Hoefler explain how Azure Maia 200 targets efficient, predictable large-scale AI inference by making data movement explicit (SDLA) and extending that approach across an all-Ethernet scale-up network, with performance discussion across realistic matmul and collective-communication workloads.

Mariko Wakabayashi shares practical lessons from evaluating an LLM-based system to reduce false positives in GitHub secret scanning, focusing on how to define success metrics, keep offline evaluation close to production, and use error analysis and human review to manage security risk.

XinXin announces the retirement timeline for Microsoft HPC Pack and explains what support will (and won’t) be available through end of support. The post also points customers to Azure Batch as Microsoft’s supported managed platform for running HPC and parallel workloads going forward.

Allison announces general availability of GitHub’s rule insights dashboard at both repository and organization levels, giving teams a clearer way to review ruleset evaluations, track bypass activity, and export CSV data for governance and compliance reporting.

Allison announces general availability of the new Customize tab in the GitHub Copilot app, which centralizes MCP servers, plugins, skills, and canvases so teams can discover and apply Copilot customizations more easily, including featured options and faster browsing of trending MCP servers.

Allison announces an update to GitHub Security Advisories that lets repository owners and org moderators block abusive or spammy users directly from an advisory page, without navigating to separate settings pages.

Ahmed Khaled shows how to track Azure Batch node state changes at per-node granularity by polling the Batch REST API and ingesting snapshots into a Log Analytics custom table, then using KQL to calculate time-in-state and trigger Azure Monitor alerts only when nodes are stuck or unhealthy.

mk_sunitha announces a preview feature for Fabric Apps that enables anonymous (no sign-in) access to selected data and operations, aimed at building public-facing experiences while keeping tight administrative and data-model controls in place.

Allison announces a GitHub rulesets update that adds path exceptions for push rules, letting teams enforce repository policies while carving out narrowly-scoped file path exemptions.

Jiri Cincura explains how to get started contributing to Entity Framework Core, including where to begin, how to build the repo locally, how the codebase is structured, and how the test setup works.

Jon Galloway announces .NET Conf 2026 (Nov 10–12), a free online event aligned with the .NET 11 launch, and points readers to current previews and related deep dives across the runtime, SDK, ASP.NET Core, Blazor, MAUI, and C# 15.

Rafia Aqil (co-authored with Sanjeev Nair) lays out a three-phase, practical approach to reducing Azure Databricks spend: first getting visibility into where DBUs and cloud costs go, then tightening cluster and code practices, and finally setting up ongoing cost observability with Unity Catalog system tables, tagging, dashboards, and budgets.

Anna Hoffman introduces the Azure SQL Database Foundations series: four videos (with companion repos) that walk developers through getting started with Hyperscale, migrating and optimizing existing databases, scaling for performance, and adding AI features like vector search and RAG directly on operational data.

Igor Sakhnov argues that the time between vulnerability disclosure and real-world exploitation has shrunk to hours, leaving many organizations unable to patch fast enough. He outlines why “exposure reduction” needs to complement traditional vulnerability management, and why network-enforced controls are emerging as the fastest way to contain risk while remediation is still in progress.

Mark Downie highlights the Visual Studio August update, focusing on new GitHub Copilot controls (model “thinking effort”, org-wide custom agents, and in-IDE usage visibility) plus Git tooling improvements that make it easier to work across multiple branches and repositories.

GitHub shows how the GitHub Copilot app’s built-in diff, terminal, and browser panels help you review and validate AI agent-made changes without constantly switching tools, so you can keep a tighter loop before accepting code updates.

yashnisar introduces Live Reports in Azure SRE Agent (public preview), a way for ops teams to describe an operational dashboard in chat and have the agent generate a deterministic page that refreshes live data on each open. The post explains token-cost behavior, connector/tool-call mechanics, and the guardrails used to keep report execution constrained.

Cary Chai announces general availability of VNet integration for Azure SRE Agent and explains how it routes outbound agent traffic through your virtual network so you can reach private endpoints while still enforcing existing routes, NSG rules, firewall policies, private DNS, and network logging.

Nir Mashkowski announces a 30-day trial for Azure SRE Agent that removes baseline always-on charges during setup, plus GA VNet integration and a public preview of Live Reports for building repeatable operational views that refresh with live data from connected systems.

Kayla Cinnamon walks through VS Code’s updated Markdown editing workflow, including side-by-side preview with live updates and a new editor that lets you edit directly in the preview while the Markdown syntax updates in real time. She also shows handing Markdown cleanup to an agent using an isolated worktree.

GitHub interviews the maintainers of the Zephyr Project as part of Open Source Friday, focusing on what Zephyr is and why it’s positioned as a scalable, optimized, and secure RTOS across multiple hardware architectures.

Andrew Lock shows how to get the total logical CPU count on a host machine (not just the CPUs available to the current process) in modern .NET. The post compares `Environment.ProcessorCount` behavior across runtimes and provides a cross-platform helper using P/Invoke on Windows/macOS and file parsing on Linux.

Tanmayee Kamath announces a preview of Bring Your Own Model (BYOM) in Visual Studio 18.10 Insiders, letting developers connect Visual Studio’s Agent mode to Microsoft Foundry/Azure AI Foundry deployments or other supported model providers, including custom endpoints for OpenAI and Ollama.

Microsoft Developer presents a lightning talk that rapid-fires practical GitHub capabilities teams often overlook, spanning collaboration features and modern delivery workflows, plus newer AI and agentic workflow concepts you can apply in day-to-day engineering work.

Microsoft Developer presents a demo-focused overview of Azure SQL Database Hyperscale, explaining its architecture and how independent compute and storage scaling can help applications handle changing demand without disruptive migrations.

Bob and Anna demo how to build AI-style retrieval features on Azure SQL Database Hyperscale using vector embeddings and vector indexes, focusing on practical developer capabilities for semantic search and retrieval scenarios.

Microsoft Developer features Bob and Anna demonstrating how to migrate a SQL Server workload to Azure SQL Database Hyperscale using Azure Database Migration Service, with practical considerations and takeaways for getting onto an always up-to-date managed SQL platform.

Bob Ward and Anna Hoffman reintroduce Azure SQL Database Hyperscale, explaining what it is, what makes it different from traditional SQL Server deployments, and how its cloud-native architecture enables independent scaling of compute and storage for modern app workloads.

Microsoft Developer presents an overview of “feedback-based learning” techniques for improving agentic RAG systems running on Azure, focusing on how to close the loop between user/system feedback and retrieval + generation quality over time.

Microsoft Developer covers how to secure AI agents running on Azure, focusing on trust boundaries, safe tool access, and gateway-based controls to reduce common agent risks like prompt injection and data leakage.

Microsoft Developer shows how to go from an initial idea to a working AI agent quickly by combining Copilot Studio with Claude Code, focusing on the practical flow of building and shaping an agent rather than theory.

Microsoft Developer presents an end-to-end reference architecture for building an enterprise AI platform on Azure, spanning ingestion through embeddings and vector search to API exposure and partner integrations, with practical patterns for scaling, observability, and secure operations across serverless and container runtimes.

Microsoft Developer introduces Work IQ, Foundry IQ, and Fabric IQ and how they fit together for building intelligent agents across application workflows and data/analytics scenarios.

Microsoft Developer explains why treating AI interactions as “specs” (with clear requirements and tests) is more reliable than ad-hoc prompting, and how to structure inputs and evaluation so LLM-powered features behave predictably in real applications.

Microsoft Developer shows how to build a Model Context Protocol (MCP) server from scratch using the MCP C# SDK, then connect it to an AI agent in Microsoft Foundry by defining tools, prompts, and resources that bridge real systems with LLMs.

MattH_OneLake announces a preview feature in Microsoft Fabric that mirrors Google Lakehouse Runtime Catalog metadata into OneLake, enabling zero-copy access to supported Apache Iceberg tables and making them usable across Fabric experiences like SQL, Power BI, Spark notebooks, and data science workloads.

Taarik Ashenafi explains how GitHub built an alt-text quality plugin for the GitHub Accessibility Scanner, combining deterministic rules with an opt-in vision-model check that can run in CI. The post focuses on reducing false positives, using layout-aware repetition detection, and handling privacy and cost when sending page context and images to models.

Bruno Capuano shows how to take a minimal Microsoft Agent Framework console app and deploy it as a Foundry Hosted Agent in Azure using one prerelease NuGet package, three lines of C#, and two azd commands—while getting managed identity, session state, observability, and an OpenAI-compatible /responses endpoint.

Bill Wagner introduces the C# 15 preview shipping with .NET 11 Preview 7, highlighting the biggest language changes and what they mean in real code: union types, closed hierarchies, a preview redesign of unsafe/memory-safety rules, plus updates to collection expressions, extension members, and loop control flow.

John Savill gives an overview and demo of Project Perception, focusing on how AI-driven workflows and agent-style collaboration can speed up cybersecurity operations across red/blue/green team activities and playbook-driven response.