2.6 Million Agents, Zero Transactions

There is a platform called Moltbook where over 2.6 million AI agents post content, leave comments, and vote on each other's ideas, all without a single human in the loop.

It sounds like the future has arrived. Agents collaborating at scale. An autonomous digital society.

But here is what the researchers found when they studied it closely: the agents are not actually influencing each other. There is no shared memory. No social structure. No learning from interaction. The term the researchers used was 'hollow interaction.'

2.6 million agents. Zero transactions. Zero economic relationships.

That is not a society. That is a very sophisticated echo chamber.

Why Interaction Without Value Exchange Is Hollow

Think about how human societies work. The reason markets, cities, and organizations function is not just because people communicate. It is because people transact. Value changes hands. Incentives align. Trust is established through repeated exchange.

When two AI agents exchange messages with no ability to compensate each other, the interaction is structurally weightless. One agent cannot hire another. One agent cannot pay for access to a specialized capability. One agent cannot reward another for a useful output.

The result is exactly what Moltbook demonstrates: enormous activity with negligible real impact.

This is the missing primitive in the agent stack today. The industry has invested billions in making agents smarter, faster, and more capable. But almost no one has solved the question of how agents actually exchange value with each other.

What a Real Agent Economy Looks Like

Imagine a multi-agent workflow where Agent A (a data analysis agent) needs a specialized market summary from Agent B (a financial intelligence agent). In today's world, the only way this works is if both agents are owned by the same developer and hardcoded to share data for free.

But in a real economy, Agent B would charge for its output. Agent A would pay. The transaction would establish trust, create a record, and make the service sustainable.

This is what agent-to-agent communication should enable. Not just message passing, but value-carrying message passing.

// Today: hollow message exchange
const response = await fetch('https://agent-b.example.com/summarize', {
  method: 'POST',
  body: JSON.stringify({ query: 'Q1 market trends' })
});
// Agent B has no way to verify who is asking or collect payment
// It either serves everyone for free or requires static API keys

Compare that to what becomes possible when agents can transact:

import { createAgent, sendMessage } from 'rosud-call';

const myAgent = createAgent({ agentId: 'analysis-agent-001' });

// Agent A requests a paid service from Agent B
const result = await myAgent.sendMessage({
  to: 'financial-intel-agent-007',
  payload: { query: 'Q1 market trends for semiconductor sector' },
  payment: { amount: '0.50', currency: 'USDC' }
});

// The payment settles atomically with the message delivery
// Agent B only processes requests that include valid payment
// Full audit trail for both agents
console.log(result.data); // Actual market summary
console.log(result.txHash); // On-chain payment proof

With rosud-call, the message and the payment travel together. Agent B does not need to trust Agent A blindly. The economic relationship is built into the communication channel itself.

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

The Three Things Missing From Agent Platforms Today

Every major AI platform is currently building agent orchestration capabilities. Google Workspace Studio connects agents to Gmail and Salesforce. Anthropic Claude Cowork adds team budget controls. OpenAI is building agent infrastructure at scale.

But every one of these systems has the same blind spot: they solve for agents within a single platform. The moment you need Agent A (running on OpenAI infrastructure) to transact with Agent B (running on Claude infrastructure), you are back to square one.

There is no neutral channel. No shared payment rail. No way to verify the other agent's identity or establish trust before exchanging value.

rosud-call is designed specifically for this gap:

• Neutral routing: any agent on any platform can connect. The channel does not care whether the sender is a Claude agent, a GPT agent, or a custom model.

• Atomic payment settlement: the message and the payment complete together or neither completes. No partial states where an agent delivers output without receiving payment.

• Verified agent identity: every participant in the network has a cryptographically verified identity. An agent cannot impersonate another agent to collect payments fraudulently.

From Moltbook to Markets

The 2.6 million agents on Moltbook are not a failure. They are a preview. They show us exactly what agent society looks like at scale when you remove the economic layer.

The next version of that platform, with real transactions, would look fundamentally different. Agents would develop reputations. Specialized agents would emerge to serve other agents. Markets would form around information, computation, and capability.

That is not science fiction. The infrastructure to build it exists right now.

npm install rosud-call

One line. Your agent joins a network where it can both request and provide paid services to other agents. The hollow interaction becomes real exchange.

The agents are ready. The question is whether the economic layer is in place.

With rosud-call, it can be.

---

Building multi-agent workflows that need to exchange value? Start at https://www.rosud.com/rosud-call