I've been exploring Bindu's positioning as:

"The identity, communication, and payments layer for AI agents"

and I'm trying to understand the architectural scope of the communication layer.

WAMP already provides all four of:

• routed RPC
• routed PubSub
• federation/router-to-router
• payment-enabled services (via XBR)

From the documentation, Bindu appears to be centered around:

• A2A-based JSON-RPC communication
• task execution and orchestration
• agent discovery
• decentralized identity (DIDs)
• authenticated agent-to-agent interactions
• integrated payments

This made me wonder how the project views communication patterns compared to WAMP (Web Application Messaging Protocol).

Relevant references:

• WAMP protocol: https://wamp-proto.org/
• WAMP specifications: https://github.com/wamp-proto/wamp-proto/
• Crossbar.io router: https://github.com/crossbario/crossbar
• Autobahn client libraries: https://github.com/crossbario/autobahn-python, https://github.com/crossbario/autobahn-js, ...
• XBR (payments): https://github.com/wamp-proto/wamp-xbr

Communication Model Comparison

One thing I find particularly interesting is that WAMP was designed from the beginning around two equally important communication patterns:

Routed RPC

Examples:

• Summarize a document
• Evaluate a policy
• Generate a report
• Execute a workflow step

Publish & Subscribe

Examples:

• Market data streams
• Agent status updates
• Shared world-state changes
• Event notifications
• Knowledge updates
• Monitoring and telemetry

For multi-agent systems, both patterns seem useful and complementary.

Router-to-Router Federation

Another area where I'm curious about Bindu's roadmap is federation.

The WAMP architecture includes explicit routing roles:

• Broker (PubSub)
• Dealer (RPC)

combined in a Router.

Historically, the WAMP ecosystem has explored:

• router-to-router topologies
• distributed routing fabrics
• federated deployments
• independently operated routing domains
• cross-domain RPC and PubSub propagation

rather than assuming a single routing authority.

For agent ecosystems, this seems highly relevant because agents will likely be operated by different organizations, cloud providers, enterprises, and individuals.

Decentralization

An especially interesting aspect is decentralized operation.

The WAMP ecosystem has experimented with architectures where:

• routers are operated by different parties
• trust relationships are established between domains
• RPC and PubSub can span organizational boundaries
• communication remains routed rather than point-to-point

This feels conceptually similar to how email servers, Matrix homeservers, or ActivityPub servers federate.

Does Bindu envision something similar for agent communication?

Or is the intended model primarily direct agent-to-agent interaction secured by DIDs and signatures?

Payments

Another area where there seems to be overlap is payments.

Bindu integrates payments directly into the agent interaction model.

The WAMP ecosystem explored a related idea through XBR:

https://github.com/wamp-proto/wamp-xbr

which combines:

• WAMP messaging
• cryptographic identities
• market-based access control
• off-chain payment channels
• micropayments for services and data

My understanding is that XBR was designed to monetize both RPC-style services and streaming/event-driven data products.

This raises an architectural question:

Is Bindu's long-term vision primarily secure paid RPC between agents, or does it also aim to become a general-purpose communication fabric supporting both RPC and PubSub semantics at the protocol level?

Questions

1. Does Bindu plan to support first-class PubSub semantics between agents?

2. If not, is the intended architecture:

   • RPC/tasks at the protocol layer
   • PubSub delegated to Kafka, NATS, Redis Streams, MQTT, etc. underneath?

3. How does the team think about event-driven agent architectures?

4. Is there a roadmap for federated communication across independently operated Bindu domains?

5. How does Bindu's vision differ from a federated WAMP-style architecture that provides:

   • RPC
   • PubSub
   • router federation
   • decentralized routing domains
   • integrated service payments

6. Has the team evaluated WAMP as a communication substrate for AI agents, and if so, what trade-offs led to the current A2A-centric design?

I'm asking because many agent systems seem to naturally require both:

• command/query interactions (RPC)
• event-driven interactions (PubSub)

and WAMP's design explicitly treats both as first-class communication primitives rather than building solely around RPC.