Sr. Content Developer at Microsoft, working remotely in PA, TechBash conference organizer, former Microsoft MVP, Husband, Dad and Geek.
165294 stories
·
33 followers

Matthew Renze on Best Practices When Working With AI Agents

1 Share

Episode 930

Matthew Renze on Best Practices When Working With AI Agents

Matthew Renze does AI consulting while pursuing a doctorate in AI. He describes things to consider when build AI Agents and when using AI Agents.

Read the whole story
alvinashcraft
just a second ago
reply
Pennsylvania, USA
Share this story
Delete

Wait, is Google Antigravity *good* now?

1 Share

About a year ago, Google shipped the first version of the Antigravity IDE. It was basically an agent-centric VS Code fork. Fine tool, fine models underneath. Nothing world-beating, but certainly useful. Back in May, the product rebooted with Antigravity 2.0, an agent-first experience that pushed the IDE to the background, and focused on the desktop app and CLI experience. Better tool, better models. It didn’t leapfrog competition, but put Google in the game. Here in November of 2026, it’s a different story. The product caught up with competitors in key areas, innovated in a few others, and is powered by legitimately good coding models. It’s worth a second (third, fourth) look!

Disclaimer: I work at Google and use Antigravity every day, alongside tens of thousands of coworkers. I do so because I prefer to use what I ask developers to use! While I use an internal version of Antigravity for day to day work, I also use my personal Google AI Pro subscription so that my developer experience often feels like that of a “regular” user. I’ve done my best to deliver a fair assessment below, but please point out any mistakes I make about the landscape.

Over the last 90 days (August 19 – November 17, 2026), no other leading AI developer tool shipped as many net-new capabilities as the Google Antigravity team did. To be sure, everybody has been shipping a ton in this space. Across all surfaces (Antigravity App, CLI, IDE, SDK, IDE extensions) we delivered 150 versioned releases, and 900+ public changelog items. Claude Code delivered ~84 CLI releases with hundreds of total items, Microsoft dropped dozens of features as part of this GitHub Universe window, Devin had ~58 tracked releases, OpenCode delivered about 65 tagged releases, and OpenAI Codex had about 40 shipping events.

Now you might say “sure, you shipped a lot of features because you were behind on functionality others already had.” True. We still needed to ship them, though! Let’s look at those items first.

Catching up

Over the past 90 days, Antigravity added a lot of features already present in other great AI tools.

Plugin / skill / MCP marketplace. You want an easy way to find and install useful plugins. OpenAI Codex, Claude Code and others have this. We’ve added a helpful “customizations” experience for discovery and management of these extensions.

Manual context compaction. Claude, Cline, and OpenCode have this. Now you can do an on-demand summarization with Antigravity. We also doubled the automatic context checkpoint from 256k to 512k tokens, which is unique.

Lifecycle hooks. Anthropic invented this taxonomy and now we have these plugin lifecycle hooks for PreToolUse, PostToolUse, Stop, SessionStart events.

Consolidating on AGENTS.md and directory-scoped rules. Instead of proprietary frontmatter-only rule files, we’ve changed (alongside Cursor, Claude Code, Codex) towards AGENTS.md with parent directory traversal.

Default “auto mode.” How much do you want to be interrupted to provide feedback on harness decisions? Other tools offered an auto permission mode, and we’ve added to the existing “turbo”, “request review”, and “default” options.

Remote control of a local terminal. Drive your laptop session from a phone. Claude Code popularized this, and now you can steer your machine from anywhere.

Side-channel questions and mid-turn steering. Claude Code and Copilot offer /btw for tangential questions. Antigravity now has that too, with a good experience where you can also pick which model answers the question. You can also add relevant questions mid-stream and immediately send those updates to the main trajectory.

Autonomous browser use. We’ve had browser use in the past, as did most tools, but we removed it. We’ve since updated that, and now have a rich /browser experience for opening web pages, interacting with running apps, inspecting errors, taking screenshots, and more.

Raw key auth and bidirectional stream/json piping. Like Aider, OpenCode, and Claude Code, you can now stream JSON out for better Unix piping. And we’ve added API key as a CLI parameter for non-interactive scenarios. All of this helps background workers.

Jumping ahead

Besides adding functionality that everyone else has, the Antigravity team recently introduced a set of relatively unique features for those building with AI.

Remote cloud agents. Keep executing even when the laptop closes. Remote Agents run in a persistent cloud VM attached to GitHub repos or Google Drive folders. Access this from anywhere.

Gemini 4 Argon, Carbon, Hydrogen, and Orchestrator. Objectively, the Gemini 4 models are strong coding models. In both benchmarks and real-world usage, developers are increasingly leaning on them. Antigravity also added support for Claude Sonnet 5.5 and Opus 5.5. Note different access based on subscription tier.

Shared-board agent swarms. /swarm mode is pretty awesome. Run a team of named agents that work in parallel and share a message board. Easy to start, and the visualizations make it easy to see what’s going on.

Zero-install dynamic Python workflows. This one is brand new. The Antigravity agent writes a runs a Python script that creates a predictable control flow for your agents.

Full-duplex Gemini Live voice. Unlike others that offer a audio recording as input, Google Antigravity ALSO supports an ongoing two-way conversation with the agent. Pairing this with remote agents and on-the-go work feels compelling.

Direct subagent messaging. With the Antigravity CLI, you can DM a subagent directly from the main conversation. We’ve made a lot of investment in making multi-agent feel natural.

Generative interfaces in the main chat. Ask the agent to create interactive widgets for the output.

Unmatched surface breadth and usable $0 tier. Use a desktop app, IDE, CLI, IDE extensions (for VS Code, Visual Studio, Eclipse, JetBrains, Zed, XCode), and an SDK. It’s all available in the free tier, as well as paid tiers. The paid tiers give you access to more up-to-date models, more quota, and more functionality (e.g. multi-agent teamwork, remote control).

Serving developers in the enterprise

Sure, many individuals don’t care about “enterprise” features. But millions of developers want to use rad agentic tools at work, so these capabilities matter. Many vendors are chasing the same set of functionality, as it’s required for winning businesses at scale.

Seat bundling and consumption flexibility. Antigravity usage is now included with Gemini Enterprise Standard and Plus seats. Or, get it seat-free with Gemini Enterprise pay-as-you-go.

Multi-vendor frontier model governance. Gemini Enterprise admins can enable (or disable) developer access to frontier models from Anthropic and Google. All this on one bill, with the same Google Cloud Terms of Service and IAM perimeter.

Pooled quotas with per-user caps. The individual user quota is pooled together so that the whole team can tap into it. But we’ve also got controls to prevent one user from chewing it all up.

Granular harness, browser, MCP and plugin guardrails. Set up policies to centrally govern MCP server allowlists, plugin/marketplace access, browser rules, and more.

Gaps that remain

None of these AI developer products are “done” and we have room to improve ourselves. Many of these items are present in other products, and our Antigravity team is going to keep quickly closing gaps while adding novel features.

OS-level desktop computer use. Claude Desktop, Codex Desktop, GitHub Copilot App all work with more than sandboxed browser tabs.

Autonomous PR merge and inbound chatops triggers. Antigravity doesn’t have the autonomous PR closure like Copilot’s “Agent Merge” and lacks the @ mentions cloud triggers inside Slack, Teams, or Jira threads.

Ambient memory. Memory remains manual (/learn triggers reflection) versus nightly auto-consolidation (like Devin’s dreaming).

Take it for a spin

Google Antigravity is faster, more usable, with better functionality, and backed by better models than ever before. It’s genuinely fun to use for coding, research, content creation, and tons of other tech and non-tech use cases.

Jump aboard the train.



Read the whole story
alvinashcraft
14 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Hosted agents in Foundry Agent Service at Ignite 2026: from pilot to production inside your enterprise boundaries

1 Share

Over the last few months I’ve worked with a lot of teams taking a hosted agent from pilot to production. A working demo is only the start. The questions that decide whether it ships come next: Will the subnet hold up when usage takes off? Can the agent call internal services that use our own certificates? Where exactly can it connect, and who decides? Can it run on the Azure Kubernetes Service (AKS) clusters we already operate? And what happens when a two-hour job gets interrupted?

At Microsoft Ignite 2026, we’re announcing a solution to each of these challenges for hosted agents in Foundry Agent Service. Below you’ll find what’s new, what you can use today, and what’s still to come. The egress and private CA updates apply to managed hosted agents, the ones Foundry runs for you; BYO-AKS support will be documented separately.

At a glance

What’s new What it means for you Status
Shared subnet IPs Run many more sessions from the same subnet; your session quota still applies Generally available (GA)
Private CA trust Call internal services that use your company’s certificates, with certificate checks still on Public preview
Network egress controls One place to decide where an agent can connect, enforced outside the agent Generally available (GA)
Azure Policy governance for egress Admins require compliant egress settings across a subscription or resource group Public preview, starting in three regions
Deploy hosted agents to your own AKS clusters Foundry’s agent runtime on your own AKS cluster Public preview targeted for early December
Long-running resilient execution Opt-in recovery for long jobs after a crash or redeploy Generally available
Configurable idle timeout Sessions can wait from 2 minutes to 4 hours between requests Generally available
Memory snapshots Faster cold starts for agents with heavy startup Public preview
A2A passthrough Host your A2A v1.0 agent on Foundry with a small Python adapter Public preview

Scale: run far more sessions from the subnet you already have (GA)

If you run hosted agents in your own virtual network, each session used to take its own IP address from your delegated subnet. A /24 topped out at about 250 concurrent sessions, and teams with a tight IP plan hit that wall fast.

Hosted agent sessions now share subnet IP addresses. Each session still runs in its own VM-isolated sandbox. What changes is how far your subnet goes: our planning estimate for a /24 is now about 60,000 concurrent sessions, and even a /27, the smallest supported size, is planned for about 7,500. IP sharing is on for everyone, with no request needed.

These are planning estimates, not guarantees, and we still recommend a /24 or larger for production so there’s room for upgrades and maintenance. For most teams, your regional session quota is now the practical ceiling: by default 2,000 or 1,000 concurrent sessions per subscription, depending on the region. You can ask for more through a support request.

Status: Generally available now. See subnet size and concurrent sessions.

Trust: call internal services that use your company’s certificates (public preview)

Internal MCP servers, APIs and model gateways often use certificates from a private certificate authority (CA). Agents didn’t trust them, so calls failed, and the tempting fix was turning off certificate checks. Security teams don’t like that fix, for good reason.

Now you register your CA once on the Foundry resource. The CA certificate lives in Azure Key Vault, and every project in the resource picks it up. Certificate and hostname checks stay on, public CAs stay trusted, and you don’t bake CA files into container images or recreate project capability hosts.

Trust covers two paths. Tools, toolboxes and bring-your-own-model gateways use your CA in projects on your own virtual network, usually within a minute of the update. Hosted agent code that calls internal services directly trusts your CA in new sessions. The docs list what isn’t covered yet, such as remote builds and mutual TLS.

Status: Public preview. See Connect agents to services that use a private certificate authority.

Control: network egress controls are generally available (GA)

A tool list isn’t a network boundary. Agent code can start a subprocess, a library can follow a redirect, and generated code can call anything. Security teams want one place to say “these hosts, nothing else.”

Network egress controls for hosted agents are now generally available. You attach an ordered list of rules to an agent: allow or deny hosts, add headers on the way out, or send traffic through your own gateway. Foundry enforces the rules outside the agent’s sandbox, before requests reach their destination, so they don’t depend on the agent’s code behaving. If a policy can’t be evaluated, the request is denied. Egress controls add to your own network controls, like Azure Firewall; they don’t replace them.

If security review is what’s holding your agent back, start here. Turn on Audit mode with a default of deny. In Audit mode, Foundry logs every request it would have blocked but lets it through. Header changes and rewrites still apply, so test them in a non-production environment first. Run representative tasks, review the destinations you see, and refine the allowlist. Then switch to Enforce and deploy a new agent version, since running sessions keep the policy they started with. Your security team reviews a list built from real traffic instead of a guess.

Admins get a central check too. With Azure Policy governance (public preview), you assign policy at a scope such as a subscription or resource group, and Azure Policy checks that egress settings and new hosted agent versions follow your rules, like Enforce mode, a default of deny, and only approved destinations. Start in Audit to see what doesn’t comply, then switch to Deny to block noncompliant changes. Sessions that are already running keep going uninterrupted. The governance preview starts in Canada Central, Spain Central and Korea Central.

Above Security runs its AI investigative agents on hosted agents inside its own network:

“Insider risk is an investigation problem, not a policy problem, and Microsoft Foundry gives our AI investigative agents a secure home on Azure. With hosted agents in Foundry Agent Service running inside our own network and Claude served natively through Foundry, we can bring our agents to Azure customers without rewriting them.”

Amir Boldo, CPTO & Co-founder, Above Security

Status: Egress controls are generally available (GA). Azure Policy governance is in public preview. See Add guardrails to a hosted agent and Govern hosted agent egress with Azure Policy.

Deploy: run agents on clusters you already operate (public preview targeted for early December)

With this new deployment option, Foundry runs the agent runtime on your Azure Kubernetes Service (AKS) cluster. You build, deploy and call agents through Foundry the same way you do today, with the same APIs, azd flow and endpoint. Each session runs as its own pod in a lightweight VM (AKS pod sandboxing), so sessions stay isolated from each other. Your networking, container registry, policies and capacity stay yours.

Managed Hosted Agents are the best fit when you want Foundry to operate the hosting infrastructure for you. The option to BYO-AKS is designed for organizations that already operate AKS as a platform or need agent workloads to run within an infrastructure, network or compliance boundary they manage. It gives customers a choice of operating model without changing how developers work with agents in Foundry.

Your platform team controls the cluster capacity and scaling, network configuration, container supply chain, storage settings and infrastructure monitoring. You can apply existing virtual networks, private connectivity, DNS, routing, firewall and egress controls; choose node pools and registry integrations; and use your established storage and observability practices.

Responsibility is shared. Foundry manages the agent lifecycle and the Foundry-managed integration components. You operate the AKS cluster and its supporting resources, such as networking, node pools and storage.

OctopusOS runs on hosted agents today and sees the AKS deployment as the way to extend into its customers’ own environments:

“At OctopusOS, our customers – like accounting firms handling sensitive client data – need agents to run where their data and compliance boundaries are. Foundry Agent Service already gives us a managed, governed agent runtime; bringing our own AKS lets us extend that same experience into customer-controlled environments without rebuilding our platform.”

Ran Tao, CEO & Founder, OctopusOS

Status: Public preview is targeted for early December. Sign up now and tell us what you need.

Recover: keep long-running jobs going through restarts and long pauses (GA)

With resilient execution, agents that opt in can recover long jobs after a crash, restart or redeploy instead of starting over, and reconnecting clients can pick up the streamed output. Recovery reruns your handler, so save progress as you go and make sure actions like sending an email aren’t repeated.

Sessions can also wait longer between requests. You can set the idle timeout per agent version from 2 minutes to 4 hours (15 minutes by default). Without memory snapshots, session files survive idle periods, and a session is deleted after 30 days of inactivity.

For full workflow orchestration, we’re working with Temporal. Customers who want to combine Temporal’s durable workflows with hosted agents can contact Temporal for early access to the integration. Public preview is planned for early 2027.

Status: Resilient execution and configurable idle timeout are generally available (GA). See Resilience for long-running hosted agents.

Accelerate: cut cold starts with memory snapshots (public preview)

Cold starts add up when every new session imports the same libraries and loads the same data. With memory snapshots, Foundry captures your agent once it’s ready and restores that state for new sessions, so they skip repeated startup work. You turn it on per agent version, in Python or .NET.

One catch: a snapshot restores your agent’s ready-to-run starting point, not a running session. Memory and local files, including $HOME, don’t survive an idle period in snapshot sessions, so keep state you need later in external storage, or leave snapshots off.

Status: Public preview. See Enable memory snapshots for hosted agents.

Connect: bring your A2A agent (public preview)

If you already built an Agent2Agent (A2A) v1.0 agent, you can now host it on Foundry with A2A passthrough (preview) and keep your own message and task logic. A small Python adapter wraps your existing agent card and handler, and Foundry handles the endpoint, authentication and compute. The preview supports JSON-RPC, without streaming or push notifications for now, and works in all supported Foundry regions with no enrollment.

Status: Public preview. See Host an A2A-native agent.

See it at Ignite

If you’re attending Microsoft Ignite 2026, or watching on-demand content later, be sure to check out these sessions:

Get started

Tell us what’s still in the way

What still keeps your hosted agent out of production? Tell us in the comments what you’re trying to run and what’s blocking it. Most of what’s in this post started as exactly that kind of feedback.

The post Hosted agents in Foundry Agent Service at Ignite 2026: from pilot to production inside your enterprise boundaries appeared first on Microsoft Foundry Blog.

Read the whole story
alvinashcraft
30 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

Browser Automation Tool in Microsoft Foundry : Ignite’26 Announcements

1 Share

Enterprise-ready cloud browsers for every agent

Much of the work that keeps a business running still happens in a browser: internal portals, vendor consoles and legacy apps with no API. The Browser Automation tool in Foundry Agent Service, powered by Azure Playwright Workspaces, is now generally available. It gives every Foundry agent secure, scalable browsers with isolated sessions, and includes the following capabilities:

  • Efficiency: Expanded MCP tool primitives with action batching (GA)
  • Human-in-the-loop: Live View and Take control for authentication and steering the agent (GA)
  • Networking: Private websites with VNet injection (preview)
  • Observability: Traces, Session recording (GA)

This Ignite, the Browser automation tool is enabled with additional features for your agentic automation workloads

  • Networking: Developers can bring their own browser proxy (preview)
  • CAPTCHA management through Web Bot Auth (preview)
  • Secure sign-in: Secret management (preview) and profile reuse (preview, coming soon)

See it work: processing invoices across multiple apps

Our sample agent’s task is clear – Process 15 invoices, validate them against the rules, flag anomalies in Excel, and enter the validated invoices into the expense portal. That’s a multi-app task, and the agent hits the ground running with Browser automation tool in its toolbox.

MCP with expanded tool primitives and batching of actions

Browser automation tool offers a larger set of MCP tools built for browser work, so agents can choose the right level of control for each step of a workflow. Step-by-step tools cover the full range of interactions: opening and reading pages, taking accessibility snapshots, clicking, typing, completing forms, selecting options, handling dialogs, managing tabs, uploading files, and capturing screenshots, console messages and network requests. For multistep sequences, agents can batch actions with the run-code tool. It runs one Playwright script for the whole sequence instead of a long chain of snapshot, click and type calls. We understand efficiency matters and hence recommend batched scripts for repetitive flows, and step-by-step tools for unfamiliar pages and flows with dialogs, where checking the page at each step pays off and LLM is an enabler. Because scripts can run any code, the run-code tools stay opt-in and should be enabled only for reviewed scenarios. Learn more

Live View and Take control: Human-in-the-loop

Browser workflows sometimes reach an unexpected page state, an ambiguous choice, or a step that needs human judgement. Live View shows the agent’s browser in headed mode in real time, so developers and operators can watch it work and see exactly how it performs each action. With Take control, a person can step in to steer the browser, for example to complete a sign-in (as seen in the demo above), give an approval or recover from an unexpected dialog. They can then hand control back and let the agent continue from where it left off. This keeps people in the loop for high-impact actions without giving up the speed of automation.

Session recording

When you need to know what an agent did, session recordings let you replay its browser sessions for debugging, auditing and compliance reviews. Recording is opt-in, and recordings are stored in your own storage account, so storage role-based access control decides who can view them. Activity logs and billing observability are also available, giving you a complete record of browser activity across your workloads.

{
"tags": null,
"location": null,
"id": "/subscriptions/<subscription-id>/resourceGroups/<resource- group>/providers/Microsoft.CognitiveServices/accounts/<resource-name>/projects/proj-default/connections/browserautomation_<string>",
"name": "<string>",
"type": "Microsoft.CognitiveServices/accounts/projects/connections",
"properties":
{
"authType": "ApiKey",
"credentials": {
"key": "<API_KEY>"
},
"group": "ServicesAndApps",
"category": "PlaywrightWorkspace",
"target": "https://<region-name>.mcp.playwright.microsoft.com/playwrightworkspaces/<playwright workspace -id>/mcp",
"metadata":
{
"resourceId": ""/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<identity-name>",
"enableRecording": "false"
}
},
}

Private websites and VNet injection (preview)

Many of the most valuable enterprise workflows run on applications that aren’t on the public internet, such as internal portals, admin consoles and line-of-business systems. With VNet injection, now in preview, you can link your own virtual network and subnet directly to your Playwright Workspace. Cloud browsers can then reach applications and endpoints hosted inside that private network. The integration uses a dedicated delegated subnet, so you can set network boundaries and control browser egress with the networking policies you already apply to the subnet. Your agents can automate private applications while network access stays within your organization’s security requirements.

Diagram that shows an architecture overview of Playwright Workspaces.

Browser proxy (preview)

Enterprises often need precise control over how browser traffic leaves their environment. With browser proxy, now in preview, you can bring your own proxy and route cloud-browser traffic through your existing proxy infrastructure to meet your organization’s access-control requirements. Configurable proxy pools support domain-based routing, so traffic can go through different proxies depending on the destination. Proxy credentials are handled through Azure Key Vault and managed identities, which keeps secrets out of your automation code. You can easily set priorities for your proxies too. When a request matches more than one rule, the rule with highest priority decides which proxy handles it, so routing stays predictable even as your rules grow. Together, these features give you greater control over how your agents’ browsers connect to the web.

az rest --method put \
  --url "<api-base-endpoint>/proxy-configs/<config-id>?api-version=2026-11-01-preview" \
  --resource "https://management.core.windows.net/" \
  --body '{
    "name": "my-proxy-config",
    "description": "Corporate and EU routing",
    "keyVaultReferenceIdentity": {
      "type": "UserAssigned",
      "resourceId": "/subscriptions/<subscription-id>/resourceGroups/<resource-group>/providers/Microsoft.ManagedIdentity/userAssignedIdentities/<identity-name>"
    },
    "proxyPool": {
      "default-proxy": {
        "server": "http://your-default-proxy-hostname:8080"
      },
      "eu-route": {
        "server": "http://your-eu-proxy-hostname:8080",
        "pattern": ["*.eu.company.com", "eu.company.com"],
        "priority": 1,
        "credentials": {
          "usernameSecretUri": "https://<vault-name>.vault.azure.net/secrets/eu-proxy-username",
          "passwordSecretUri": "https://<vault-name>.vault.azure.net/secrets/eu-proxy-password"
        }
      },
      "corp-route": {
        "server": "http://your-corp-proxy-hostname:8080",
        "pattern": ["*.company.com", "company.com"],
        "priority": 2
      }
    },
    "bypass": ["status.company.com", "*.blob.core.windows.net"]
  }'

Profile reuse (preview, coming soon)

Long-running and repeated workflows shouldn’t have to sign in from scratch every time. With profile reuse, now in preview, browser profiles keep authentication, cookies and browser state between sessions, so agents skip repeated logins and setup steps. This makes multistep and long-running workflows faster. Profiles are kept in encrypted storage and governed by workspace-level role-based access control, so only authorized identities can use a saved browser state.

az rest --method patch \
--resource "https://management.core.windows.net/" \
--url "https://<region>.api.playwright.microsoft.com/playwrightworkspaces/<workspaceId>/browser-sessions/<saveSessionId>?api-version=2026-12-01-preview" \
--headers "Content-Type=application/merge-patch+json" "x-ms-mcp-call=true" \
--body '{
    "browserType": "Chromium",
    "operatingSystem": "Linux",
    "protocol": "MCP",
    "browserProfile": {
      "id": "<profileId>",
      "saveChanges": true
    }
  }'

Secret management (preview)

Agents often need credentials to sign in to the websites they automate, and those credentials should never reach the model or your application code. With secret management, now in preview, you keep secrets in your own Azure Key Vault and pass them directly to the browser. The secret is read on the server side, inside the Playwright Workspaces remote MCP server, so neither your application code nor the model ever receives the value. You can bind each secret to a domain allowlist, which stops a malicious site from capturing it. Secret URIs are versionless, so when you rotate a secret in Key Vault, the change is picked up automatically.

CAPTCHA handling (preview)

Many public websites are protected by CAPTCHAs and web application firewalls that block automated traffic.  Our focus is secure, responsible, enterprise-grade automation, not getting around a website’s security controls.

Web bot Auth (based on IETF draft) enables AI agents to cryptographically sign their HTTP requests which can help in verifying the agent’s identity for public website research tasks. We are enabling Web Bot Auth for customers by primarily 2 methods – customer self-registration OR Microsoft platform registration (via selected bot management providers like Akamai, Cloudflare, and F5). Complete this form to express interest in Microsoft platform registration.

PATCH
https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.LoadTestService/playwrightWorkspaces/{workspaceName}?api-version=2026-11-10-preview
Authorization: Bearer {{AAD Token}}
Content-Type: application/json

{
  "properties": {
    "webBotAuth": {
      "status": "Enabled",
      "signingKey": "Workspace"
    }
  }
}

Get started

To get started, create a Playwright Workspace, connect Browser automation tool to a toolbox in Microsoft Foundry, and add the toolbox to your agent. Then enable the capabilities your scenario needs. Preview capabilities are subject to change, so review their documentation before using them in production. These resources will help:

With these capabilities, your agents can reach private applications, use your network’s controls, sign in safely, carry state between sessions, and leave a full audit trail.

The post Browser Automation Tool in Microsoft Foundry : Ignite’26 Announcements appeared first on Microsoft Foundry Blog.

Read the whole story
alvinashcraft
36 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

The Foundry Dev Pack is here: build Foundry agents your way

1 Share

Your next agent can start wherever you like to build: in your editor, at the terminal, or with your favorite coding agent. At Microsoft Ignite, we’re making that first step easier: the Foundry Dev Pack (aka.ms/foundrydevpack) is now generally available, bringing the Microsoft Foundry developer tools to your machine in a single install. Move from setup to building, debugging, evaluating, and deploying agents in the environment you already know.

The Dev Pack combines the Foundry CLI (azd ai) and Microsoft Foundry Skill, and installs the Foundry Toolkit for VS Code and Foundry plugin for the GitHub Copilot app when those apps are present. It builds on a major milestone from November 5: the Foundry CLI reached general availability. Together, these tools give you more ways to move from an idea to an agent you can test and ship more efficiently.

Foundry developer tools meet you where you work

With a single command, the Foundry Dev Pack sets up your development environment so you can start building Foundry agents wherever you prefer to work.

Tool Where you work Best for
Foundry Toolkit for VS Code Editor A visual, repository-centered workflow with familiar VS Code debugging
Foundry CLI (azd ai) Terminal, scripts, CI/CD CLI-focused developers, platform engineers, and teams automating deployment
Foundry plugin for the GitHub Copilot app Desktop app Guided design choices without losing access to the generated code
Microsoft Foundry Skill Any compatible coding agent Developers using GitHub Copilot, Claude Code, Cursor, or another compatible coding agent

Mix and match as you build. The tools share project files, so you can scaffold in one, debug in another, and deploy from whichever environment fits your workflow.

Foundry Toolkit for VS Code

Keep your agent-building loop moving without leaving the editor. The Foundry Toolkit for VS Code brings together the richest feature set of the developer tools with a visual workflow and tight GitHub Copilot integration.

  • Browse your Foundry project resources and try models in the Model Playground.
  • Scaffold an agent, press F5 to debug it, and inspect requests and responses in Agent Inspector.
  • Keep models, agent code, resources, tests, and evaluations in the repository.
  • Use traces to find a problem, fix it, and redeploy from the editor.

Agent Inspector shows a local agent run with traces, latency, and tool activity.

Learn more in the Foundry Toolkit documentation.

Foundry CLI (azd ai)

Prefer the terminal? The Foundry CLI turns agent development and deployment into repeatable commands and project configuration in azure.yaml. Take the same workflow from your laptop to scripts and CI/CD pipelines, and customize infrastructure with Bicep or Terraform when you need to. Target environments and cost-bearing actions stay explicit and reviewable.

Here’s the inner loop with the basic Python Agent Framework sample. Before you begin, install Azure Developer CLI 1.37.0 or later, a current uv release, and Python 3.13 or later.

azd auth login

# Scaffold the sample into an empty folder, then review the source and azure.yaml
azd ai agent init \
  --template https://github.com/microsoft-foundry/foundry-samples/blob/main/samples/python/hosted-agents/agent-framework/responses/01-basic/azure.yaml \
  --deploy-mode code \
  --src .

# Confirm tenant, subscription, project, region, model, and quota
azd provision

# Run and invoke locally
azd ai agent run
azd ai agent invoke --local "Write a haiku about deploying cloud applications."

# Deploy from the same project
azd deploy

From there, azd ai agent monitor --follow streams logs, azd ai agent doctor diagnoses setup and permission issues, and azd pipeline config sets up GitHub Actions or Azure DevOps. For the full walkthrough, including evaluations and CI/CD, read the azd ai GA announcement.

Foundry plugin for the GitHub Copilot app

Turn an idea into a project you can inspect and shape. In the GitHub Copilot app, Microsoft Foundry Canvas opens a guided, project-aware experience alongside your chat:

  • Choose the agent’s model, tools, skills, and guardrails.
  • Copilot generates and updates the project files from your design.
  • Inspect the files and test the agent locally.
  • Project, resource, and deployment choices stay visible so you can review them.
  • Choose from a variety of built-in solution templates to get started quickly.

Your choices produce code and configuration that you can inspect and edit.

Microsoft Foundry Canvas in the GitHub Copilot app

Learn more about Microsoft Foundry Canvas.

Microsoft Foundry Skill for coding agents

Bring Foundry expertise to the coding agent you already use. The Microsoft Foundry Skill provides reusable workflows for creating, deploying, evaluating, and troubleshooting Foundry agents across compatible hosts, including GitHub Copilot, Claude Code, Cursor, and other coding-agent hosts.

The skill guides coding agents to use tools such as az, azd, MCP tools, and your repository scripts when needed. With Foundry-specific knowledge and deterministic command-line workflows built in, the skill helps agents avoid broad web searches and repeated trial and error—so they can make progress with fewer tokens and faster iteration. You stay in control: review the agent’s plans, file changes, commands, and cost-bearing actions before they run.

A coding agent invokes the Microsoft Foundry Skill while preparing a hosted-agent project.

Learn more: Microsoft Foundry Skill documentation

Get started

Ready to get your machine set up? The Foundry Dev Pack is the recommended, repeatable way to prepare for Microsoft Foundry. One install brings in the tools you need:

  • Foundry CLI (azd ai)
  • Microsoft Foundry Skill
  • Foundry Toolkit, when VS Code is installed
  • Foundry plugin, when the GitHub Copilot app is installed

Install for your operating system:

Windows

winget install Microsoft.FoundryDevPack

macOS

brew install --cask microsoft/foundry/devpack && foundry-devpack install

Linux

curl -fsSL https://aka.ms/foundry-devpack-install.sh | bash

You can use the Dev Pack’s install commands in onboarding docs, dev containers, and machine setup scripts so your team can get started with a consistent toolset.

Start building your next agent

Install the Foundry Dev Pack, then follow the hosted-agent quickstart to take an agent from project setup through local testing and deployment. Prefer to see the tools in action first? Check out these Microsoft Ignite sessions:

The post The Foundry Dev Pack is here: build Foundry agents your way appeared first on Microsoft Foundry Blog.

Read the whole story
alvinashcraft
43 seconds ago
reply
Pennsylvania, USA
Share this story
Delete

What’s new in Foundry Agent Service at Ignite 2026

1 Share

Your customers don’t judge agents by how well they demo. They judge them by whether the work gets done: the case resolved, the report delivered, the follow-up sent. That takes more than a model. It takes the right context and tools, a runtime that holds up under real demand, and a way to keep improving once real users put agents to work. At Ignite 2026, Foundry Agent Service delivers new capabilities to get you there across the agent lifecycle: Build, Deploy, and Operate.

Build more capable agents faster with the managed Microsoft Copilot harness, real-time voice, and richer tool connections. Deploy them at scale with enterprise controls, and bring them into Microsoft 365 where people already work. Operate them with confidence by turning production evidence into validated improvements. Here’s what’s new, and how each capability helps you move from idea to impact.

Build: Create agents on your terms

Build harness agents with the tools you use

The Microsoft Copilot harness, in public preview, gives developers a fully managed way to build prompt agents that reason, use tools, and complete complex, long-running tasks. Microsoft runs the agent loop and sandbox; you bring the knowledge, reusable skills, and connected tools that make the agent yours. Instead of rebuilding execution machinery, your team can focus on the agent’s expertise and results.

Author Copilot harness agents in the Foundry UI, the GitHub Copilot app, the Foundry CLI (azd ai), or the Foundry Toolkit for VS Code, and keep agent definitions in source control alongside your application code. [Read what’s new in Foundry dev tools →]

You can choose the right starting point for your application: author a prompt agent using the Microsoft Copilot harness, or bring your own code and orchestration through hosted agents. Foundry Agent Service supports those choices without requiring every team to use the same framework or take the same approach to agent logic.

Voice conversations to your agents, now generally available

Talking to AI should feel as natural as talking to a person. Voice agents in Foundry Agent Service are now generally available, giving organizations an enterprise-grade way to add real-time voice to their agents. That covers serving customers, supporting employees, and powering in-car and in-app assistants.

  • Conversations that feel human: people can interrupt, pause and change direction, and the agent keeps up.
  • Builds on what you already have: add voice to existing agents without rewriting them, and connect to phone and contact center systems through native telephony.
  • Production-ready from day one: build, deploy, monitor and improve voice agents on the same managed platform as the rest of your agents.

Thousands of customers have adopted voice agents since public preview, across customer service, automotive, education, HR and public services. [Read what’s new in Azure Speech in Foundry Tools→]

Connect tools and act across applications

At Ignite, we’re expanding how Foundry agents connect to tools, business context, and other agents. Work IQ and Fabric IQ integrations, in preview, bring Microsoft 365 context and Fabric data into agent workflows. Web Search powered by Web IQ is generally available for prompt agents, with Toolbox support coming soon, while the generally available A2A tool connects Foundry and external agents. Toolboxes make these capabilities reusable through a managed MCP endpoint, with expanded skills support, a monitoring dashboard, and preview tool policies.

Computer use and browser automation are now generally available for tasks that require an application interface rather than an API. Browser automation combines isolated browser sessions with Live View and Take control for human oversight, session recordings in customer-owned storage, and preview access to applications behind private virtual networks.  [Read what’s new in tools and toolboxes in Foundry →]

 

Deploy: Put agents to work at scale

Run hosted agents with less friction

Hosted agents let you bring your application code and orchestration to a managed runtime. At Ignite, we’re expanding scale, enterprise controls, and deployment choice:

  • Shared subnet IPs — GA: Sessions share subnet IP addresses while retaining their own VM-isolated sandboxes, reducing pressure on private IP capacity. Default quotas are 1,000–2,000 concurrent sessions per subscription and region, with increases available on request.
  • Memory snapshots — Public preview: Reduce cold starts by restoring an initialized agent state instead of repeatedly loading libraries and data. Enable snapshots per agent version; state needed across idle periods should be stored externally.
  • Network egress controls — GA: Define which destinations managed hosted agents can access, with enforcement outside the agent’s sandbox. Audit traffic before enforcing rules to build an allowlist based on actual usage.
  • Private certificate authority trust — Public preview: Connect to internal APIs, MCP servers, and model gateways that use your organization’s certificates. Register your CA at the Foundry resource level while keeping certificate and hostname validation enabled.
  • Azure Policy governance — Public preview: Require approved egress configurations across subscriptions or resource groups. Administrators can audit noncompliant settings or block noncompliant changes.
  • Long-running resiliency — GA: Opt into recovery for long-running jobs after crashes, restarts, or redeployments. Recovery reruns the handler, so developers should save progress and prevent duplicate side effects. Idle timeout is configurable per agent version, from 2 minutes up to 4 hours (15 minutes by default). When a session goes idle, compute is released and its state is saved, so the agent picks up where it left off on the next request.
  • Deployment to customer-owned AKS — Coming soon; public preview targeted for early December: Use the Foundry APIs and developer workflow while running agents on your own AKS clusters. Foundry manages the service integration; your team operates the cluster, networking, and capacity.

[Read what’s new in hosted agents →]

Bring agents into everyday work with Microsoft 365 accounts

One powerful publishing pattern is creating autonomous, always-on agents in Microsoft 365. Supported hosted agents get their own Entra Agent ID, email address, Microsoft Teams presence, and place in the org chart, so they can start conversations, work on shared files, and follow up on action items alongside people.

Foundry is integrating with Microsoft 365 Resources for Agents, which equips supported agents with their own secured Microsoft 365 resources, including a standalone mailbox, calendar, and OneDrive workspace for file storage. These capabilities will be made available to supported agents across the Microsoft portfolio.

The result: agents that work where people already collaborate, while administrators keep control of access and availability through Microsoft Entra and Agent 365, subject to tenant controls.

 

Operate: Govern and continuously improve

Production readiness means understanding how agents behave after deployment, and using that evidence to improve them. At Ignite, we’re connecting production insights, expert feedback, and optimization through continuous improvement in Foundry:

  • Insights — GA: Identify recurring issues across production traces, see supporting evidence, and investigate likely causes. This visibility also extends to agents built with LangGraph, LangChain, and CrewAI.
  • Annotations on traces — Public preview: Capture expert feedback on what worked, what didn’t, and what the agent should have done. Evaluation datasets, in preview, turn those reviews into reusable tests for future versions.
  • Insights to Agent Optimizer — Preview: Send a recurring production issue to Agent Optimizer to generate candidate fixes and test them against your evaluations.
  • Skill optimization — Preview: Turn past interactions and expert feedback into new or improved skills. Versioned skills can be reused or rolled back; the running agent changes only when your team adopts an update.
  • Cost optimization — Public preview: Find more cost-efficient model choices without compromising quality, with candidate changes evaluated before your team decides what to ship.

Every improvement should be validated before release and monitored afterward. For the full continuous improvement story, see Tina Schuchman’s blog.

“For us, agent quality is paramount and must be measurable. We can now connect tracing and evaluation so we can diagnose failures, measure quality against expert-validated answers, and continuously improve the agent. Data protection is equally fundamental: session isolation and private networking provide key controls. Together, these capabilities give us a more systematic way to keep improving the agent based on our in-house intelligence while leveraging our existing strong data controls.”

— Rasmus S Andersen, Associate Director, Products and AI, FounData, Novo

 

Start building

Whether you are authoring a harness agent with the Foundry CLI (azd ai) or the Foundry Toolkit for VS Code, scaling a hosted application, or improving an agent already in production, these updates expand what you can do with Foundry Agent Service. Start with the authoring and deployment path that fits your application, connect the tools it needs, and use production evidence to guide what comes next.

If you’re attending Microsoft Ignite 2026, or watching on-demand content later, be sure to check out these sessions:

  1. BRK240: Build and scale the next generation of AI agents in Microsoft Foundry
  2. BRK242: Build your self-improving AI Platform with Microsoft Foundry
  3. BRK243: How much should you own? Choosing the right agent architecture
  4. BRK249: From traces to better agents: The Foundry improvement loop
  5. BRK251: Agents in production: From issue detection to continuous improvement
  6. BRK422: Run open-weight models, post-training, and agents on AKS

 

The post What’s new in Foundry Agent Service at Ignite 2026 appeared first on Microsoft Foundry Blog.

Read the whole story
alvinashcraft
50 seconds ago
reply
Pennsylvania, USA
Share this story
Delete
Next Page of Stories