Jayashree Arunkumar is a Distinguished Member of Technical Staff, driving enterprise-scale AI adoption as part of the Technology Advisory.
getty
IDC’s Agent Adoption Report reinforces what I’m hearing in enterprise conversations. Interoperability and intrinsic security are two make-or-break requirements for building a scalable agentic foundation. What’s changing is that we’re moving from a few pilots to an enterprise ecosystem of agents, tools and models that have to operate reliably across teams, regions and risk boundaries.
Three of the most common concerns I hear from enterprises are as follows:
1. Agents are being built, but they’re not discoverable across the enterprise.
2. Interoperability is inconsistent across multi-agent systems—models, prompts and tools don’t plug together.
3. Chain of trust isn’t mandated end-to-end, so identity, policy and auditability break down as soon as agents start calling tools and other agents.
When these three show up together, I see the same outcome: duplicated agents, fragmented user experiences and an ecosystem that’s harder to govern and operate.
In this article, I'll summarize the approach I believe is essential for scaling a multi-agentic foundation in the enterprise.
When I talk about a scalable foundation, I start with a collaborative framework where intelligent collaborators (human users, internal apps and agents) interact seamlessly with a fleet of specialized agents (intelligent/augmented or ambient).
The heart of an agent’s operation is a highly efficient intelligence loop:
• Request And Intent: Intelligent collaborators interact with the system via agents or applications, and intent is established.
• Intelligence And Tool Routing: An LLM-powered interface or orchestrator processes the intent. Rather than just returning text, it intelligently routes the request, determining the appropriate tools and systems needed.
• Intelligent Enablers (Model/Tool/Agent) Execution: When an agent needs to invoke a model, tool or another agent, interoperability must be treated as a first-class requirement.
To operationalize interoperability as a first-class requirement, it must be consistently applied across models, prompts, tools and agents—ensuring each layer can evolve independently without breaking the system as a whole.
For model interoperability, consider a model registry that treats models hosted in Vertex, Azure Foundry, AWS Bedrock, API-first models (OpenAI, Anthropic) and OSS models (Llama, Mistral) as equal citizens. Rather than hard-coding model versions, aliases can be mapped to specific models and versions through configuration. This helps provide cost control and flexibility: Model swaps can be executed instantly without requiring application refactoring.
For prompt interoperability, a multi-model prompt engineering approach—supported by tools like Jinja2 or Langfuse—enables greater agility. Instructions can be updated dynamically without the need to redeploy code.
Tool interoperability via MCP allows secure calls to relevant external systems through the Model Context Protocol, while maintaining vendor agnosticism. The business value here is scalability: A single connector pattern continues to function as models evolve.
Agent interoperability via A2A enables access to remote agents through an Agent2Agent protocol, improving system scalability. This improves reliability: Standardized communication between agents reduces fragile, point-to-point integrations.
For response and iteration, systems return data and contextual signals that an orchestrator synthesizes into a final response, effectively closing the loop for the end user.
Enterprise AI demands more than intelligence; it demands rigorous data sovereignty and regional compliance. This requires processing the data locally within specific regions to meet strict regulatory and compliance requirements (e.g., GDPR in Europe) and aggregating data where permissible to provide a global view while respecting regional boundaries.
This approach directly addresses the critical business need for global compliance, ensuring that as the enterprise scales its AI footprint, it adheres to local laws and regulations without turning every rollout into a reinvention.
In a multi-agent system, a comprehensive “trust by design” security framework must be implemented at multiple levels.
The first of these levels is architecture security. The architectural design goal is to minimize the potential “blast radius” if any single agent is compromised. This can be achieved through two key elements.
1. Distinct Agent Identities: Every agent is provisioned with its own distinct service account identity. Cross-agent access is explicitly blocked and managed through access controls. This ensures an issue with one agent doesn’t automatically compromise others.
2. Explicit Deny/Allow: Granular policies define what each agent can access (e.g., specific telemetry versus calendar access), adhering to the principle of least privilege.
Securing how agents interact with shared services is paramount. This can be addressed through:
1. Securely Deployed Shared Services: Essential services, like inventory servers, are deployed securely (via containers in a cloud environment) to ensure isolation and resilience.
2. Service Account And Access Control: Service accounts for agents are distinctly configured, with only authorized identities permitted to invoke specific shared services or servers, preventing unauthenticated access and reducing risk.
To ensure agents act reliably and within bounds, guardrails and comprehensive observability need to be deployed.
1. Intelligent Guardrails: Beyond baseline LLM capabilities, implement a decoupled AI safety and policy enforcement layer, such as Model Armor, for security and responsible AI. This approach keeps policy separate from application logic, enabling updates without requiring redeployments.
This layer performs both pre- and post-processing checks on model and tool interactions, filtering for risks such as safety and security (PII exposure, prompt injection, jailbreaking and intellectual property leakage) and responsible AI (hate speech, harassment and other forms of harmful or unsafe content).
2. Comprehensive Observability And Interoperability: Audits and explanations are paramount for enterprise operations. Through standardized tracing and open observability tools, every agent interaction is traceable.
This multilayered approach—starting from identity and access design through infrastructure hardening and into runtime guardrails and standardized observability—helps ensure the multi-agentic architecture is not only intelligent, but fundamentally secure, reliable and trustworthy.
If I were advising a CIO/CTO or vice president of engineering on where to start, I’d focus on three concrete moves that make the rest of the architecture easier to scale:
1. Stand up an enterprise agent registry and discovery model.
2. Standardize interoperability contracts early.
3. Mandate chain-of-trust controls end-to-end.
My intent is to make multi-agent systems feel less like an experiment and more like a repeatable enterprise capability where scale doesn’t come at the cost of security, governance or reliability.
Forbes Technology Council is an invitation-only community for world-class CIOs, CTOs and technology executives. Do I qualify?
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。