I was on the We l Open Source podcast and talked about the threats to open source and software.
Trading openness for convenience: From app stores to AI assistants

Have you ever sat down at your computer, ready to get into a flow state, and then spent the first ten minutes just arranging windows? Dragging your editor here, your browser there, nudging Slack into a corner - only to close it all two hours later, and start from scratch the next day? Yeah. Me too.

I've been a big fan of Microsoft PowerToys for a while now. It's one of those tools that quietly makes your Windows experience feel a lot more intentional. There are a bunch of great utilities in there - but recently I've been leaning heavily on one in particular: PowerToys Workspaces.

What is PowerToys Workspaces?

Workspaces is a Windows desktop management utility that lets you capture your ideal window layout, which apps are open, where they're positioned, what size they are, and then launch that entire setup with a single click.

Think of it like a saved game state, but for your desktop.

You could have a "Coding" workspace that opens VS Code to a specific project, a browser on the side, and Terminal ready to go. Or an "Email & Admin" workspace that brings up Outlook, your calendar, and a notes app. Whatever your workflow looks like - you set it up once, and Workspaces handles the rest every time.

Setting Up Your First Workspace

If you haven't already got PowerToys installed, you can grab it from the Microsoft Store or via WinGet. Once it's running, head into the PowerToys Settings and enable Workspaces.

To create your first workspace:

1. Hit Win + Ctrl + ' to open the Workspaces editor (or go to Settings and click "Launch editor").
2. Click "+ Create workspace".
3. You'll enter Capture mode - arrange your apps exactly how you want them.
4. When you're happy hit "Capture".
5. Give it a name, tweak anything you need to, and save it.

That's it. When it you launch it, it will open those apps exactly as you'd like them. You can create as many different workspaces as you'd like depending on your needs.

The Part That Surprised Me

What I didn't expect was how useful the CLI arguments feature would be. When you're in the editor, each app has a little dropdown where you can pass command line arguments. So for VS Code, I can point it straight to a specific project folder on launch. For Edge, I can give it a comma-separated list of URLs and it'll open all those tabs automatically.

It sounds like a small thing - but removing those few extra clicks every time you start a session adds up surprisingly quickly.

Desktop Shortcut

Within the workspace editor, you can select the option to Create a desktop shortcut which creates a handy shortcut on your desktop.

I find this super handy for when I start my PC first thing in the morning. Just a double click and your workspace is loaded and ready to go. If you prefer, you could pin it to your taskbar if you really want it front and centre.

A Few Things Worth Knowing

When a workspace launches, you'll briefly see windows jumping around the screen as PowerToys repositions them. There's a status dialog that pops up to show you what's loading, which helps - but it can look a bit chaotic the first time you see it.

Also worth noting: if you've got apps snapped using Windows' built-in snap feature, Workspaces won't preserve that snapped state. It uses its own positioning engine under the hood. Not a dealbreaker, but something to be aware of when you're setting things up.

How I Use It Day to Day

If you've read my recent post on staying technical as a TPM, you'll know I'm always looking for ways to reduce friction and stay in a coding mindset. Workspaces has become one of those small but surprisingly impactful habits.

I've ended up with two workspaces that cover probably 90% of my week:

• Coding - VS Code, Terminal, and a browser window with the relevant docs.
• Daily - Outlook, Teams, Slack and a browser.

Switching between them takes a double click. It sounds almost too simple - but honestly, that's the point. The friction of setting up your environment is just gone.

If you haven't explored PowerToys yet, it's one of the best free productivity tools for Windows and the Workspaces docs are a great place to start.

Vite 8.0 is out! ​

March 12, 2026

We're thrilled to announce the stable release of Vite 8! When Vite first launched, we made a pragmatic bet on two bundlers: esbuild for speed during development, and Rollup for optimized production builds. That bet served us well for years. We're very grateful to the Rollup and esbuild maintainers. Vite wouldn't have succeeded without them. Today, it resolves into one: Vite 8 ships with Rolldown as its single, unified, Rust-based bundler, delivering up to 10-30x faster builds while maintaining full plugin compatibility. This is the most significant architectural change since Vite 2.

Vite is now being downloaded 65 million times a week, and the ecosystem continues to grow with every release. To help developers navigate the ever-expanding plugin landscape, we also launched registry.vite.dev, a searchable directory of plugins for Vite, Rolldown, and Rollup that collects plugin data from npm daily.

Quick links:

• Docs
• Translations: 简体中文, 日本語, Español, Português, 한국어, Deutsch, فارسی
• Migration Guide
• GitHub Changelog

Play online with Vite 8 using vite.new or scaffold a Vite app locally with your preferred framework running pnpm create vite. Check out the Getting Started Guide for more information.

We invite you to help us improve Vite (joining the more than 1.2K contributors to Vite Core), our dependencies, or plugins and projects in the ecosystem. Learn more at our Contributing Guide. A good way to get started is by triaging issues, reviewing PRs, sending tests PRs based on open issues, and supporting others in Discussions or Vite Land's help forum. If you have questions, join our Discord community and talk to us in the #contributing channel.

Stay updated and connect with others building on top of Vite by following us on Bluesky, X, or Mastodon.

The Rolldown-Powered Vite ​

The problem ​

Since its earliest versions, Vite relied on two separate bundlers to serve different needs. esbuild handled fast compilation during development (dependency pre-bundling and TypeScript/JSX transforms) that made the dev experience feel instant. Rollup handled production bundling, chunking, and optimization, with its rich plugin API powering the entire Vite plugin ecosystem.

This dual-bundler approach served Vite well for years. It allowed us to focus on developer experience and orchestration rather than reinventing parsing and bundling from scratch. But it came with trade-offs. Two separate transformation pipelines meant two separate plugin systems, and an increasing amount of glue code needed to keep the two pipelines in sync. Edge cases around inconsistent module handling accumulated over time, and every alignment fix in one pipeline risked introducing differences in the other.

The solution ​

Rolldown is a Rust-based bundler built by the VoidZero team to address these challenges head-on. It was designed with three goals:

• Performance: Written in Rust, Rolldown operates at native speed. In benchmarks, it is 10-30x faster than Rollup matching esbuild's performance level.
• Compatibility: Rolldown supports the same plugin API as Rollup and Vite. Most existing Vite plugins work out of the box with Vite 8.
• Advanced features: A single unified bundler unlocks capabilities that were difficult or impossible with the dual-bundler setup, including full bundle mode, more flexible chunk splitting, module-level persistent caching, and Module Federation support.

The journey to stable ​

The migration to Rolldown was deliberate and community-driven. First, a separate rolldown-vite package was released as a technical preview, allowing early adopters to test Rolldown's integration without affecting the stable version of Vite. The feedback from those early adopters was invaluable. They pushed the integration through real-world codebases of every shape and size, surfacing edge cases and compatibility issues we could address before a wider release. We also set up a dedicated CI suite validating key Vite plugins and frameworks against the new bundler, catching regressions early and building confidence in the migration path.

In December 2025, we shipped the Vite 8 beta with Rolldown fully integrated. During the beta period, Rolldown itself progressed from beta to a release candidate, with continuous improvements driven by the testing and feedback of the Vite community.

Real-world performance ​

During the preview and beta phases of rolldown-vite, several companies reported measurable reductions in production build times:

• Linear: Production build times dropped from 46s to 6s
• Ramp: 57% build time reduction
• Mercedes-Benz.io: Up to 38% build time reduction
• Beehiiv: 64% build time reduction

For large projects, the impact can be especially noticeable, and we expect further improvements as Rolldown continues to evolve.

A unified toolchain ​

With Vite 8, Vite becomes the entry point to an end-to-end toolchain with closely collaborating teams: the build tool (Vite), the bundler (Rolldown), and the compiler (Oxc). This alignment ensures consistent behavior across the entire stack, from parsing and resolving to transforming and minifying. It also means we can rapidly adopt new language specifications as JavaScript evolves. And by integrating deeply across layers, we can pursue optimizations that were previously out of reach, such as leveraging Oxc's semantic analysis for better tree-shaking in Rolldown.

Thank you to the community ​

None of this would have been possible without the broader community. We want to extend our deep thanks to the framework teams (SvelteKit, React Router, Storybook, Astro, Nuxt, and many others) who tested rolldown-vite early, filed detailed bug reports, and worked with us to resolve compatibility issues. We are equally grateful to every developer who tried the beta, shared their build time improvements, and reported the rough edges that helped us polish this release. Your willingness to test the migration on real projects helped make the transition to Rolldown smoother and more reliable.

Node.js Support ​

Vite 8 requires Node.js 20.19+, 22.12+, the same requirements as Vite 7. These ranges ensure Node.js supports require(esm) without a flag, allowing Vite to be distributed as ESM only.

Additional Features ​

Beyond the Rolldown integration, Vite 8 includes several notable features:

• Integrated Devtools: Vite 8 ships devtools option to enable Vite Devtools, a developer tooling for debugging and analysis. Vite Devtools provide deeper insights into your Vite-powered projects directly from the dev server.

• Built-in tsconfig paths support: Developers can enable TypeScript path alias resolution by setting resolve.tsconfigPaths to true. This has a small performance cost and is not enabled by default.

• emitDecoratorMetadata support: Vite 8 now has built-in automatic support for TypeScript's emitDecoratorMetadata option, removing the need for external plugins. See the Features page for details.

• Wasm SSR support: .wasm?init imports now work in SSR environments, expanding Vite's WebAssembly feature to server-side rendering.

• Browser console forwarding: Vite 8 can forward browser console logs and errors to the dev server terminal. This is especially useful when working with coding agents, as runtime client errors become visible in the CLI output. Enable it with server.forwardConsole, which activates automatically when a coding agent is detected.

@vitejs/plugin-react v6 ​

Alongside Vite 8, we are releasing @vitejs/plugin-react v6. The plugin uses Oxc for React Refresh transform. Babel is no longer a dependency and the installation size is smaller.

For projects that need the React Compiler, v6 provides a reactCompilerPreset helper that works with @rolldown/plugin-babel, giving you an explicit opt-in path without burdening the default setup.

See the Release Notes for more details.

Note that v5 still works with Vite 8, so you can upgrade the plugin after upgrading Vite.

Looking Ahead ​

The Rolldown integration opens the door to improvements and optimizations. Here is what we are working on next:

• Full Bundle Mode (experimental): This mode bundles modules during development, similar to production builds. Preliminary results show 3x faster dev server startup, 40% faster full reloads, and 10x fewer network requests. This is especially impactful for large projects where the unbundled dev approach hits scaling limits.

• Raw AST transfer: Allows JavaScript plugins to access the Rust-produced AST with minimal serialization overhead, bridging the performance gap between Rust internals and JS plugin code.

• Native MagicString transforms: Enables custom transforms where the logic lives in JavaScript but the string manipulation computation runs in Rust.

• Stabilizing the Environment API: We are working to make the Environment API stable. The ecosystem has started regular meetings to better collaborate together.

Migrating to Vite 8 ​

For most projects, upgrading to Vite 8 should be a smooth process. We built a compatibility layer that auto-converts existing esbuild and rollupOptions configuration to their Rolldown and Oxc equivalents, so many projects will work without any config changes.

For larger or more complex projects, we recommend the gradual migration path: first switch from vite to the rolldown-vite package on Vite 7 to isolate any Rolldown-specific issues, then upgrade to Vite 8. This two-step approach makes it easy to identify whether any issues come from the bundler change or from other Vite 8 changes.

Please review the detailed Migration Guide before upgrading. The complete list of changes is in the Vite 8 Changelog.

Thank You, Rollup and esbuild ​

As Vite moves to Rolldown, we want to take a moment to express our deep gratitude to the two projects that made Vite possible.

Rollup has been Vite's production bundler since the very beginning. Its elegant plugin API design proved so well-conceived that Rolldown adopted it as its own, and Vite's entire plugin ecosystem exists because of the foundation Rollup laid. The quality and thoughtfulness of Rollup's architecture shaped how Vite thinks about extensibility. Thank you, Rich Harris for creating Rollup, and Lukas Taegert-Atkinson and the Rollup team for maintaining and evolving it into something that has had such a lasting impact on the web tooling ecosystem.

esbuild powered Vite's remarkably fast development experience from its early days: dependency pre-bundling, TypeScript and JSX transforms that completed in milliseconds rather than hundreds. esbuild proved that build tools could be orders of magnitude faster, and its speed set the bar that inspired an entire generation of Rust and Go-based tooling. Thank you, Evan Wallace, for showing all of us what was possible.

Without these two projects, Vite would not exist as it does today. Even as we move forward with Rolldown, the influence of Rollup and esbuild is deeply embedded in Vite's DNA, and we are grateful for everything they have given to the ecosystem. You can learn more about all the projects and people Vite depends on at our Acknowledgements page.

Acknowledgments ​

Vite 8 was led by sapphi-red and the Vite Team with the help of the wide community of contributors, downstream maintainers, and plugin authors. We want to thank the Rolldown team for their close collaboration in making the Rolldown-powered Vite 8 possible. We are also especially grateful to everyone who participated in the rolldown-vite preview and the Vite 8 beta period. Your testing, bug reports, and feedback made the Rolldown migration possible and shaped this release into something we are proud of.

Vite is brought to you by VoidZero, in partnership with Bolt and NuxtLabs. We also want to thank our sponsors on Vite's GitHub Sponsors and Vite's Open Collective.

As AI agents transition from simple chatbots to autonomous systems capable of managing cloud incidents, navigating complex web interfaces, and executing multi-step API workflows, a new challenge has emerged: transparency.

When a human makes a mistake, we can usually trace the logic. But when an AI agent fails, perhaps by hallucinating a tool output or deviating from a security policy ten steps into a fifty-step task, identifying exactly where and why things went wrong is an arduous, manual process.

Today, we are excited to announce the open-source release of AgentRx (opens in new tab), an automated, domain-agnostic framework designed to pinpoint the “critical failure step” in agent trajectories. Alongside the framework, we are releasing the AgentRx Benchmark (opens in new tab), a dataset of 115 manually annotated failed trajectories to help the community build more transparent, resilient agentic systems.

The challenge: Why AI agents are hard to debug

Modern AI agents are often:

• Long-horizon: They perform dozens of actions over extended periods.
• Probabilistic: The same input might lead to different outputs, making reproduction difficult.
• Multi-agent: Failures can be “passed” between agents, masking the original root cause.

Traditional success metrics (like “Did the task finish?”) don’t tell us enough. To build safe agents, we need to identify the exact moment a trajectory becomes unrecoverable and capture evidence for what went wrong at that step.

Introducing AgentRx: An automated diagnostic “prescription”

AgentRx (short for “Agent Diagnosis”) treats agent execution like a system trace that needs validation. Instead of relying on a single LLM to “guess” the error, AgentRx uses a structured, multi-stage pipeline:

1. Trajectory normalization: Heterogeneous logs from different domains are converted into a common intermediate representation.
2. Constraint synthesis: The framework automatically generates executable constraints based on tool schemas (e.g., “The API must return a valid JSON response”) and domain policies (e.g., “Do not delete data without user confirmation”).
3. Guarded evaluation: AgentRx evaluates constraints step-by-step, checking each constraint only when its guard condition applies, and produces an auditable validation log of evidence-backed violations.
4. LLM-based judging: Finally, an LLM judge uses the validation log and a grounded failure taxonomy to identify the Critical Failure Step—the first unrecoverable error.

A New Benchmark for Agent Failures

To evaluate AgentRx, we developed a manually annotated benchmark consisting of 115 failed trajectories across three complex domains:

• τ-bench: Structured API workflows for retail and service tasks.
• Flash: Real-world incident management and system troubleshooting.
• Magentic-One: Open-ended web and file tasks using a generalist multi-agent system.

Using a grounded-theory approach, we derived a nine-category failure taxonomy that generalizes across these domains. This taxonomy helps developers distinguish between a “Plan Adherence Failure” (where the agent ignored its own steps) and an “Invention of New Information” (hallucination).

Key Results

In our experiments, AgentRx demonstrated significant improvements over existing LLM-based prompting baselines:

• +23.6% absolute improvement in failure localization accuracy.
• +22.9% improvement in root-cause attribution.

By providing the “why” behind a failure through an auditable log, AgentRx allows developers to move beyond trial-and-error prompting and toward systematic agentic engineering.

Join the Community: Open Source Release

We believe that agent reliability is a prerequisite for real-world deployment. To support this, we are open sourcing the AgentRx framework and the complete annotated benchmark.

• Read the Paper: AgentRx: Diagnosing AI Agent Failures from Execution Trajectories
• Explore the Code & Data: https://aka.ms/AgentRx/Code (opens in new tab)

We invite researchers and developers to use AgentRx to diagnose their own agentic workflows and contribute to the growing library of failure constraints. Together, we can build AI agents that are not just powerful, but auditable, and reliable.

Acknowledgements

We would like to thank Avaljot Singh and Suman Nath for contributing to this project.

The post Systematic debugging for AI agents: Introducing the AgentRx framework appeared first on Microsoft Research.