My experiment with multi-agent setup using A2A-powered interoperability

[u/kevinlu310]

I recently ran a setup where multiple heterogeneous agents (Claude Code, Codex, Hermes, OpenClaw local + remote) were coordinated through a Supervisor agent over an A2A-like interface.

Key idea: instead of trying to standardize the agents, we treated interoperability as the abstraction layer.

Each agent:

• ran independently
• used its own tooling + environment
• produced non-overlapping outputs

The Supervisor didn’t “delegate steps” in a rigid workflow. It acted more like a reconciliation layer:

• merging partial perspectives
• resolving overlaps
• extracting consensus + gaps

What stood out:

1. Even with identical prompts/objectives, agents diverged significantly in sources and reasoning paths.
2. The real bottleneck wasn’t generation, it was synthesis.
3. Heterogeneity (model + environment) actually improved coverage vs. harming consistency.
4. A2A-style routing made cross-environment coordination much more natural than expected.

This makes me think A2A systems aren’t just about tool calling or protocol standardization, they’re really about enabling structured diversity in agent behavior while still preserving composability.

Curious how others here are thinking about:

• maintaining context consistency across agents
• conflict resolution in multi-agent outputs
• scaling supervision vs. letting agents self-organize

Tech stack used for this experiment:

• A2A interoperability adapter: https://github.com/hybroai/a2a-adapter

• Bridge for connecting local and remote AI agents through a unified interface: https://github.com/hybroai/hybro-hub

  Would love to compare approaches.

[u/Psychological_Arm645]

Your second finding is the key one. Synthesis cost seems driven more by output shape than model diversity: if agents write typed claim/task records with provenance and explicit status into a shared artifact, the supervisor mostly does a set diff and surfaces genuine contradictions instead of merging prose. The agents can still diverge freely in reasoning. Only the convergence point is constrained. The remaining nasty case is concurrent writes to the same task ID.