Google Workspace Studio lets Gemini agents connect directly to Gmail, Drive, Asana, and Salesforce without writing a single line of code. Microsoft is doing the same. OpenAI too.
Every major AI platform is solving the same problem: connecting agents to tools. And they are all getting very good at it.
But there is a different problem that none of them have solved: connecting agents to each other.
What agents can do today vs. what they cannot
A modern AI agent can browse the web, write and execute code, summarize documents, send emails, and trigger Salesforce workflows. The tool-calling surface has never been richer.
What the same agent cannot do is this: while it is running a task, notify a second agent in real time. Ask it for a result. Wait for a response. Continue.
You can simulate this with shared databases, polling loops, or message queues you build yourself. But that is infrastructure overhead on top of every multi-agent system you try to ship.
The multi-agent coordination problem
As agent platforms mature, the natural next step is orchestration: a lead agent breaking a complex task into subtasks, dispatching to specialist agents, and aggregating results.
This pattern is already appearing in production systems. Research agent delegates to a code agent. Procurement agent delegates to a pricing agent. Customer agent escalates to a compliance agent.
Each delegation is a message. Each result is a reply. The channel those messages travel on needs to be reliable, fast, and simple to plug in.
That is what rosud-call is built for.
What rosud-call actually does
rosud-call is an npm SDK that gives your agents a real-time messaging channel with one line of setup:
npm install rosud-call
Under the hood it runs a WebSocket daemon with automatic reconnection and polling fallback. Your agent sends a message to another agent by ID. The receiving agent gets it in milliseconds. No infrastructure to configure, no broker to deploy.
import { RosudCall } from 'rosud-call';
const agent = new RosudCall({ agentId: 'pricing-agent', token: process.env.ROSUD_TOKEN });
await agent.listen((message) => {
console.log('Received from', message.from, ':', message.payload);
return { price: calculatePrice(message.payload.sku) };
});
The lead agent on the other side sends and awaits:
const response = await agent.send({
to: 'pricing-agent',
payload: { sku: 'PRO_ANNUAL' }
});
console.log('Price confirmed:', response.price);
That is the full integration. Two agents, coordinating in real time, with no shared state and no polling loop you wrote yourself.
Why this matters for multi-agent systems
When Google Workspace Studio builds an agent that touches Gmail and Salesforce, the next question is: what happens when that agent needs to coordinate with a compliance agent before taking action?
The answer is a channel. Not a database entry. Not a webhook you configure once. A channel that exists as long as both agents are running and disappears when they are done.
rosud-call handles the connection lifecycle, the reconnection on dropped sockets, and the fallback to polling when WebSocket is unavailable. You write the agent logic. The messaging just works.
The bigger picture
The agent ecosystem is splitting into two layers: building agents (Google, Microsoft, OpenAI) and connecting agents (still mostly custom work).
rosud-call sits in the second layer. The goal is simple: any agent, in any framework, should be able to send a message to any other agent with one function call.
You can find the SDK and docs at rosud.com.
If you are building multi-agent workflows and stitching together your own coordination layer, try npm install rosud-call. The first 10,000 messages per month are free.
Top comments (0)