DEV Community

Cover image for When the Enterprise Opens Up to Agents, Who Coordinates Them?
Kavin Kim
Kavin Kim

Posted on • Originally published at Medium

When the Enterprise Opens Up to Agents, Who Coordinates Them?

#ai #agents #salesforce #enterprise

Salesforce just opened 27 years of enterprise CRM to any AI agent. Headless 360 launched at TDX with over 60 MCP tools and 30 coding skills. Any agent built with Claude Code, OpenAI Agents SDK, or Cursor can now read, update, and trigger workflows inside Salesforce directly. SAP did the same. ServiceNow followed. Nvidia brought 17 enterprise partners onto Agent Toolkit. The message from every major platform in Q1 2026 is identical: the enterprise is now agent-accessible.

This is a genuine inflection point. But it created a problem nobody is talking about.

The agents can read the data. They can trigger workflows. They cannot coordinate with each other in real time.

One Enterprise, Many Agents, Zero Shared Channel

Here is what a real enterprise workflow looks like in 2026:

  • A Claude-based sales agent updates deal status in Salesforce
  • An OpenAI-based inventory agent needs to check availability
  • A Gemini-based finance agent needs to generate a quote
  • A Claude Code-based fulfillment agent schedules delivery

These agents all have access to the enterprise platforms. But how does the sales agent tell the inventory agent that a deal just moved to negotiation? How does the finance agent know to generate a quote right now, not in 15 minutes when the orchestrator checks in?

The answer, in most architectures today: it does not. The orchestrator polls. Agents wait. Workflows stall.

The Polling Problem

Traditional multi-agent setups handle this through a central orchestrator. Agent A finishes, writes to shared state, and the orchestrator eventually notices and triggers Agent B. This works when workflows are predictable and latency is acceptable. Enterprise-grade agent workflows are neither.

A deal moving from prospecting to negotiation triggers an immediate cascade: inventory checks, legal review alerts, pricing updates, competitor analysis. Each needs to happen now, not on the next polling cycle. The orchestrator architecture was designed for sequential tasks. Real enterprise workflows are event-driven.

What Real-Time Agent Coordination Looks Like

The model is simple. When something meaningful happens, the detecting agent publishes an event. Every agent that cares about it receives the event immediately and acts. With rosud-call, this is a two-line integration:

import { RosudClient } from 'rosud-call';

const client = new RosudClient({ agentId: 'crm-agent-001' });

// Publish when a deal stage changes
await client.publish('deal.stage.changed', {
  dealId: 'D-4892',
  from: 'prospecting',
  to: 'negotiation',
  timestamp: Date.now()
});
Enter fullscreen mode Exit fullscreen mode

The inventory agent does not need to know about the CRM agent. It subscribes to the event channel and reacts:

// Inventory agent: react immediately to deal progress
client.subscribe('deal.stage.changed', async (event) => {
  const { dealId, to } = event.payload;

  if (to === 'negotiation') {
    const availability = await checkInventory(dealId);

    await client.publish('inventory.checked', {
      dealId,
      available: availability.units > 0,
      leadTimeDays: availability.leadTime
    });
  }
});
Enter fullscreen mode Exit fullscreen mode

The finance agent subscribes to 'inventory.checked'. The fulfillment agent subscribes to 'quote.approved'. No orchestrator polling required for any of these handoffs.

Why This Matters for Enterprise Adoption

When Salesforce launched Headless 360, it described the product as making the entire platform accessible to external agents. That description is accurate. But accessible does not mean coordinated.

In practice, most enterprise agent deployments fail not because agents cannot access data, but because they cannot coordinate their actions.

This creates three problems that kill enterprise rollouts:

  • Race conditions: two agents act on the same record without knowing about each other
  • Stale context: Agent B acts on 10-minute-old information because the orchestrator has not checked in
  • Invisible failures: Agent A finishes its task but nobody knows, so Agent B keeps waiting

Real-time event channels eliminate all three.

npm install rosud-call

The enterprise platforms have done the hard work of opening up their APIs. The agent coordination layer is the remaining gap.

rosud-call connects any two agents with a single npm install. No broker to manage, no polling loops, no shared state database. Any agent that can run JavaScript can publish or subscribe to events. Platform does not matter. Model does not matter.

As Salesforce Headless 360 deploys across enterprise customers, the question is not whether agents will work in the enterprise. The question is how they will work together.

That is the problem rosud-call was built to solve.

https://www.rosud.com/rosud-call

Top comments (0)