Andrei Kvapil, founder of Ænix and core developer of Cozystack, joins Ryan to dive into what it takes to build a cloud from scratch, the intricacies of Kubernetes and virtualization, and how open-source has made digital sovereignty possible.

The rise of Model Context Protocol (MCP) has transformed how AI agents interact with tools, codebases, and even browsers. GitHub Copilot and VS Code teams, in partnership with the Microsoft Open Source Program Office (OSPO), are now sponsoring a wave of open-source MCP projects that push the boundaries of developer experience, agent autonomy, multi-modal capabilities, and community.

These nine projects—ranging from browser extensions to semantic code editors—are not just experiments, they’re the scaffolding for a new generation of AI-native workflows. Let’s dive into some of the exciting MCP-powered innovations on GitHub based on community engagement. 

From semantic code editing to new dev tools

1. Upstash/context7: Up-to-date documentation for LLMs and AI code editors 

Upstash’s Context7 MCP server allows developers to easily pull up-to-date, version-specific documentation and provides code examples straight from the source. From there, the MCP includes them directly into your prompt for easily understandable context for your LLMs and AI applications.

2. Tadata/fastapi_mcp: FastAPI, meet MCP 

FastAPI-MCP turns your FastAPI endpoints into MCP tools with authentication that needs minimal configuration. The MCP preserves schemas, documentation, and authentication logic, creating a seamless way to expose APIs to AI agents.

3. Oraios/serena: Semantic code editing for agents 

Serena is a fully featured coding agent toolkit that integrates language servers with MCP. It provides semantic retrieval and editing capabilities for code retrieval, editing, and shell execution. This makes coding agents smarter and more efficient and can even turn a vanilla LLM into a true IDE assistant.

4. Czlonkowski/n8n-mcp: Let AI agents build n8n workflows for you 

 This project brings n8n’s powerful automation engine into the MCP ecosystem. By bringing in comprehensive access to n8n node documentation, validation tools, and direct n8n instance access, agents can now trigger, monitor, and manipulate workflows programmatically. Though details are sparse, early adopters are already integrating it with GitHub Actions, Discord bots, and data pipelines.

5. Justinpbarnett/unity-mcp: AI agents in game dev 

 Unity-MCP exposes Unity’s game engine APIs to MCP clients. Agents can inspect and modify game objects, scenes, and prefabs. It’s a bold step toward AI-assisted game development, with potential for debugging, level design, and UI generation.

6. Antfu/nuxt-mcp: Nuxt dev tools

Created by ecosystem veteran Anthony Fu, Nuxt-MCP lets agents interact with Nuxt apps via MCP. It supports route inspection, component analysis, and SSR debugging. If you’re building with Nuxt and want AI-native tooling, this is your launchpad.

7. MCPJam/inspector: MCP server testing and evals

The MCPJam inspector is an open-source testing and debugging tool for MCP servers – Postman for MCP. It can test your MCP server’s tools, resources, prompts, and authentication, and also has an LLM playground to test your MCP server against different models. Bonus: MCPJam has a CLI tool for MCP evaluation.

8. Steipete/Peekaboo: Swift code analysis via MCP 

Peekaboo brings Swift codebases into the MCP fold. It uses language servers to expose symbol-level tools for agents, enabling code navigation, editing, and refactoring. Built by Peter Steinberger, it’s a must-have for iOS developers.

9. Instavm/coderunner: Run code safely and locally 

Coderunner is a sandboxed MCP server for executing code snippets. It supports multiple languages and isolates execution for safety. Agents can test hypotheses, run scripts, and validate outputs—all without leaving the IDE. 

Why GitHub and VS Code are sponsoring these projects 

These projects aren’t just cool—they’re helping accelerate the MCP community and provide tools that developers use and care about. GitHub Copilot and VS Code teams are sponsoring these projects to promote open-source software and open standards like MCP, accelerate agent-native development workflows, and give developers more power to build, debug, and deploy with AI. 

Want to help support these projects? Sign up for GitHub Sponsors today and join us in sponsoring them or other open-source projects you care about.

Dive into the MCP ecosystem and start building the future of AI-native development and explore how MCP x VS Code and GitHub Copilot can increase your productivity and creativity!

The post 9 open-source projects the GitHub Copilot and Visual Studio Code teams are sponsoring—and why they matter appeared first on Microsoft Open Source Blog.

view my past posts

Meta just dropped a paper that solves a problem we all know too well. AI models that either answer unsafe questions or refuse to help with perfectly reasonable ones.

Their solution? Train two AI agents to work together.

The results are striking. Unsafe replies drop from 39% to 4.6%. Needless refusals fall from 45.3% to 9.9%. And general capabilities stay intact.

This is WaltzRL, a new approach to AI safety that treats alignment as teamwork instead of a single-player game.

The Problem? Guardrails That Kill Helpfulness

Current safety systems are blunt instruments. They see potential risk and hit the reject button. The entire response gets blocked, even if 95% of it was valid.

This creates two failures; Models generate unsafe content when attacked (jailbreaks work). Models refuse harmless requests that look risky ("How do I kill a Python process?").

Adding more guardrails makes this worse. When Meta's team added Llama Guard to their baseline model, overrefusal jumped from 25.7% to 29.8%.

If you start with a model that already has low overrefusal, adding guardrails hurts even more. Their single-model RL baseline had 8.6% overrefusal. After adding guardrails: 14.9%. That's a 6.3 percentage point increase.

Traditional guardrails don't solve the safety-helpfulness trade-off. They just move the slider toward "say no more often."

The Solution - Two Agents Dancing Together

WaltzRL uses two specialized models working in tandem.

The conversation agent writes responses to user prompts. It's optimized to be helpful and safe.

The feedback agent reviews those responses. When it spots problems, either unsafe content or unnecessary refusal, it suggests specific fixes.

Here's the key insight: the feedback agent doesn't just flag problems. It explains what to change and why. This rich feedback helps the conversation agent learn faster and correct course without throwing away entire responses.

The system uses one round of feedback per response in its experiments. The conversation agent writes an initial answer. If the feedback agent detects issues, it provides guidance. The conversation agent then writes a revised response incorporating that feedback.

At runtime, feedback only triggers when needed. On general helpfulness queries, the feedback trigger rate is just 6.7%. Even on challenging safety and over-refusal benchmarks, it stays below 50%. This keeps latency manageable.

How? Reinforcement Learning with a Twist

Both agents train together through reinforcement learning. But they get rewarded differently.

Conversation agent reward: It only gets a positive reward when the response is both safe AND not over-refusing. One without the other doesn't count.

Feedback agent reward: This is where it gets clever. They use Dynamic Improvement Reward (DIR).

The feedback agent gets rewarded based on whether its advice actually improves the conversation agent's following response. If the revised answer is better than the original, the feedback agent gets credit. If the revision makes things worse, it gets penalized.

This creates a positive-sum game. Both agents win when they collaborate well. The feedback agent learns to give advice that the conversation agent can actually use.

The training happens in two stages.

Stage 1: Freeze the conversation agent. Train only the feedback agent to recognize problems and provide helpful feedback. This builds accurate detection before moving forward.

Stage 2: Train both agents together. The feedback agent's label reward is disabled, but the improvement reward stays active. This prevents overfitting to imbalanced data while maintaining accuracy.

Why This Works Better Than Alternatives

The researchers tested several baselines.

Inference-time collaboration (no training): Just using two instances of the base model already reduced both unsafe responses and overrefusals. But feedback was triggered excessively, and the results weren't optimal.

Oracle feedback: They attempted to give the system perfect labels converted to template feedback, such as "avoid unsafe content" or "don't overrefuse." This helped with safety (26.5% to 7.0% ASR) but barely dented overrefusal (25.7% to 16.6% ORR).

Why? Asking a model to be less cautious requires convincing it with reasoning, not just instructions. Detailed feedback matters, especially for reducing overrefusal.

Single-model RL: Training just the conversation agent improved safety but not as much as WaltzRL. And it didn't benefit from adaptive feedback at inference time.

WaltzRL beats all of them on both metrics simultaneously.

The Numbers That Matter

Tested across five diverse datasets.

Safety under attack

- WildJailbreak: 39.0% to 4.6% ASR

- FORTRESS harmful: 40.4% to 6.2% ASR

- StrongREJECT: 0.0% to 0.3% ASR

Over refusal on benign prompts

- OR-Bench: 45.3% to 9.9% ORR

- FORTRESS benign: 6.0% to 5.4% ORR

General capabilities: Minimal degradation across AlpacaEval, IFEval, GPQA, MMLU, and TruthfulQA, even though they used zero helpfulness prompts during training.

That last part is essential. WaltzRL trains only on adversarial attacks and borderline overrefusal cases. No general helpfulness data. Yet instruction-following and knowledge stay intact.

What Makes This Different From Debate

AI safety through debate involves agents competing in zero-sum games. One agent attacks, one defends. A higher reward for one means a lower reward for the other.

WaltzRL is collaborative. Both agents pursue the same goal: safe, non-overrefusing responses. It's positive-sum, not zero-sum.

And unlike debate approaches that train multiple agents but deploy only one, WaltzRL deploys both agents together at inference time. An attacker has to jailbreak both agents to succeed.

The Emergent Behavior

Something interesting emerged during training: the feedback agent started directly quoting ideal responses.

Instead of just saying "make it safer," it would generate an outline or even complete sentences that the conversation agent should use. The conversation agent learned to follow this guidance.

This wasn't explicitly programmed. It emerged from the Dynamic Improvement Reward. The feedback agent discovered that specific, concrete suggestions work better than vague instructions.

What This Means

WaltzRL pushes forward the Pareto frontier between safety and helpfulness. You can have both.

The key insight is treating alignment as collaboration, not control. Two specialized models working together outperform one model trying to do everything.

Traditional guardrails are gatekeepers. They say yes or no to entire responses.

WaltzRL is an editor. It looks at what you wrote and suggests improvements.

That difference, between blocking and refining, unlocks better results on both safety and helpfulness.

The paper is open research from Meta. All experiments use Llama 3.1-8B-Instruct as the base model for both agents.

Future work could explore training generalist feedback agents that work off-the-shelf with different conversation models. Or expanding beyond one round of feedback to multi-turn refinement.

For now, WaltzRL shows a clear path forward: if you want AI systems that are both safe and helpful, teach two agents to dance together instead of making one agent walk a tightrope alone.

Paper: The Alignment Waltz: Jointly Training Agents to Collaborate for Safety (arxiv.org/abs/2510.08240)

Authors: Jingyu Zhang, Hongyuan Zhan, and team at Meta Superintelligence Labs

In this episode of the AWS Developers Podcast, we dive deep into Strands Agents, AWS's open-source framework for building AI agents. Our guest Arron Bailiss, Tech Lead for Strands, explains how this framework evolved from an internal AWS tool to a developer-friendly, open-source solution. Learn how Strands simplifies AI agent development with just a few lines of code while maintaining production-ready capabilities. Aaron discusses the framework's unique model-driven approach, its support for both MCP and A2A protocols, and how it powers various AWS services including Amazon Q Developer and AWS Glue. Discover how Strands enables multi-agent systems through swarms, supports various deployment options, and get insights into the roadmap including TypeScript support and voice agent capabilities.

With Arron Bailiss, Tech lead, Strands Agents

Strands Agents

Strands on GitHub

Download audio: https://op3.dev/e/dts.podtrac.com/redirect.mp3/developers.podcast.go-aws.com/media/186.mp3

Explore the benefits of intelligent query processing and how it enhances performance in Azure SQL with minimal effort.

The post Intelligent Query Processing in Azure SQL: A Deep Dive into Adaptive Execution appeared first on MSSQLTips.com.

Windows App SDK 1.7.5 (1.7.251014001)

WinAppSDK 1.7.5 is the latest stable version of WinAppSDK 1.7 providing new features and improvements to the platform. To see everything that's new and changed, see the full Windows App SDK 1.7 release notes.

This release also includes the following Bug Fixes:

Bug Fix	Runtime Compatibility Change
Fix scrolling when the setting "Scroll inactive windows when hovering over them" is off.	InputPointerSource_FixScrollForInactiveWindowSetting
Fixed an issue that caused a false positive warning about a missing mspdbcmf.exe.	N/A, build .targets change

To learn more about how to disable Runtime Compatibility Changes, see RuntimeCompatibilityOptions.DisabledChanges Property

Try it out

• Download the 1.7.251014001 NuGet package to use WinAppSDK 1.7 in your app.
• Download and update the WinUI Gallery to see the WinUI 3 updates firsthand.

Getting Started

To get started using Windows App SDK to develop Windows apps, check out the following documentation:

• Install developer tools .
• Create a WinUI 3 app.
• Continue your development journey.

---

This discussion was created from the release Windows App SDK 1.7.5 (1.7.250909003).