Whether you’re exploring your first model, shipping a production agent, or squeezing performance from edge hardware, Microsoft Foundry Toolkit for VS Code meets you where you are.

To get started, visit aka.ms/foundrytk.

You have a database in production. How do you get it into source control — and keep it there? With SSMS 22.5, you can now import your database into a SQL project — a code-based, human-readable definition of your schema — edit and validate without impacting the original database, and publish changes with confidence. In this Data Exposed episode, we introduce SQL projects in SSMS with the new Database DevOps workload in preview. We'll also show how the same project file works across VS Code, GitHub Actions, and Azure DevOps — so your database development process can grow with your team across any tool.

0:00 Introduction
2:13 Demos
12:00 What's next

✅ Resources:
https://aka.ms/sqlprojects
https://aka.ms/ssms-sqlprojects

📌 Let's connect:
Twitter - Anna Hoffman, https://twitter.com/AnalyticAnna
Twitter - AzureSQL, https://aka.ms/azuresqltw

🔴 Watch even more Data Exposed episodes: https://aka.ms/dataexposedyt

🔔 Subscribe to our channels for even more SQL tips:
Microsoft Azure SQL: https://aka.ms/msazuresqlyt
Microsoft SQL Server: https://aka.ms/mssqlserveryt
Microsoft Developer: https://aka.ms/microsoftdeveloperyt

#AzureSQL #SQL #LearnSQL

Production agents need to remember. In this episode, we dive into Memory in Foundry Agent Service — a managed, long-term memory layer that turns stateless LLM calls into stateful, continuous agents. Lewis Liu and Amy Boyd walk through how memory is natively integrated with Microsoft Agent Framework and LangGraph, enabling agents to persist user preferences, conversation context, and task outcomes across sessions — with zero infrastructure overhead. See how per-user memory scoping, automatic memory extraction, and CRUD APIs give developers full control while keeping enterprise governance built in.

✅ Chapters:
00:17 Introduction MAF - Microsoft Agent Framework and Foundry Memory
00:45 Why we need Foundry Memory
01:40 What's Foundry Memory
03:20 How Memory helps Agents - Use Cases
07:31 Foundry Memory Key concepts and Features
14:33 Foundry Memory - What's under development
16:55 Foundry Memory and MAF - Demo 1
20:25 Foundry Memory and MAF - Demo 2
24:24 Foundry Memory and MAF - Demo 3
30:50 Foundry Memory Public Preview and What's Next

✅ Resources:
Foundry Toolkit for VS Code: https://aka.ms/foundrytk
Microsoft Agent Framework on GitHub: https://aka.ms/AgentFramework
AI Agents for Beginners: https://aka.ms/ai-agents-beginners
Blog post: https://aka.ms/DeployingAgents-blog
MAF 1.0 Announcement: https://aka.ms/AgentFramework1.0-blog

📌 Let's connect:
Jorge Arteiro | https://www.linkedin.com/in/jorgearteiro
Amy Boyd | https://www.linkedin.com/in/amykatenicho/
Lewis Liu | https://www.linkedin.com/in/lewisxl/

Subscribe to the Open at Microsoft: https://aka.ms/OpenAtMicrosoft

Open at Microsoft Playlist: https://aka.ms/OpenAtMicrosoftPlaylist

📝Submit Your OSS Project for Open at Microsoft https://aka.ms/OpenAtMsCFP

New episode on Tuesdays!

In episode 6 of our GitHub Copilot CLI for beginners series, we explore how to deeply customize your AI coding assistant. We walk you through setting up instructions, skills, and custom agents to ensure Copilot follows your team's exact coding standards. Learn how to generate project-level instructions, automate pull requests with agent skills, and run specialized tasks like accessibility reviews. These tools work in perfect harmony to keep your codebase consistent.

GitHub Copilot CLI for Beginners: https://github.com/github/copilot-cli-for-beginners?utm_source=youtube-cli-beginners-series-episode6-repo-cta&utm_medium=social&utm_campaign=copilot-cli-ga-phase-two-2026

#GitHubCopilot #CopilotCLI #AI

Stay up-to-date on all things GitHub by connecting with us:

YouTube: https://gh.io/subgithub
Blog: https://github.blog
X: https://twitter.com/github
LinkedIn: https://linkedin.com/company/github
Insider newsletter: https://resources.github.com/newsletter/
Instagram: https://www.instagram.com/github
TikTok: https://www.tiktok.com/@github

About GitHub
It’s where over 180 million developers create, share, and ship the best code possible. It’s a place for anyone, from anywhere, to build anything—it’s where the world builds software. https://github.com

Building APIs with ASP.NET Core? In this @VisualStudioLive session from Visual Studio Live! Las Vegas 2026, Phil Japikse walks through the fundamentals and modern best practices for creating fast, scalable RESTful services using .NET.

From dependency injection and configuration to model binding, validation, and content negotiation, this session blends core concepts with practical demos to help you build clean, maintainable APIs in real-world applications.

🔑 What You’ll Learn
• Key differences between ASP.NET Web API and ASP.NET Core APIs
• How dependency injection works (scoped, singleton, transient) and when to use each
• Structuring your app with Program.cs, top-level statements, and service configuration
• Using the options pattern and environment-based configuration (appsettings.json)
• Model binding, validation, and handling errors with model state
• Returning data with IActionResult and controller base helpers
• Content negotiation (JSON, XML, CSV) and custom formatters
• Data shaping techniques for flexible API responses
• Securing APIs with CORS and best practices for configuration
• Using filters for global exception handling and logging

⏱️ Chapters
00:00 Introduction + RESTful services in ASP.NET Core
04:05 Program.cs, top-level statements, and app setup
06:40 Dependency injection fundamentals (scoped, singleton, transient)
11:30 Injecting services and using FromServices
14:41 Keyed services and dependency validation
17:24 Environment configuration and appsettings.json
21:05 Options pattern and configuration binding
29:00 JSON serialization and naming conventions
32:46 Returning data and IActionResult patterns
33:49 Content negotiation (JSON, XML, CSV)
37:55 Data shaping and dynamic responses
45:30 CORS configuration and security considerations
49:19 Model binding, validation, and model state
52:07 Logging with Serilog and structured logging
53:21 ControllerBase helpers and HTTP responses
55:09 Routing and API controller behavior
57:41 Filters and global exception handling
59:15 Custom validation attributes and best practices

👤 Speaker
Phil Japikse
CTO & Chief Architect, Pintas & Mullins

🔗 Links
• Download Visual Studio 2026: http://visualstudio.com/download
• Explore more VS Live! Las Vegas sessions: https://aka.ms/VSLiveLV26
• Join upcoming VS Live! events: https://aka.ms/VSLiveEvents

#dotnet #visualstudio #vslive

Curious how AI tools like GitHub Copilot actually impact your day-to-day development? In this @VisualStudioLive session from Visual Studio Live! Las Vegas 2026, Brian Randell breaks down what AI does well, where it falls short, and how developers can use it effectively without buying into the hype.

From model selection and cost tradeoffs to real-world demos with Copilot, Claude, and local models, this session provides a practical framework for using AI as a tool, not a replacement for developer expertise.

🔑 What You’ll Learn
• Why AI is not “magic” and how it actually works under the hood (tokens, probabilities)
• Why there is no “one model to rule them all” and how to choose the right tools
• The real productivity tradeoffs of AI (speed vs validation and testing time)
• Where AI excels: code generation, refactoring, documentation, and planning
• Common failure modes: hallucinated APIs, security risks, and incorrect code
• Cost considerations for AI tools, including token usage and model pricing
• Using local models vs cloud-based AI for privacy, performance, and cost control
• Why “trust but verify” is critical when working with AI-generated code

⏱️ Chapters
00:00 AI is not magic, but it is disruptive
03:00 The “one model to rule them all” myth
06:30 Understanding how AI models actually work
08:30 The productivity paradox with AI tools
10:30 Model selection, pricing, and cost tradeoffs
18:00 Where AI works best (code, tests, documentation)
18:33 Demo: using AI tools in real development workflows
24:30 Comparing Copilot, Claude, and local models
35:42 Running local models with Ollama
42:15 Integrating local AI into Visual Studio Code
47:00 AI failures: hallucinations, security, and bad code
53:03 Governance, risk, and enterprise considerations
54:55 Best practices: trust but verify
57:00 Building your AI toolkit as a developer

👤 Speaker
Brian Randell (@brianrandell)
Partner, MCW Technologies

🔗 Links
• Download Visual Studio 2026: http://visualstudio.com/download
• Explore more VS Live! Las Vegas sessions: https://aka.ms/VSLiveLV26
• Join upcoming VS Live! events: https://aka.ms/VSLiveEvents

#ai #githubcopilot #visualstudio #vslive