Matt Hobbs, PwC’s cloud, engineering, data and AI platforms leader, has laid out a stark reality for enterprises: the gulf between a working AI proof-of-concept and durable, enterprise-scale value is not bridged by larger models or more data scientists but by the grinding, unglamorous work of modernization. Speaking on the Cloud Wars AI Agent & Copilot Podcast, Hobbs introduced an orchestration and integration fabric PwC calls Agent OS—a practical response to the tangle of legacy systems, cloud sprawl, and governance gaps that keeps most agentic AI deployments locked in pilot purgatory.

PwC’s message arrives as hyperscalers pour billions into AI infrastructure and enterprises scramble to turn Copilot and agent demos into bottom-line results. For Windows and Microsoft Azure shops, the approach carries specific resonance: Agent OS is designed to plug into Azure, along with AWS, OCI, and Google Cloud, presenting a unified API surface that hides the ugly plumbing. But Hobbs’ real insight is that technology alone is worthless without an outcomes-first discipline that starts with productivity, moves to efficiency, and only then chases net-new value creation.

The Integration Backbone: What Agent OS Really Is

Agent OS is not a marketing label for yet another AI platform. Hobbs describes it as an enterprise-agnostic orchestration layer built from necessity—to connect cloud services from multiple hyperscalers with stubbornly persistent legacy systems, and to let agents “learn” from each other by sharing durable, operational knowledge exposed as microservices. In practice, that means:

  • A solid integration layer that masks heterogeneity across Azure, AWS, OCI, Google Cloud, and on-prem mainframes
  • Microservices and APIs that make business logic discoverable and reusable by any agent, regardless of where it runs
  • Pluggable adapters for major cloud providers so hybrid deployments don’t force a rewrite every time a new agent is needed

These capabilities are not fanciful. During the podcast, Hobbs grounded the discussion in real customer use cases—airlines and insurers where an agent must internalize unique business rules, regulatory constraints, and operational context to be useful. That requires more than a generic LLM call wrapped in a chat interface. It demands an architecture where agents can reason over modular, observable services that faithfully expose the logic once buried in COBOL routines or undocumented spreadsheet macros.

For Windows-centric organizations, the reference to Azure is pivotal. With Microsoft’s Copilot stack, Power Platform, and Fabric gaining traction, enterprises already deep in the Microsoft ecosystem can see Agent OS as a way to standardize how agents—whether Copilot-based or custom—connect to data and services across hybrid estates. The promise: stop hand-coding a new integration for every agent and every system, and start building a composable fabric that makes agentic workflows safe, auditable, and repeatable.

Outcomes-First, Not Technology-First

Hobbs structures the AI adoption journey into three sequential goals: productivity first, then efficiency at scale, and finally the creation of completely new AI-enabled products and services. Too many organizations, he argues, invert this order, chasing a visionary AI use case before they’ve wrung basic time savings from existing processes.

Productivity gains come from using copilots and agents to shave hours off common knowledge-worker tasks—summarizing documents, generating reports, routing approvals. Once those are institutionalized, efficiency targets kick in: reducing latency in supply chains, automating compliance checks, optimizing cloud resource allocation. Only after the organization has both data and operational muscle does it make sense to design net-new services, like an insurance underwriter that can bind coverage in seconds because an agent has already ingested 30 years of policy data and built a risk model.

The engineering work that underpins this progression is where most teams stall. Hobbs prescribes a clear modernization path:

  1. Inventory critical workflows and data owners
  2. Decompose monoliths and extract deterministic services
  3. Build the integration fabric (Agent OS or a similar construct)
  4. Pilot agents on well-instrumented, high-value workflows
  5. Iterate with tight feedback loops between agents, engineers, and business owners

This sequence deliberately avoids the trap of automating a brittle process that will collapse the moment conditions change. It also aligns with the technical reality of Azure-heavy shops: decomposing legacy .NET monoliths or mainframe applications into containerized services that can be exposed through APIs enables not just agents but any modern workload to consume that logic.

The Hidden Tax: Technical Debt

One of Hobbs’ bluntest observations is that AI doesn’t remove technical debt—it exposes it with brutal efficiency. When an agent attempts to automate a process and hits an undocumented integration, an ambiguous data pedigree, or a hard-coded business rule in an Excel sheet, the result isn’t just a failed automation; it’s often a costly incident that erodes trust in the entire AI program.

PwC’s answer is to treat modernization as a prerequisite, not an afterthought. That means extracting and refactoring business logic into observable services before giving agents wide freedom. The approach is not a big-bang rip-and-replace; Hobbs acknowledges that legacy systems will persist for years. Instead, Agent OS is designed to wrap and virtualize those legacy endpoints, presenting them as clean, intent-driven microservices that agents can consume safely while the underlying systems are gradually modernized.

This has direct implications for the Windows server base. Many enterprises still run mission-critical workloads on Windows Server and SQL Server, often with layers of custom business logic built in .NET Framework. By exposing those functions through a governed API gateway—something Azure API Management can facilitate—those assets become part of the Agent OS fabric without a rewrite. It’s a pragmatic path that respects sunk costs while making systems agent-ready.

Cloud Architecture: Avoiding Sprawl as Agents Multiply

Most organizations, Hobbs notes, are still in proof-of-concept stages for AI. The central blockers are data readiness and architectures never designed for autonomous agents. Without centralized, curated data environments, agents will hallucinate, make unsafe decisions, or force expensive integration work downstream.

The risk of cloud sprawl intensifies as agentic workflows multiply. Each agent may need to touch five different cloud services across three providers, generating costs that are difficult to attribute and impossible to predict. Hobbs’ playbook for avoiding this chaos includes:

  • Treat cloud providers as interchangeable compute and service layers only when architecture and governance are standardized
  • Use Agent OS to present a homogeneous API surface so agents don’t need to know which cloud they’re calling
  • Enforce tagging, cost governance, and lifecycle policies—Microsoft Azure’s native tools like Policy and Cost Management fit this model well
  • Migrate critical datasets to governed, centralized stores such as Microsoft OneLake or other data lakehouse architectures

This advice echoes the broader community discussion around Microsoft Fabric and unified data platforms. For Windows-focused enterprises, co-locating Agent OS orchestration with Azure-native governance tools can simplify compliance, especially for organizations already using Entra ID for identity.

The Economics of Model Consumption

A key operational insight from Hobbs is that modern model provider pricing—typically consumption-based rather than reserved capacity—rewards clever architecture. Well-designed agent workflows that minimize token usage, cache interim results, and tier their model selection can be dramatically cheaper than naïve implementations.

PwC’s cost-control playbook includes:

  • Implementing result caching and session memory policies so repeated queries don’t re-run expensive model calls
  • Tiering models: using smaller, cheaper models (like GPT-4o mini or open-weight alternatives) for intent routing, reserving large models for complex synthesis
  • Centralizing model access through a broker service—part of Agent OS—to monitor, throttle, and audit consumption across the enterprise

For Azure customers, this logic maps naturally to Azure OpenAI Service with its token-based pricing and the ability to switch models via the same endpoint. An Agent OS that sits on top of these services can enforce policy while still allowing experimentation with different model sizes.

Industry Use Cases: Airlines and Insurance

Hobbs highlighted airlines and insurance as verticals where agents deliver the most immediate impact. Both share traits that make them a proving ground:

  • Complex, slow-running processes (claims adjudication, passenger disruption recovery) that are rich in business rules
  • Heavy dependence on SLAs and regulatory compliance that can be encoded and observed
  • High-touch customer interactions where time-to-resolution directly drives satisfaction and cost

In an airline, an agent that understands flight schedules, rebooking policies, passenger preferences, and real-time operational data can resolve a disruption in seconds rather than the 45 minutes a human agent might take. That’s not just a cost saving; it’s a customer experience transformation. But the agent only works if it can reach into a dozen legacy systems—reservations, crew scheduling, weather feeds—via a consistent, governed interface. That’s the Agent OS value proposition in a nutshell.

Similarly, in insurance underwriting, an agent can ingest decades of policy data, apply regulatory rules, and generate a bindable quote if the underlying data models and business rules have been decomposed into callable services. PwC’s emphasis on industry-specific agents—rather than generic copilots—is a deliberate hedge against the hallucination and blandness that plague general-purpose assistants.

Governance, Trust, and Safety: Baked In, Not Bolted On

Hobbs regards governance as a first-order architectural concern, not a compliance checkbox. Agent OS enforces identity-aware access, auditable decision trails, and explicit escalation paths. Every agent action is routed through controlled microservices, with policies that can require human-in-the-loop for high-risk decisions.

The practical governance checklist that emerges from the discussion:

  • Enforce least-privilege data access for every agent, tied to the identity of the human on whose behalf it acts
  • Require human approval for actions above predefined risk thresholds (e.g., moving money, changing entitlements)
  • Log every agent action with full context and rationale, akin to a flight recorder for AI
  • Maintain model cards and versioning so reproducibility and safety reviews are possible

These measures are not optional in regulated industries, but they are equally critical for any enterprise seeking to scale agents beyond a handful of trusted users. The architecture echoes the Zero Trust principles Microsoft has been advocating, making it a natural fit for Azure-adopting organizations.

The Road Ahead: A Decade-Long Journey

Hobbs frames agentic AI as part of a persistent, decade-long trend that will unfold in multiple waves. Current copilot and agent capabilities are just the beginning. Sustained hyperscaler investment—Microsoft’s capex on AI infrastructure, for one—will continue to change the economics of what’s possible, but the winners will be those who build durable capabilities now: data platforms, integration fabrics, governance.

For IT leaders in the Windows community, the implications are clear. Don’t bet on a single point solution or model. Instead, invest in the plumbing:

  • Centralized, governed data estates (Fabric, OneLake, or similar)
  • Integration fabrics that can span Azure, on-premises, and other clouds
  • Governance frameworks that can evolve as agent autonomy increases

PwC’s Agent OS may not be a product you can buy off the shelf, but the engineering principles behind it are actionable today. Start with inventorying high-value workflows, decompose the logic that powers them, and build the integration layer that turns legacy chaos into agent-friendly services. Only then scale agents with discipline, measuring not in terms of AI features deployed but in tangible business outcomes—revenue, margin, time-to-insight.

The 2026 AI Agent & Copilot Summit, running March 17–19 in San Diego, will focus on operationalizing these very patterns. For enterprises still stuck in proof-of-concept, the message is succinct: the hardest part of AI transformation isn’t the model—it’s the modernization.