IBM Deploys Watsonx Control Plane to Halt Enterprise Agent Sprawl
Ai4
Scaling agentic AI across multi-cloud systems requires decoupling runtime reasoning from underlying foundation models while enforcing automated governance guardrails.
## Background
Published on YouTube by the Ai4 channel on August 16, 2026, this presentation features Sunil Murthy, Watsonx Technical Lead and IBM Gen AI Field CTO. The session examines how organizations can scale agentic AI across multi-cloud environments without losing visibility, control, and accountability by bridging runtime orchestration with GRC governance.
## TL;DR
Sunil Murthy addresses the rapid proliferation of enterprise AI agents across disparate platforms like AWS, Azure, GCP, and Salesforce, warning against the operational hazards of uncoordinated multi-vendor sprawl. To counteract isolated islands of autonomy, IBM presents an open control plane architecture pairing watsonx Orchestrate with watsonx.governance to manage policies, access, performance, and token cost arbitrage. Supported by standardized Model Context Protocol (MCP) connectivity and the IBM AI Risk Atlas, the platform enables organizations to embed security guardrails and risk tiering directly into agent catalogs. Through a retail banking lifecycle demonstration, Murthy illustrates how synthetic pre-deployment testing and auditable telemetry allow enterprises to safely graduate from raw experimentation to controlled autonomy.
## Atmosphere & style
The presentation carries an authoritative, pragmatic, and enterprise-focused architectural tone characteristic of a high-level corporate technology summit. Murthy grounds complex governance abstractions with approachable analogies—such as comparing excessive token consumption on routine tasks to driving a Ferrari to the grocery store—before transitioning seamlessly into concrete runtime demonstrations. The pacing feels measured, purposeful, and reassuring, guiding technical leaders away from chaotic deployment anxiety toward a disciplined, evidence-based roadmap for scaling agentic systems.
## Key takeaways
- [00:04](https://www.youtube.com/watch?v=kJL2KLQIONY&t=4s) Enterprise software is rapidly transitioning toward agentic systems, with projections forecasting over 1 billion deployed agents within 12 to 18 months and over 2.2 billion by 2030.
- [00:04](https://www.youtube.com/watch?v=kJL2KLQIONY&t=4s) Uncoordinated multi-cloud development across AWS, Azure, GCP, and Salesforce creates severe agent sprawl and disconnected 'islands of autonomy' lacking central visibility.
- [02:19](https://www.youtube.com/watch?v=kJL2KLQIONY&t=139s) An effective enterprise control plane must systematically address four core pillars: what agents do, who has access, how they perform, and how much they cost.
- [02:19](https://www.youtube.com/watch?v=kJL2KLQIONY&t=139s) Agent registries must govern the entire dependency ecosystem—including integration tools, enterprise knowledge bases, and dynamic markdown instructions—rather than just code repositories.
- [04:23](https://www.youtube.com/watch?v=kJL2KLQIONY&t=263s) Decoupling reasoning, planning, and memory management from underlying foundation models allows organizations to orchestrate workflows across any agent or model vendor.
- [04:23](https://www.youtube.com/watch?v=kJL2KLQIONY&t=263s) Standardized gateways supporting Model Context Protocol (MCP) enable cost arbitrage by routing simple tasks to lightweight models and reserving frontier models for complex reasoning.
- [07:39](https://www.youtube.com/watch?v=kJL2KLQIONY&t=459s) Embedding risk frameworks like the IBM AI Risk Atlas into asset catalogs provides transparent risk scoring and synthetic validation benchmarks before agents are deployed.
- [10:27](https://www.youtube.com/watch?v=kJL2KLQIONY&t=627s) Proactive governance maps regulatory mandates such as the EU AI Act, GDPR, and SR 11-7 directly into runtime controls rather than treating compliance as an afterthought.
- [10:27](https://www.youtube.com/watch?v=kJL2KLQIONY&t=627s) Closed-loop governance automatically captures runtime telemetry, security endpoint data, and execution logs as auditable compliance evidence.
- [14:12](https://www.youtube.com/watch?v=kJL2KLQIONY&t=852s) Hierarchical policy inheritance enables newly onboarded agents to automatically inherit top-level guardrails, risk thresholds, and compliance checks from their parent use case.
- [14:12](https://www.youtube.com/watch?v=kJL2KLQIONY&t=852s) Enterprises must transition deliberately from raw experimentation to observed agents and controlled autonomy through rigorous synthetic testing and granular permissions.
- [18:18](https://www.youtube.com/watch?v=kJL2KLQIONY&t=1098s) Vendor-agnostic scaling requires pairing flexible runtime orchestration with evidence-based governance to avoid vendor lock-in across hybrid and multi-cloud footprints.
## Detailed walkthrough
### [00:04](https://www.youtube.com/watch?v=kJL2KLQIONY&t=4s) The Proliferation of AI Agents and the Risk of Enterprise Sprawl
Modern enterprise software development is undergoing a fundamental architectural transition where core componentry is shifting toward agentic systems. Artificial intelligence is rapidly evolving from basic models into autonomous systems of interaction and systems of action, establishing conversational and agentic interfaces as the new enterprise UI. Projections indicate exponential proliferation, with estimates forecasting over 1 billion deployed agents within the next 12 to 18 months, surging past 2.2 billion by 2030. Even organizations that have not deliberately set out to build custom agents are already adopting them, as third-party enterprise software suites increasingly arrive bundled with native agentic capabilities.
This rapid, uncoordinated proliferation creates severe multi-cloud and multi-vendor sprawl. Enterprise environments are seeing agents built across fragmented platforms, including AWS Bedrock, Microsoft Copilot, Google Cloud Platform (GCP), and Salesforce Agentforce. Without a unified architectural approach, organizations end up with disconnected "islands of autonomy" where central visibility, standardized registries, and operational control are completely lost across the business.
```mermaid
flowchart TD
accTitle: Closed Loop Agentic Governance and Orchestration Architecture
accDescr: Diagram illustrating how use case intake, policy definition, orchestration runtime, and governance monitoring interact in a closed loop.
subgraph GovPlane["AI Governance Layer (watsonx.governance)"]
A["Use Case Onboarding & Risk Intake"] --> B["Policy & Guardrail Definition"]
F["Compliance & Risk Console"] <-- "Runtime Evidence & Telemetry" --- E
end
subgraph ControlPlane["Agent Control Plane (watsonx Orchestrate)"]
B --> C["Governed Asset Catalog & Registry"]
C --> D["Operating System: Reasoning & Memory"]
D --> E["Cross-Platform Orchestration & Gateway"]
end
subgraph ExecutionLayer["Distributed Agent Execution"]
E --> G1["AWS Bedrock / Azure Copilot"]
E --> G2["Salesforce Agentforce / SAP Joule"]
E --> G3["MCP Servers & Custom Tools"]
end
```
[02:19](https://www.youtube.com/watch?v=kJL2KLQIONY&t=139s) The Four Core Pillars of the Agentic Control Plane
To counter agent sprawl, enterprises must implement a centralized control plane capable of cross-platform orchestration across hybrid and multi-cloud footprints. Rather than solely tracking isolated code repositories, a governed registry must maintain complete visibility over the entire ecosystem of dependencies that agents rely on—including integration tools, enterprise knowledge bases, operational skills, and dynamic markdown instruction files generated by coding tools such as Claude Code within CI/CD pipelines. Orchestration must prioritize high-level task completion rather than raw execution alone.
An effective agentic control plane is defined by its ability to answer four essential enterprise questions:
- **What do the agents do?** Enforcing proactive policies, operational boundaries, and guardrails.
- **Who has access?** Governing identity, access permissions, and execution rights.
- **How are the agents performing?** Providing comprehensive observability, build-time evaluation, and real-time telemetry.
- **How much are the agents costing?** Tracking token usage, computational overhead, and return on investment to measure true time-to-value.
[04:23](https://www.youtube.com/watch?v=kJL2KLQIONY&t=263s) watsonx Orchestrate: Decoupled Runtime, Evaluation, and Cost Arbitrage
IBM's agentic control plane, watsonx Orchestrate, structures agent operations across three foundational architectural components: a runtime operating system, an evaluation and observability plane, and a governed asset catalog. The agent operating system decouples the underlying reasoning, planning, memory management, and execution layers from the individual agents themselves, allowing organizations to execute workflows across IBM-native agents as well as external agents from Microsoft, AWS, GCP, or Salesforce. The platform adopts an "evaluation-first" methodology, subjecting agents to rigorous evaluation, observability, and optimization during both build time and production runtime.
A critical capability of the control plane is its standardized gateway, designed to handle Model Context Protocol (MCP) integrations, agent-to-agent communication protocols, and intelligent model routing. Sunil Murthy underscores the necessity of cost arbitrage across models with a practical analogy: "You don't need to drive a Ferrari for doing every single task. If I'm going to the grocery store... I'm not going to drive a Ferrari." A specialized gateway ensures organizations avoid consuming premium frontier model tokens for simple tasks like email drafting, reserving resource-intensive models exclusively for complex reasoning workflows.
- **Ecosystem Scale:** IBM's agentic partner network currently encompasses over 100 ecosystem partners, with an active target to scale to 500 certified partners.
- **Standardized Connectivity:** Out-of-the-box support for the Model Context Protocol (MCP) and agent-to-agent communication interfaces.
- **Deployment Flexibility:** Operational across on-premises, hybrid cloud, and multi-cloud environments behind corporate firewalls.
[07:39](https://www.youtube.com/watch?v=kJL2KLQIONY&t=459s) Open Multi-Cloud Integration and the IBM AI Risk Atlas
IBM focuses on delivering an open, vendor-agnostic control plane tailored for complex enterprise landscapes. Acknowledging that organizations are not monolithic single-vendor shops, the platform integrates natively with diverse enterprise tools, hyperscalers, and SaaS ecosystems like Salesforce Agentforce and SAP Joule. Enterprises can utilize IBM's public catalog of pre-built agents and MCP servers or deploy a private, dedicated tenant behind their own corporate firewalls to govern proprietary assets.
The platform embeds risk management directly into the asset catalog via the open-source IBM AI Risk Atlas. Building upon years of risk cataloging across classical machine learning, generative AI, and autonomous agents, the system assigns transparent risk scores and performance benchmarks to cataloged assets. This gives teams instant visibility into historical accuracy, synthetic validation tests, and vulnerability profiles prior to agent deployment.
[10:27](https://www.youtube.com/watch?v=kJL2KLQIONY&t=627s) Proactive AI Governance with watsonx.governance
Governance cannot function as an operational afterthought; it must be built proactively into the entire agent lifecycle from inception to retirement. Enterprises face strict regulatory and compliance frameworks, such as the European Union's EU AI Act, GDPR, and banking standards like Federal Reserve SR 11-7 (and its evolving supervisory guidance). Meeting these mandates requires integrated risk scoring, standardized use-case onboarding, and continuous compliance telemetry.
```
┌────────────────────────────────────────────────────────────────────────────┐
│ END-TO-END AGENT GOVERNANCE LIFECYCLE │
├─────────────────┬───────────────────┬───────────────────┬──────────────────┤
│ 1. INTAKE │ 2. RISK TIERING │ 3. ENFORCEMENT │ 4. TELEMETRY │
│ Business use │ Questionnaires, │ Inheritance of │ Real-time │
│ case onboarded; │ PII policies, and │ guardrails in │ evidence fed │
│ ownership and │ human approval │ watsonx │ back to central │
│ scope assigned. │ thresholds set. │ Orchestrate. │ audit console. │
└─────────────────┴───────────────────┴───────────────────┴──────────────────┘
```
Complementing runtime orchestration, watsonx.governance acts as an overarching governance layer that links abstract compliance policies to concrete runtime controls. When a enterprise policy stipulates that an agent cannot process personally identifiable information (PII), that control is enforced during runtime execution within watsonx Orchestrate. Telemetry and security endpoint data are automatically collected as auditable evidence and fed back into the governance console, establishing a closed-loop framework across departments, risk tiers, and operational runtimes.
[14:12](https://www.youtube.com/watch?v=kJL2KLQIONY&t=852s) Demo: Retail Banking Lifecycle and Controlled Autonomy
A live demonstration of a retail banking customer support workflow illustrates how governance and runtime orchestration interact in practice. Within watsonx.governance, administrators configure organizational guardrails that enforce input and output filtering against harmful content, prompt injection, jailbreaking, social bias, profanity, and hate speech. Through parent-child inheritance models, any newly imported agent linked to that business use case automatically inherits these baseline guardrails without requiring manual reconfiguration.
During pre-production unit testing with synthetic data, the agent's behavioral boundaries are systematically verified. In the demonstration scenario, when a banking agent lacking elevated permissions attempts to process a customer application containing personal data, the embedded guardrail blocks the submission. The administrator then adjusts the agent's autonomy settings from a restricted tier to an authorized level, granting controlled autonomy to read and update specific customer records. Sunil Murthy highlights that moving from raw experimentation to mature enterprise deployment requires managing this progression deliberately: "You go from experimentation to... observed agents to controlled autonomy."
- **Policy Inheritance:** Child agents automatically inherit top-level guardrails, risk thresholds, and compliance checks established at the use-case level.
- **Pre-Deployment Unit Testing:** Synthetic datasets validate agent decision boundaries, PII handling, and tool execution before production deployment.
- **Core Governance Maxim:** "You can't drive accountability if you don't have visibility."
[18:18](https://www.youtube.com/watch?v=kJL2KLQIONY&t=1098s) Enterprise Readiness and Vendor-Agnostic Scaling
Scaling enterprise AI agents effectively requires pairing flexible runtime orchestration with evidence-based governance by design. Organizations cannot afford to become locked into a single platform vendor; real-world production environments demand cross-functional operations where sales and service agents seamlessly interact across internal systems, third-party databases, and external platforms such as Salesforce.
IBM's high placement in industry analyst evaluations, including Gartner research, reflects real-world client implementations validating this open, enterprise-grade architecture. By decoupling agent reasoning and orchestration from underlying foundation models while anchoring every interaction to an auditable governance plane, enterprises can safely transition from unmanaged agent sprawl to governed, scalable agentic operations.
## Notable quotes
> [00:04](https://www.youtube.com/watch?v=kJL2KLQIONY&t=4s) the biggest challenge is not creating agents - it is how to scale agentic AI without losing visibility, control and accountability. — Sunil Murthy
> [00:04](https://www.youtube.com/watch?v=kJL2KLQIONY&t=4s) Traditional GRC governance and agent runtime operations often work in separate worlds, making it hard to connect policies, controls, evidence, and oversight. — Sunil Murthy
> [00:04](https://www.youtube.com/watch?v=kJL2KLQIONY&t=4s) islands of autonomy — Sunil Murthy
> [02:19](https://www.youtube.com/watch?v=kJL2KLQIONY&t=139s) What do the agents do?
> [02:19](https://www.youtube.com/watch?v=kJL2KLQIONY&t=139s) Who has access?
> [02:19](https://www.youtube.com/watch?v=kJL2KLQIONY&t=139s) How are the agents performing?
> [02:19](https://www.youtube.com/watch?v=kJL2KLQIONY&t=139s) How much are the agents costing?
> [04:23](https://www.youtube.com/watch?v=kJL2KLQIONY&t=263s) You don't need to drive a Ferrari for doing every single task. If I'm going to the grocery store... I'm not going to drive a Ferrari. — Sunil Murthy
> [14:12](https://www.youtube.com/watch?v=kJL2KLQIONY&t=852s) You go from experimentation to... observed agents to controlled autonomy. — Sunil Murthy
> [14:12](https://www.youtube.com/watch?v=kJL2KLQIONY&t=852s) You can't drive accountability if you don't have visibility. — Sunil Murthy
## Mentioned
Sunil Murthy, IBM, Ai4, watsonx, watsonx Orchestrate, watsonx.governance, IBM AI Risk Atlas, Model Context Protocol (MCP), AWS Bedrock, Microsoft Copilot, Google Cloud Platform (GCP), Salesforce Agentforce, SAP Joule, Claude Code, Gartner, EU AI Act, GDPR, Federal Reserve SR 11-7
## Video description
Sunil Murthy - Watsonx Technical Lead - IBM Gen AI Field CTO, IBM
As companies build AI agents across teams, tools, models, and clouds, the biggest challenge is not creating agents - it is how to scale agentic AI without losing visibility, control and accountability. Traditional GRC governance and agent runtime operations often work in separate worlds, making it hard to connect policies, controls, evidence, and oversight.
In this session, we’ll explore why orchestration and governance must come together as enterprises adopt AI agents at scale. Together, these capabilities help organizations connect governance intent to agent runtime controls. he result is a more trusted, measurable, and scalable path to agentic AI adoption.
As enterprise AI adoption transitions toward autonomous agentic systems, organizations face significant operational risk from multi-cloud and multi-vendor sprawl. To transition from disconnected islands of autonomy to scalable production, enterprises must decouple agent orchestration from underlying foundation models and enforce centralized, continuous governance.
The Proliferation and Architectural Risks of Agent Sprawl (0:04)
Modern enterprise software is shifting from static artificial intelligence models to autonomous systems of interaction and action, making agentic interfaces the standard enterprise UI. Forecasts cited in the program project agent deployments to exceed 1 billion within the next 12 to 18 months and surpass 2.2 billion by 2030. Many organizations adopt agents inadvertently, as standard enterprise software packages increasingly arrive with bundled agentic features. This uncoordinated rollout generates multi-cloud fragmentation across platforms such as AWS Bedrock, Microsoft Copilot, Google Cloud Platform, and Salesforce Agentforce, resulting in isolated systems that lack central operational oversight.
Core Pillars of the Agentic Control Plane (2:19)
Countering agent sprawl requires a centralized control plane capable of cross-platform orchestration across multi-cloud and hybrid environments. This control architecture goes beyond isolated code repositories to monitor tools, enterprise knowledge bases, operational skills, and dynamic instructions produced by tools like Claude Code. Orchestration focuses on end-to-end task completion rather than raw execution alone. To maintain operational control, the plane must systematically answer four core questions: what tasks the agents perform through proactive guardrails, who holds access and execution rights, how agents perform across build-time evaluation and runtime telemetry, and the computational and token costs they incur.
Decoupled Runtime, Cost Arbitrage, and Open Integration (4:23)
IBM's control platform, watsonx Orchestrate, addresses these requirements by separating reasoning, planning, memory management, and execution from individual agent implementations. This decoupled architecture allows organizations to run workflows across proprietary IBM agents and third-party tools from Microsoft, AWS, GCP, SAP Joule, and Salesforce Agentforce. Standardized gateways support Model Context Protocol (MCP) connections, inter-agent communication, and intelligent routing. Sunil Murthy highlights the necessity of cost arbitrage, comparing model selection to vehicle choice: organizations avoid consuming costly frontier model tokens on basic tasks like drafting emails, reserving them strictly for complex reasoning. The ecosystem currently supports over 100 partners, targeting 500 certified partners.
End-to-End Governance and Controlled Autonomy (10:27)
Governance must function as an integrated lifecycle framework rather than an afterthought, particularly to comply with regulations such as the EU AI Act, GDPR, and Federal Reserve SR 11-7 guidelines. IBM integrates risk management into the asset catalog via the open-source IBM AI Risk Atlas, which benchmarks accuracy, synthetic test outputs, and vulnerability profiles. Working alongside runtime systems, watsonx.governance translates broad policies—such as restrictions against processing personally identifiable information—into enforced guardrails within watsonx Orchestrate. Runtime telemetry feeds auditable evidence back to a central compliance console.
Demonstrated Policy Inheritance in Retail Banking (14:12)
A retail banking workflow demonstrates how governance policies operate in practice. Administrators establish baseline guardrails that protect against prompt injection, jailbreaking, harmful content, and social bias. Using parent-child inheritance structures, newly onboarded agents automatically inherit these controls from the overarching business use case without manual intervention. In pre-deployment unit testing with synthetic data, an unauthorized agent attempting to submit personal data is blocked until an administrator elevates its permissions. As Murthy emphasizes, moving from experimentation to production scale requires intentionally transitioning from observed agents to controlled autonomy.
Scaling enterprise AI requires vendor-agnostic orchestration paired with proactive governance by design. Rather than accepting vendor lock-in, enterprises must maintain visibility across disparate tools and clouds to enforce accountability as agents assume greater operational autonomy.
[0:04] Sunil Murthy: the biggest challenge is not creating agents - it is how to scale agentic AI without losing visibility, control and accountability.
[0:04] Sunil Murthy: Traditional GRC governance and agent runtime operations often work in separate worlds, making it hard to connect policies, controls, evidence, and oversight.
[0:04] Sunil Murthy: islands of autonomy
[2:19] What do the agents do?
[2:19] Who has access?
[2:19] How are the agents performing?
[2:19] How much are the agents costing?
[4:23] Sunil Murthy: You don't need to drive a Ferrari for doing every single task. If I'm going to the grocery store... I'm not going to drive a Ferrari.
[14:12] Sunil Murthy: You go from experimentation to... observed agents to controlled autonomy.
[14:12] Sunil Murthy: You can't drive accountability if you don't have visibility.
Original transcript
[0:04] Well, thank you for taking your valuable
time to listen to this important topic.
[0:08] Um, I'm guessing most of you are already working
through agents. So, agents sprawl is something
[0:15] that as IBM we see in our enterprise customers.
And this talk is specifically focused on
[0:22] how do you get better control of these agents
and and establish a governance framework. So,
[0:28] with that, um, I'm one of the AI field CTOs at
IBM. I work with several customers. What we are
[0:35] seeing is really the emergence of systems of
interaction, systems of action from based on
[0:43] agentic AI and agents in general, right? If you
think about software development, the componentry
[0:49] that builds up the software is predominantly now
shifting towards agent. There are some statistics
[0:56] that suggest more than a billion agents in the
next 1 year, 1 and 1/2 years. You know, crossing
[1:04] to 2.2 billion according to another statistic
by 2030. So, you have agents that are growing
[1:11] tremendously. Now, you may ask, "Well, I'm not
building any agents. Are you using any software?"
[1:16] Well, guess what? The softwares are bundling
agents for you. So, the reality is the systems
[1:22] of interaction where the AI becomes the new UI is
happening as part of the transformation with AI.
[1:30] Now, as part of this agents sprawl from a software
perspective, you are going to see agents that are
[1:36] being built on let's say AWS bedrock platform
or Microsoft co-pilot platform, you GCP,
[1:45] Salesforce agent verse, you name it, right? The
reality is there is no single control layer,
[1:53] and I'll get to the definition of this control
layer in a minute, but there's no really, you
[1:58] know, an agentic visibility layer for across the
platform. So, there's not a single visible layer,
[2:06] there's not a single registry, there's not a
single really control layer for these agents. So,
[2:12] you'll have islands of autonomy that you really
would lose control from an overall enterprise.
[2:19] So, what we are suggesting is is really quite the
contrary. The contrary is a registry that you can
[2:26] actually govern, a registry that tracks all your
AI assets, not just agents, but what do agents
[2:33] need? Agents need access to tools, integration,
agent needs access to knowledge bases,
[2:40] agents need access to skills. There's a lot of
markdown files that are getting generated perhaps
[2:46] by Claude Code and other software development
agentic tool sets. You need to get control of
[2:52] those as part of your CI/CD processes. So, one
registry to really provide that visibility,
[2:59] observability, which really how the agents are
operating at an enterprise level, that's another,
[3:06] you know, critical aspect of this control plane,
and then really this cross-platform orchestration.
[3:13] You will have agents across the platforms,
be it both hybrid as well as cloud. How do
[3:19] you orchestrate so that the task completion is a
central focus rather than agentic execution. So,
[3:27] you need almost like a layer to orchestrate these
agents. So, if you think about a definition of
[3:33] a control plane, it really does four things. The
for the agents, right? What do the agents do? So,
[3:40] think about policies and guardrails. What do
these agents do? So, what? Who has access to these
[3:47] agents? Who can execute these agents? So, the who
question, that the security and access question.
[3:54] How are the agents performing? That's more of an
observability question that you need answers to.
[3:59] And top-of-the-mind for a lot of you and a lot of
our customers, how much are the agents costing?
[4:05] Right? Because ultimately, it's about time to
value and the value delivered is tracking by cost
[4:12] and the outcomes that the agents deliver. So, four
things that you need as part of an agentic control
[4:17] plane. And what do we do from an IBM perspective
is to really deliver a robust enterprise-focused
[4:23] control plane for your agent orchestration
and your agent execution. So, we call this the
[4:31] you know, agentic control plane called Watsonx
Orchestrate. It has three major components in
[4:37] terms of providing an operating system to execute
your agents. Again, agents could be from IBM,
[4:44] agents could be from Microsoft, Copilot or
AWS Bedrock, GCP, Salesforce, doesn't matter.
[4:52] The idea is you have memory management, the
reasoning and planning and execution layer,
[5:00] which is abstracted or, you know, kind kind of
decoupled from your agents that are executing. So,
[5:06] you get the operating system for for agents
where you run your agents. You have the control
[5:12] plane. We are talking about observability, but
also evaluation because we are dealing with
[5:18] the evaluation-first approach where the agents are
getting evaluated before they get deployed. So,
[5:24] you need observability and evaluation and
optimization for these agents while you're
[5:29] developing as well as you are uh deploying.
So, observability, evaluation, optimization,
[5:36] build time and run time important to uh execute
as part of the control plane. And really,
[5:43] the the third element is this notion of governed
catalog. So, you have a governed set of AI assets,
[5:50] everything surrounding your agents. So, IBM
agents, partner agents. We work with 100 plus
[5:56] partners as part of our partner ecosystem
for agentic systems continuing to grow.
[6:02] Our target is to get to 500. So, if you are
a partner in the room, want to work with IBM,
[6:07] you're welcome to stop by our booth, which
is booth number 601 to talk more about that.
[6:13] Um and and this notion of gateway. So,
when you think about how do you, you know,
[6:19] arbitrage cost between different models? You
need a gateway, right? You need agents that can,
[6:26] you know, you don't The analogy that I always use
and most of the folks I've heard of perhaps is
[6:31] you don't need to drive a Ferrari for doing every
single task. If I'm going to the grocery store, I
[6:37] don't I'm not going to drive a Ferrari, right? So,
if you have one car, which is a Ferrari, in this
[6:43] case one model, which is your token cost, do you
really want to use it just for email composition?
[6:50] Or do you want to restrict that to a complex
task management? So, how do you arbitrage between
[6:56] multiple models? You need a gateway. So, you need
when you have an agent that can abstract out tasks
[7:02] and can handle multiple models in the back end
so that you can, you know, cost manage it better.
[7:08] And you can also have agent-to-agent protocol
through a gateway as well as an MCP pro
[7:14] gateway if to manage your MCP connections,
model context protocol for integration,
[7:19] you basically need a standardized gateway. That's
what you get as part of the IBM's control plane
[7:26] for agents, which is Watson X Orchestrate.
And we we got, you know, quite a bit of demos,
[7:32] again, out there in our booth that you can stop by
if you have time. I mentioned partners. Our idea
[7:40] of having an agentic control plane for enterprise
is you're not going to be total IBM customer.
[7:46] You know, in fact, I would contend because we're
not a major frontier model provider, we're not
[7:52] a major cloud provider, but we knew do know a
little a thing or two about enterprise systems.
[7:58] So, we have the responsibility to provide you an
enterprise agentic platform that works with what
[8:06] you have invested from different enterprises, be
it cloud vendors, hyperscalers, or be it platforms
[8:13] like Agent Force from Salesforce or SAP Joule
and others. So, the idea is you can orchestrate
[8:19] agents, be it agents from wherever it comes from,
which whichever platform. The idea is to grow this
[8:27] outreach. And the again, the vision,
the idea is to have one central place
[8:32] so that you can have a governed catalog of all
things assets related to agents. It's about agents
[8:40] in terms in terms of catalog, in terms of MCP
servers, in terms of skills that goes alongside
[8:46] with agents, and the controls, which really are
policies and guardrails for these agents. So,
[8:54] we provide a catalog that's publicly accessible
for all our agents that's managed by IBM,
[9:00] but you can take that same concept and make it
your own tenant, your own private governed catalog
[9:06] for all your agents behind your firewall.
That's another advantage of an IBM system.
[9:11] It works perfectly well in a hybrid multi-cloud
system. You're not wedded to one cloud in this
[9:18] approach. So, this is how it looks in terms of
your UI. You get meaningful information of every
[9:24] single agent. You get meaningful information
about metrics in terms of how they perform,
[9:30] maybe historical performance based on, you
know, be it real data or even, you know,
[9:36] synthetic data. you get, you know, this notion of
AI Atlas risk score. IBM is big on AI governance.
[9:45] We assess risk based on what is called as a AI
Atlas catalog. We catalog a bunch of risks for
[9:52] AI. We've been doing that for since ML, now GenAI
and agentic AI. You can go Google that or Claude
[9:59] that or open AI. What's the word nowadays? Open
AI dirt. So, you can you can ask that in terms of,
[10:05] you know, what's the IBM AI risk catalog? And
you'll get a response which is a very publicly
[10:11] very usable asset for you, which is documented
IBM experience of assessing risk across multiple
[10:18] assets in AI. And you have that risk assessment
out of the box for the AI assets in our catalog.
[10:27] Speaking of governance, it's not enough to just
talk about agentic control plane. What about the
[10:33] governance piece to complement the observability
piece? So, when we talk about agent control plane,
[10:41] what's missing is is really the upfront AI
governance piece. So, how do you comply to various
[10:47] risk approaches, compliance approaches? There
are a lot of standards, especially if you are
[10:53] European Union, you know, aligned. There's a EU AI
Act. There's also, you know, GDPR. There's also,
[11:00] you know, various acts like the SR 11-7, which is
now 26-2, which is a, you know, Federal Reserve
[11:08] standard. So, when you think about risk and
compliance standards that you need to comply to,
[11:14] you need to have a system that can provide the
compliance metrics. You need to have a system
[11:18] that provides out of the box risk. You need to
have AI use case onboarding that uses AI agents,
[11:26] AI models, different AI assets. So, use case
onboarding, governance for us is a very proactive
[11:33] approach for AI. It's not an afterthought. It's
It's a proactive approach. So, how does this
[11:40] look like? So, complementing our Agentic Control
Plane, you have AI governance um solution,
[11:47] which is Watson x governance. It provides you the
ability to have the ownership of AI in terms of
[11:55] the accountability. It provides you visibility of
AI in terms of where the AI assets are executing.
[12:02] It also provides you mechanisms to define your
controls. A control could be an enterprise
[12:07] control, for example, no AI should use PII. That
could be a control. But, you need to have evidence
[12:14] surfaced from run times. Could be security end
points. Could be run the various run times,
[12:20] including Agentic operating systems like Watson
x Orchestrate, to be surfaced and integrated with
[12:26] the governance plane. Apologies for the small
font. But, the idea here is you go through your
[12:33] traverse through end to end, from cradle to all
the way to retirement of an agent or any AI asset.
[12:40] So, if you think about somebody requesting an AI
use case, you have definition of AI use case. You
[12:47] go through a questionnaire that assesses the risk.
It assess It provides a proactive risk score,
[12:53] where you can define is this a straight-through
approved process, approved use case,
[12:58] or you need a human intervention for approving the
use case. Um it goes through a bunch of, you know,
[13:04] additional controls in terms of the policy and
the risk tiers, where you define the thresholds.
[13:11] And then, as I mentioned, that you define the
controls, but you execute this in a control plane,
[13:17] in a operating system for agents. In
this example, it's Watson x Orchestrate.
[13:22] It's where you operationalize and enforce your AI
assets. You monitor, you report on the telemetry
[13:30] as well as observability metrics back into
the control plane. That evidence is now fed
[13:38] back to the AI governance control plane. The AI
governance plane, if you will, is the overarching
[13:45] AI governance solution providing you a single
console of all your AI assets based on risk,
[13:52] based on compliance, based on departments that
are consuming the AI assets and all of these other
[14:00] you know relevant information. So, you got
an end-to-end closed loop, if you will,
[14:05] agentic governance solution both from execution
as well as governance. So, how does this look?
[14:12] This is a demo that hopefully will
play here that you can take a look.
[14:18] A quick demo. Again, we have much more details
on the booth here. So, what you're seeing here is
[14:25] a bunch of use cases for a retail banking customer
support use case. And you can see some controls
[14:31] defined here. You can see the connections
where the agents are deployed. In this case,
[14:37] we're showing you agents deployed on Watson
x Orchestrate. Again, as I mentioned,
[14:42] we have agents that we can work with deployed
on AWS, Microsoft, and other platforms.
[14:48] Once you have this, this is again pre-deployment.
It's not yet in production, right? You have the
[14:54] screen showing you Watson x Orchestrate to
actually build out your agent. You know,
[14:59] agents need tools, agents need knowledge, agents
need behavior. So, you define all these guardrails
[15:06] and you know, remember what can the agent
do, who can access it, how does it perform,
[15:11] all of those elements. You define those and this
is an example of defining guardrail or control
[15:18] for an agent. So, in this case, we want to make
sure both the input and output are enforced.
[15:24] You're tracking harmful content, jailbreak,
social biases, as well as any other hate,
[15:30] abuse, profanity language. So, you want to track
those and monitor as part of the guardrail.
[15:35] And then you're adding an agent that inherits So,
there's a parent-child relationship, inheritance
[15:42] of these guardrails. So, any agent that you
build for this use case inherits these controls,
[15:49] and then you can actually, you know, look at
these individual agents where you can import
[15:54] these agents here. And again, it goes through
that connection that we already established.
[15:59] Bring that agent over. In this case, it's a retail
banking agent and attach it to the use case.
[16:05] So, the idea being you have definition of a use
case. You build your agent wherever you want to,
[16:12] IBM or non-IBM. Bring that back as evidence into
the governance console. Now, you get a view of the
[16:21] that you see, if I can go back here. You get
a You get a view of the metrics of the agent
[16:26] that you that's being executed. So, um let me run
this for a couple more minutes here. So, this is
[16:34] pre-production. You're testing with synthetic
data. You're basically unit testing it.
[16:40] And you know, you want the agent to behave the
way you want to define you want it to define.
[16:45] So, if an agent is not you've not given the
authority for an agent to submit the application,
[16:51] which includes personal information, then you
want to test it out. So, in this case, the agent
[16:56] basically did not let the applicant submit the
application because it will involve personal
[17:02] information. But then you can go back in there
and you can say the control at an agent level,
[17:07] I want to give the autonomy control to read and
update the information autonomously. So, the
[17:15] It's called controlled autonomy, right? For
agents, where you go from experimentation to,
[17:21] you know, observed agents to controlled
autonomy. So, you get all these different levers
[17:27] for enabling the governed state for agents. So,
the idea again is you get important controls,
[17:34] important metrics for you to make decisions, and
you get this production metrics that, you know,
[17:41] you continue to monitor as you deploy the agent.
And you can always go back and make edits and
[17:47] changes if your risk posture has changed or if you
want to, you know, do any other modifications. So,
[17:54] that's the idea. The idea is you have a a very
governed state, and as you scale these agents,
[18:00] you get everything that's visible. Once you
have visibility, you can drive accountability,
[18:06] right? That's the idea. You can't drive
accountability if you don't have visibility.
[18:12] So, that's what we are attempting
to do in the solution. So, with the
[18:18] time I have left here, I just want to, you know,
bring this to a wrap. We spoke about agent runtime
[18:25] in terms of orchestration from IBM. We need to
complement that with the AI governance with,
[18:32] you know, Watson X governance that gives you
that governed state for all your agents and,
[18:38] more importantly, all the AI assets, not just
AI agents as in just the agent code, but the MCP
[18:46] servers, the skills that you need, as well as, you
know, anything else that's goes alongside with the
[18:53] agents. So, evidence by design, that's the runtime
controls that I showed, as well as this notion of
[18:59] cross-functional operating model. So, you don't
be restricted to one single vendor. You have the
[19:07] you know, kind of the flexibility to work across
the agents across multiple vendors. And this is
[19:13] truth right I mean in IBM we use our sales agents
talk to salesforce as well as our internal systems
[19:20] as well as a third-party system so it's a
reality and I'm I'm pretty sure most of your
[19:25] environments as well so why IBM we were rated
fairly I highly by Gartner not by chance but by
[19:34] interviews of you know multiple customers lots
of our customers vouch for the solution to
[19:41] be enterprise ready and and really help you as
part of this evolving agentic world and and the
[19:48] continuing governance work we may have
time for maybe one or two questions
[19:55] we can do one question and then they could ask
you oh we got to stage because I have a question
[19:59] anybody has any pressing questions before I
wrap you can always catch us at booth number 601
[20:08] which where we are all out there showcasing
the solution and answer any questions again
[20:15] appreciate your time thank you for joining our
session hopefully we'll see you back at the booth