Feature Request: Native Multi-Container Tabs (Session Isolation) for Edge Workspaces and Tab Groups
Microsoft Edge developer team, As a developer who regularly tests complex web applications locally and on staging environments, I rely heavily on Microsoft Edge's Tab Groups and Workspaces to keep my projects organized. However, testing multi-role workflows—such as simultaneously testing Admin, Manager, and Standard User accounts on localhost—is currently very frustrating. When logging into a secondary account in another tab within the same Edge window, the newly created authentication token overwrites the existing cookies, localStorage, and session context across all open tabs for that domain. This causes the first tab to automatically switch sessions upon refresh or navigation, breaking side-by-side workflow testing. Mozilla Firefox solves this problem cleanly with Multi-Account and Temporary Containers, allowing tabs inside the same window to maintain fully isolated storage contexts. Bringing native container tabs or tab-level session isolation to Microsoft Edge, especially tightly integrated with Tab Groups, would eliminate the need to run multiple heavy browser profiles or separate windows. It would make Edge the absolute premier browser for developers, QA engineers, and power users who manage multiple user roles daily. Please consider adding tab-level container isolation to the Edge product roadmap.
Looking for feedback: local-first release checkout for Web UI and API validation
Full disclosure: I am involved with WebSureQTool, so I am not posting this as a neutral third-party review. I am sharing it as a practical QA / IT-ops pattern and would genuinely welcome critique, comparisons, and suggestions from people who already have strong release-validation workflows. Every promotion into a higher environment — QA, UAT, staging, or production-like — usually carries the same question: Are the key user journeys still working, and did this release break anything important? Many teams answer that with some combination of manual checkout, automated smoke tests, CI jobs, monitoring, or a commercial test platform. Those are all valid approaches. What I have been exploring with WebSureQTool is a more local-first and portable version of that release-checkout layer. The core idea is simple: Keep the release-checkout assets close to the team that owns the release. That means the test definitions, datasets, run evidence, and generated automation code should be easy to inspect, version, move, and retain — not just execute. The pattern I am trying to solve For each release, a team usually needs two kinds of validation. First, a standing release checkout suite: the critical paths that should always work, such as login, navigation, search, key forms, checkout flows, admin workflows, or important API checks. Second, a release-specific suite: the flows affected by the current change set. The value is not just in running the tests. The value is in making those checks repeatable, reviewable, and reusable. A manual checklist can work, but it often disappears after the release. A pipeline test can work, but sometimes it is too developer-centric for manual QA or IT-ops users. A SaaS test platform can work, but not every team wants its test assets, datasets, reports, or execution history tied tightly to a vendor account. WebSureQTool is my attempt to sit in that practical middle ground. What WebSureQTool is WebSureQTool / WSQ is a local-first QA workspace for Web UI and API testing. It lets a team build and run web/API validation suites while keeping the artifacts in a workspace they control. Suites are stored as readable YAML, datasets can be kept separately, and outputs such as logs, reports, run files, and generated code can remain under the team’s own storage and governance. The current focus is not to replace every enterprise testing platform. It is to support a practical workflow: Author a release-checkout suite. Run it before promotion. Run it again after promotion where appropriate. Capture failures as portable repro suites. Turn confirmed incident steps into future regression coverage. Export Java or C# automation when the team wants to move the same logic closer to CI. Why I think this matters In many teams, release checkout is still partly tribal knowledge. A tester knows what to click. A developer knows which endpoint changed. An ops person knows which environment is risky. A production issue gets written up as steps in a ticket. Then the next release comes, and the same knowledge has to be reconstructed again. I believe those release-checkout steps should become durable assets. With a local-first workflow, the team can keep the suite in its own repo or workspace, review changes like any other release artifact, separate environment-specific data from test logic, and preserve evidence for audit or handoff. This is especially useful when dealing with regulated, privacy-sensitive, or client-owned environments where teams may not want test data, internal URLs, execution history, or generated artifacts living primarily in a third-party cloud system. Production issue to lower-environment repro One workflow I care about is turning a production issue into a lower-environment reproduction. When something breaks in production, the slow part is often not just fixing it. It is reproducing it safely in dev, QA, or staging. With WSQ, the failing path can be captured as a suite and saved as readable YAML. That suite can travel with the bug ticket. A developer, tester, SDET, or consultant can run the same steps instead of reconstructing the issue from a written description. Environment-level datasets make this cleaner. The same repro may need different users, IDs, URLs, or records per environment. By separating the test flow from the dataset, the team can reuse the same repro suite across environments without rewriting the test logic. Once the fix is confirmed, the same repro can become part of the standing release-checkout or regression suite. Where I see the fit I do not see this as “the only right way” to do QA automation. There are already strong tools in the ecosystem: Playwright, Selenium, Cypress, Katalon, Tricentis, BrowserStack, Azure DevOps pipelines, GitHub Actions, and many others. The specific space I am trying to explore is this: A release-checkout workflow that is local-first, inspectable, portable, friendly to manual QA, useful to developers, and capable of producing automation artifacts the team can keep. For different roles, that might mean: Manual testers get a way to turn repeated release click-throughs into reusable suites. Developers get a reproducible UI/API flow that can be run locally or converted into code. SDETs and QA automation engineers get reviewable definitions, datasets, and generated code that can be curated over time. IT-ops and platform teams get clearer evidence around whether a release is safe to promote. Consultants and freelancers can hand clients artifacts the client owns instead of keeping the value trapped in someone else’s account. Honest boundaries WSQ is not a deployment orchestrator, monitoring platform, or replacement for a mature enterprise test-management system. It does not make the promote-or-hold decision for the team. It provides a way to author, run, preserve, and hand off release-validation checks. The current focus is Web UI and API validation. If a team needs large-scale distributed execution, deep mobile testing, advanced AI self-healing across huge app portfolios, or enterprise-wide governance, there may already be better-fit platforms. That is part of why I am posting here. Discussion I would really value feedback from QA, DevOps, SRE, IT-ops, and platform engineering people: Is local-first ownership of QA/release-checkout assets still a meaningful need for enterprises, especially as AI-based and SaaS-based testing platforms grow — or do modern tools already solve the ownership, portability, and auditability problem well enough?Signing in to Microsoft Foundry from OpenClaw using Azure AD: a smoother way to bring your models in
This post is a quick update to walk through the new flow. If you read the previous one, think of this as the easier path I wish I had the first time round. If you have not seen the original, you can find it here: Integrating Microsoft Foundry with OpenClaw: Step by Step Model Configuration | Microsoft Community Hub Pre-requisite: You will need the Azure CLI (azure-cli) installed on your machine. The official install guide for Linux is here: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli-linux?view=azure-cli-latest I am on Linux so I went the Homebrew route, which keeps things simple. The formula is here: https://formulae.brew.sh/formula/azure-cli Microsoft also has official docs covering the Homebrew/Linuxbrew install: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli-macos?view=azure-cli-latest#install-with-homebrew Once Homebrew is ready, run this in your terminal: brew install azure-cli Why this matters: Before this update, every Foundry model you wanted to use in OpenClaw needed its own API key and endpoint pasted into the config. It worked, but it was tedious, and keys are easy to leak if you are copying them around. The Azure AD path solves both problems. You authenticate as yourself (or a service principal), OpenClaw asks Azure for the list of Foundry resources you have access to, and it brings the models in automatically. Signing in to Microsoft Foundry from OpenClaw via Azure AD A device-code OAuth handshake replaces the old static-API-key flow. OpenClaw delegates auth to the local Azure CLI; the CLI handles the browser-side sign-in, holds the resulting tokens, and refreshes them silently. OpenClaw then walks the Azure resource graph, subscriptions → Foundry resources → model deployments and registers each model into its own config. No API keys move through OpenClaw at any point. Sequence diagram of the OAuth 2.0 device-authorization flow as orchestrated by OpenClaw. Phases 1–3 establish identity (the developer authenticates once, in a real browser, against Azure AD). Phases 4–5 perform service discovery (OpenClaw walks the ARM resource hierarchy, subscriptions → Foundry accounts → model deployments and persists the result to a local provider config). After registration, every model call OpenClaw makes against Foundry reuses the same Azure-CLI-managed token cache: tokens refresh transparently, and access is gated by the Foundry resource's RBAC assignments rather than a static API key. Dashed lines denote return values; the teal line in step 7 marks the single token-issuance event the rest of the system pivots on. Walking through the new flow: Start with the command to onboard openclaw as if you were setting up OpenClaw for the first time: openclaw onboard Kick things off with the OpenClaw onboard command, the same one you would use when setting up OpenClaw for the first time. When it prompts you, choose update values. Next, you will be asked to configure your models. Scroll down a little and you will see Microsoft Foundry listed as a supported provider. Pick it. From here, you have two options. You can sign in with an API key, which is what I covered in the previous blog post, or you can sign in through Azure AD. The Azure AD path is easier and more secure, so that is the one we will use. OpenClaw will give you a URL and a device code. Copy the URL into your browser and use the code to complete the sign in. (This is where the az CLI from the pre-requisite section earns its keep.) If everything worked, you should see a success prompt similar to this: Once you are signed in, OpenClaw will ask you to pick the Azure subscription that your Microsoft Foundry resource lives in. Pick the subscription, then pick the Foundry resource where your models are deployed. And that is pretty much it. All the models you have deployed to that Foundry resource get pulled into OpenClaw automatically. Compared to the old way of pasting API keys and endpoints one by one, this is a huge time saver, and you do not have to babysit any keys. From here you can start using your Foundry-deployed models inside OpenClaw straight away: Wrapping up The Azure AD sign-in option in OpenClaw is one of those small updates that quietly removes a real pain point. If you have ever juggled multiple Foundry endpoints and rotated keys across them, you already know why. With this flow, you sign in once, your models show up, and you can get back to actually building. If you have not tried OpenClaw with Microsoft Foundry yet, this is a good time to give it a go. And if you were holding off because of the key management overhead, that excuse is gone now. References Previous post on integrating Microsoft Foundry with OpenClaw using API keys: Integrating Microsoft Foundry with OpenClaw: Step by Step Model Configuration | Microsoft Community Hub Install the Azure CLI on Linux: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli-linux?view=azure-cli-latest Install the Azure CLI on macOS: https://learn.microsoft.com/en-us/cli/azure/install-azure-cli-macos?view=azure-cli-latest#install-with-homebrew Homebrew formula for azure-cli: https://formulae.brew.sh/formula/azure-cliLess than a week for the .NET Conf Student Zone!
Less than a week for a fantastic opportunity to learn more about .NET development and build amazing projects with C# and .NET. It's the .NET Conf 2023 Student Zone, a beginner-friendly, virtual event where experts from Microsoft and the community will teach you how to use .NET for AI, web development, mobile development, and more!
