Principles for safely scaling autonomous work

• Enterprises are rapidly embedding AI agents across core business platforms such as Salesforce, ServiceNow, Coupa, Anaplan, and Ironclad.  
• While these agents can reason within individual systems, organizations struggle to unlock value across systems. They’re focused on building “cool agents” rather than creating outcomes engines.
• The problem is due to fragmented execution, lack of governance, and disconnected automation.
• Here's a quick primer on Agent2Agent (A2A) protocol.

The proliferation of application-specific AI agents presents a paradigm shift in how work is executed. However, without a governed integration layer connecting these capabilities, the resulting fragmented architecture introduces substantial enterprise risk.

For example, an enterprise might be using Salesforce for customer interaction and ServiceNow for IT service management. Without a governed integration layer, a Salesforce chat agent attempting to resolve a customer issue might require direct, ungoverned API access to create a ticket or check system status in ServiceNow. This creates brittle, peer-to-peer connections that fracture easily and bypass security protocols.

When autonomy scales without properly structured communication channels, organizations typically experience:

• Loss of auditability and trust: Autonomous agents executing actions without proper security gates or traceability are problematic.
• Escalating compliance risk: Operational and compliance risks expand as unrestrained autonomous systems attempt to scale without guardrails.
• Poor scalability: Many business systems and their exposed data access methods were not built with artificial intelligence in mind.
• Insufficient access controls: Agents can unintentionally expose sensitive or unnecessary data if identity, role-based access, least-privilege permissions, and data-scoping rules are not enforced consistently across systems. Organizations need controls that ensure users and agents only see the data required for the task, with auditability over what was accessed, why, and by whom.
• Siloed automation: While core enterprise processes like Procure-to-pay, Order-to-cash or Issue-to-resolution spans multiple systems, SaaS vendors typically build AI agents as walled gardens. Without an A2A integration layer, the initiating agent is forced to manage heavy operational context across unfamiliar domains, such as translating CRM data into ITSM requirements. This massive cross-system burden makes execution significantly more complex, brittle, and difficult to scale safely.
• Fragmented logic: Core business logic becomes dangerously scattered across prompts, application programming interfaces (APIs), and ad hoc scripts rather than centralized in a robust integration layer.

To resolve the limitations of fragmented AI tools, organizations must adopt a new delegation model for managing agentic workflows. In a traditional business unit, human workers operate efficiently because roles are clearly defined, and responsibilities are thoughtfully delegated. AI agents require the exact same structure.

Rather than developing general purpose agents tasked with a wide array of responsibilities, enterprises should build specialized, role-aligned agents.  

Role-aligned agents:

• Have a narrower, focused operational context window
• Possess clearly enumerated and thoroughly described skills
• Achieve more consistent, efficient outcomes by specializing in a specific domain

When agents are role-aligned, A2A interactions can be safely governed by established communication channels. Each agent is aware of the specific capabilities of its peers in the ecosystem.

Integration-led A2A architectures allow autonomous systems to collaborate securely. To build an ecosystem where agents determine what should happen—while integrations securely control how it happens—organizations must adopt four key approaches:

1. Design for separation of concerns: Maintain a strict boundary between AI cognition (planning) and systematic execution. Agents focus on reasoning, planning, and coordination; integrations handle execution, policy enforcement, retries, and recovery.
2. Implement a planner → router → executor pattern: Policy-driven routing prevents unpredictable, “freestyle AI.” Deterministic execution ensures every action is repeatable, auditable, and traceable.
3. Event-driven, integration-first orchestration: Use iPaaS as the coordination fabric between agents. Use SaaS platforms to manage long-running, cross-system workflows durably.
4. Deploy incremental autonomy with guardrails: Scale autonomy at the pace your business can trust. Begin with human-in-the-loop workflows, transition to supervised autonomy, and then achieve full automation you can trust.

As organizations embed AI deeper into their operational workflows, the challenge has shifted:

• It’s no longer Can the AI understand the request?

• Now it’s Can the AI execute the request safely across the enterprise?

Slalom helps clients evolve from static automation to dynamic, agent-driven ecosystems. By applying proven enterprise integration disciplines to agentic systems, organizations can achieve incremental, scalable autonomy without sacrificing trust, operational stability, or compliance.  

We recommend these steps:

1. A2A readiness assessment: Assess candidate workflows, existing agents, integration platforms, data readiness, identity model, and risk posture.
2. Reference architecture and pattern design: Define the A2A control plane, planner/router/executor pattern, MCP/tool boundaries, agent-card standards, and integration-led execution model.
3. Pilot delivery: Build an initial end-to-end workflow with human-in-the-loop approvals, traceability, exception handling, and measurable success criteria.
4. Governance and operating model: Create the governance model with decision rights, controls, runbooks, monitoring, and change-management approach needed to expand safely.
5. Scale roadmap: Prioritize the next workflows and reusable accelerators so the client can expand A2A adoption without creating disconnected automation islands.

Remember: Enterprise AI initiatives fail because execution across systems isn’t controlled. Always prove measurable value through a bounded pilot before scaling the pattern enterprise-wide. Agent-to-Agent (A2A) integration, supported by enterprise integration platforms, provides the trust layer required to safely scale agentic AI with autonomy.