Browse All Posts (125)

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.

Cassidy Williams highlights GitHub’s “Tiny Wins” team and how they reduce day-to-day friction for maintainers by shipping small platform improvements, including performance tweaks and making contributing guidelines easier to find directly in a repository.

John Savill's Technical Training gives a quick overview of Microsoft's Project Perception and how it approaches agentic, end-to-end security.

Visual Studio Code shows how to manage the AI models available in VS Code, including GitHub Copilot models, local models, and bring-your-own-key providers, using quick show/hide and pin controls to keep the model list focused on what you actually use.

DevClass summarizes how Cursor designed its Origin Git repository service to handle Git at large scale, drawing on Vicent Martí’s write-up about Git’s DAG traversal costs, replica synchronization limits, and an object-storage-backed approach using a write-ahead log plus local NVMe caches.

This week's DevOps roundup focuses on practical hardening work in GitHub that reduces auth friction while improving incident response. OAuth apps now support refresh tokens and up to 10 callback URLs, making it easier to run clean dev/staging/prod setups without risky wildcard redirects. On the operations side, GitHub Enterprise adds token-type-specific credential revocation with audit logs and user notifications, so security teams can contain incidents without forcing disruptive, broad resets.

This week's ML roundup focuses on making agent experiences more governed and repeatable in Microsoft Fabric, from the new Fabric Data Warehouse MCP Server preview to tighter routing controls for Fabric data agents. On the data platform side, Fabric Data Warehouse added new tuning and cost tools, including GPU-powered Query Acceleration and Custom SQL Pools, plus practical guidance for Bronze-Silver-Gold layering. Security and operations also moved forward with CMK REST APIs, identity-based Event Hubs connections for Eventstream, and more production-friendly monitoring and dashboard KPIs to help teams run streaming workloads with clearer controls.

This week's GitHub Copilot updates focus on making agent work more collaborative, tool-aware, and governable. Shared agent sessions are now in public preview for Microsoft Teams and Slack, keeping conversations tied to secure sandboxes and pull requests so teams can review what changed and why. MCP momentum continued with hosted connector setup, practical tool servers (Playwright and SQL), and a portable Agent Plugins 1.0 packaging story that supports repeatable workflows across clients. Alongside new managed settings for JetBrains and more hands-on guidance for tokens and budgets, the thread running through the week is clear: scale Copilot usage by pairing better workflows with stronger controls.

This week's AI roundup focuses on what it takes to run agents in production: move safety from prompt rules into enforceable environment controls, and make every tool call and permission boundary auditable. GitHub Copilot expanded shared agent sessions into Microsoft Teams and Slack while adding canvases and session management so collaborative work stays visible, reviewable, and tied to spend. MCP continued to solidify as the tooling layer for agents with connectors, hosted servers, and portable packaging, and Foundry updates added structured outputs and clearer guidance on when to choose prompt agents versus hosted orchestration. Across it all, the theme is practical governance - budgets, managed settings, approvals, and observability that keep agent-driven work predictable.

This week's Azure roundup centers on making production systems easier to run: agent runtimes get stronger isolation and safer tool access, while platform updates improve how you modernize apps and review infrastructure changes. Azure Web PubSub adds a chat-native layer in preview, App Service Managed Instance reaches GA for minimal-change migrations, and Deployment Stacks What-If now supports durable, reviewable diffs. On the reliability side, GitHub's outage write-up is a timely reminder to design for capacity and retries, and core platform updates (DNS, VM CPU controls, and Foundry model tooling) round out a week focused on practical ops and governance.

This week's Security roundup focuses on tightening access and making security decisions easier to audit. GitHub shipped OAuth refresh tokens with stricter redirect hygiene and added incident response controls to revoke credentials by token type, while CodeQL and code scanning updates improved detection coverage and clarified governance with new audit signals and a "Mitigated" dismissal reason. On the platform side, Azure and Fabric continued the shift toward keyless patterns (managed identity), programmable encryption governance (CMK APIs), and stronger recovery posture with immutable SQL backups, alongside practical guidance for securing agentic systems by constraining tools, data access, and runtime.

This week in .NET is about making upgrades and AI features easier to run in real systems. Azure App Service Managed Instance reached GA, giving .NET Framework and Windows-dependent apps a more production-ready landing zone while you plan longer-term modernization. On the tooling side, Visual Studio and Copilot content focused on turning migration into a repeatable workflow (assessment, planning, checkpoints) that scales to large solutions and dependency graphs. In parallel, the AI story moved from single features to agentic architectures, with routing and failover in Microsoft.Extensions.AI, local-first Agent Framework patterns, and quality control loops that put reliability into application logic.

Authorised Territory demonstrates how to build a .NET console app that repeatedly runs an AI agent until a loop evaluator confirms the agent’s tool output matches an expected condition, using Microsoft Agent Framework components like LoopAgent and DelegateLoopEvaluator.

Scott Hanselman walks through a real-world NAS migration from Synology to a UniFi UNAS Pro 8 using Windows and Robocopy, including how he debugged Windows error 665, handled NTFS Alternate Data Streams, and tuned Robocopy switches to avoid major performance traps.

GitHub shares a changelog update for OAuth apps, covering refresh tokens, access token lifetimes, and support for multiple callback URLs. It also highlights configuration details like the offline_access scope and a security audit tip for legacy wildcard redirect URI matching.

Visual Studio Code shares a quick tip on using GitHub Copilot in VS Code to generate a correct launch.json by analyzing package.json, so you can run and debug scripts using the built-in debugger without manually remembering configuration syntax.

Cameron Hamilton joins GitHub’s Rubber Duck Thursday to walk through how he built HALIE, his personal AI agent, including the key product decisions he made and what he learned from shipping it.

Kaleb Cole and Kurt Emrich show how to turn a repeated content-publishing routine into reusable GitHub Copilot workflows using agent skills, personas, plugins, and a marketplace, including drafting from notes, reviewing with an agent, converting to HTML, and publishing to GitHub.

Gwendolyn Vongkasemsiri and Garrett Berliner show how to use GitHub Copilot with Bootstrap 5 to modernize an existing portfolio site, focusing on responsive layout, accessible navigation, animated cards, skill badges, hover effects, and a sticky footer without rebuilding from scratch.

Ashley Steitz and Ahmed Ghaddah show how to use the GitHub Copilot app to turn a resume into a simple portfolio website, generating HTML, CSS, and JavaScript from prompts and then iterating on the design with features like a resume preview and dark mode.

Emily Rothrock and Shivani Sundaresan explain how to get better GitHub Copilot results while using fewer tokens by managing Copilot Chat context. They break down what “context” includes, how the context window works, and how to use commands like /context, /init, and /compact to keep sessions focused and accurate.

Alexander Elguezabal walks students through getting GitHub Copilot access via GitHub Education and the Student Developer Pack, then uses Copilot with Visual Studio Code to generate a simple “Hello World” website and open it locally as a starting point for a portfolio site.

Alexander Elguezabal shows how to bring your own AI model into the GitHub Copilot app using Microsoft Foundry and Azure, including creating Foundry resources via the Azure MCP Server, deploying a model, wiring it up as a model provider with an API key, and troubleshooting token rate limits.