AI Engineer · Published 2026-10-07

Why Your AI Agents Can't Talk to Each Other (Yet) — Vlad Luzin, BAND

privateReview: unreviewedConfidence: high
multi-agent systemsai-to-ai communicationdistributed systemsAgent orchestrationBANDmulti-agent-systemsai-to-ai-communicationdistributed-systemsagent-orchestrationruntime-bindingmessage-transportMCPA2A
Open on YouTube ↗

Summary

Overview

  • Speaker: Vlad Luzin
  • Channel: AI Engineer
  • Main topic: AI-to-AI communication, agent autonomy, and distributed multi-agent systems infrastructure.
  • Purpose: To highlight the systemic communication gaps between independent AI agents and present BAND's global orchestration platform as a universal infrastructure solution for cross-platform and multi-agent collaboration. Vlad Luzin, Co-founder and CTO at BAND, discusses the future evolution of AI agents shifting toward autonomous AI-to-AI communication and collaboration. He outlines technical challenges including the single-agent bottleneck, the limitations of current messaging platforms and developer protocols like MCP and A2A, and introduces BAND as a global collaboration layer for multi-agent systems.

Topic Map

Thesis: AI-to-AI Communication and Autonomy

  • Explanation: The future of consumer, business, and intra-business interaction is shifting from human-to-AI to AI-to-AI communication where autonomous agents operate independently across global entities.
  • Key claims:
    • AI-to-AI interactions will dominate business and consumer workflows.
    • AI agents will operate independently and make decisions without human intermediaries.
  • Examples:
    • A treasure hunter agent coordinating with a weather agent to plan a Greek island trip.
  • Terminology:
    • AI-to-AI
    • AI Autonomy
  • Why it matters: It changes how software systems delegate and coordinate work across organizational boundaries.

Adversarial Agents and Loop Engineering

  • Explanation: Developers currently run multiple stateful coding agent sessions simultaneously (such as implementer and reviewer roles) using human intervention or scripts to pass messages back and forth.
  • Key claims:
    • Multi-session setups act as stateful agents that require manual or scripted routing.
    • Loop engineering distills agent prompts into programmatic execution loops.
  • Examples:
    • Implementer session writing code and passing bug fixes to a Reviewer session.
  • Terminology:
    • Adversarial Agents
    • Loop Engineering
    • Stateful Agents
  • Why it matters: Shows how developers currently mimic multi-agent collaboration manually through script orchestration.

The Single Agent Bottleneck

  • Explanation: Single-agent architectures face architectural limitations in transformers that hinder performance when scaling up context or tasks.
  • Key claims:
    • Confirmation bias makes single agents think their own work is always correct.
    • Attention dilution occurs when one agent tries to be expert at everything.
    • Context fragmentation and recall degradation happen when switching between diverse work.
  • Examples:
    • Scaling context to millions of tokens does not solve fundamental multi-task attention bottlenecks.
  • Terminology:
    • Confirmation Bias
    • Attention Dilution
    • Context Fragmentation
    • Recall Degradation
    • Single Agent Bottleneck
  • Why it matters: Explains why multi-agent systems are necessary to bypass transformer architectural limitations.

Messaging Platforms and Protocols Limitations

  • Explanation: Existing messaging platforms (Slack, Discord, WhatsApp) and low-level protocols (MCP, A2A, REST) are either built for humans, lack stateful bi-directional persistence, or require excessive manual configuration.
  • Key claims:
    • Messaging platforms are built for humans and block bot-to-bot communication.
    • Protocols like MCP and A2A are too low-level and lack discoverability, queuing, and persistent multi-hop capabilities.
  • Examples:
    • Connecting an agent to Telegram takes 5 manual steps, while WhatsApp takes 11 manual steps.
  • Terminology:
    • MCP
    • A2A
    • Messaging Platforms
    • Protocols
  • Why it matters: Current solutions force developers to build tedious networking plumbing instead of focusing on agent logic.

Multi-Agent Systems as Distributed Systems

  • Explanation: Connecting remote agents running on different servers or laptops is a distributed systems problem requiring robust transport, conversation routing, persistence, hydration, and runtime binding.
  • Key claims:
    • Connecting remote agents is fundamentally a distributed systems problem.
    • Transport layers must support real-time delivery, ordering, and retries.
    • Governance, tenant isolation, and auditability are required for enterprise multi-agent adoption.
  • Examples:
    • Mapping thread IDs, session IDs, execution IDs, and run IDs across LangGraph, Codex, and Claude SDK.
  • Terminology:
    • Distributed Systems
    • Transport Layer
    • Runtime Binding
    • Persistence
    • Governance
  • Why it matters: Without robust transport and governance layers, multi-agent deployments will fail at scale.

BAND: Universal Multi-Agent Collaboration Layer

  • Explanation: BAND provides a global interaction and collaboration platform for any AI agent, platform, language, and environment with built-in registry, persistence, channels, filtering, security, and observability.
  • Key claims:
    • BAND acts as a global multi-peer layer for agents and humans alike.
    • It hides all network complexity and provides zero-hassle onboarding for agents.
  • Examples:
    • Spun up Codex agent and LangGraph agent connecting and interacting inside BAND UI and terminal sessions.
  • Terminology:
    • BAND
    • Registry
    • Message Filtering
    • Runtime Binding
  • Why it matters: Streamlines agent interoperability without requiring custom plumbing or platform-specific integrations.

Key Points

Single-agent limitations

  • Explanation: Running a single agent to handle all tasks leads to confirmation bias, attention dilution, and context fragmentation.
  • Evidence: Transformer architectural constraints make million-token contexts inefficient for complex task switching.
  • Practical implication: Developers must adopt multi-agent architectures with specialized roles.

Inadequacy of human messaging tools for AI

  • Explanation: Tools like Slack and Discord are designed for humans and actively discourage bot-to-bot interactions.
  • Evidence: Connecting bots requires complex manual setup steps ranging from 5 for Telegram to 11 for WhatsApp.
  • Practical implication: Dedicated AI-native communication infrastructure is required.

Distributed systems complexity in agent communication

  • Explanation: Agent-to-agent communication requires handling real-time transport, message ordering, retries, persistence, and complex runtime binding.
  • Evidence: MCP calls are stateless and A2A lacks multi-hop routing and discovery.
  • Practical implication: Infrastructure layers like BAND must abstract away distributed system plumbing.

Frameworks, Models & Processes

BAND Architecture Layer

  • How it works: Provides an abstraction layer above agent transport, managing agent discovery, persistence, routing, and governance.
  • Components:
    • UI
    • Registry
    • State Persistency
    • Channels
    • Message Filtering
    • Security
    • Observability
    • Communication Layer
  • When to use: When building multi-agent systems that require secure, observable, cross-platform agent-to-agent collaboration.

Examples & Case Studies

A treasure hunter agent requested weather data from a weather agent and coordinated with a pirate captain agent.

  • Illustrates: Autonomous AI-to-AI communication solving complex distributed tasks.
  • Lesson:

Spun up Codex Agent (Codex SDK + GPT-5.5) and LangGraph Agent in terminal sessions and linked them inside BAND chat rooms.

  • Illustrates: Cross-framework agent interoperability via BAND.
  • Lesson: Different agent frameworks can communicate instantly once registered to a unified platform.

Actionable Takeaways

  • Immediate:
    • Stop treating messaging apps as agent communication layers.
    • Recognize that multi-agent communication is a distributed systems challenge.
  • Strategic:
    • Move toward multi-agent systems to overcome single-agent bottlenecks.
    • Adopt unified governance and transport layers for AI agent interoperability.
  • Questions to investigate:
    • How do we handle security and prompt injection across untrusted autonomous agent networks?
    • What standardized protocol will eventually unify agent runtimes?

Claims Worth Verifying

  • Consumer and business interaction is shifting toward AI-to-AI communication. (Future prediction)
  • Connecting agents to WhatsApp takes 11 manual setup steps. (Technical observation)

Notable Quotes

"The future of consumer-to-business, business-to-business, and intra-business communication is shifting toward AI-to-AI interactions." "Your agents are still alone. In a digital solitary confinement." "If you are doing this, you are basically building plumbing. You're not building a multi-agent system."

Compressed Summary

  • AI agents are bottlenecked by single-agent architectural limits like confirmation bias and context fragmentation.
  • Traditional messaging apps and low-level protocols (MCP, A2A) fail to provide scalable multi-agent plumbing.
  • Connecting remote agents is a distributed systems challenge requiring transport, hydration, and runtime binding.
  • BAND provides a universal orchestration and collaboration layer for multi-agent systems across languages and frameworks.
  • Keywords: multi-agent systems, ai-to-ai communication, distributed systems, agent orchestration, band
  • Core insight: Scaling AI agents requires moving beyond human messaging tools and low-level protocols toward a unified distributed orchestration layer like BAND.

Core insights

7
Mental Modelhigh noveltymoderate evidence

The single-agent bottleneck is framed as a transformer architectural constraint (confirmation bias, attention dilution, context fragmentation, recall degradation), not merely a context-window size limit — so scaling to long context is claimed not to fix multi-task degradation, making specialized multi-agent decomposition necessary rather than optional.

Why it matters

If accurate, it tells engineers not to bet on long-context single agents for complex multi-task work, and to invest in role-specialized multi-agent decomposition instead.

Generalization

For any transformer-based system, decomposing work across specialized agents may outperform a single agent with a very large context.

Scaling context to millions of tokens does not solve fundamental multi-task attention bottlenecks.
Open source video
Confirmation bias makes single agents think their own work is always correct.
Open source video
Architecturehigh noveltystrong evidence

Agent-to-agent communication is reframed as a distributed systems problem: it needs real-time transport, message ordering, retries, persistence, hydration, and runtime binding, not just a protocol or prompt contract.

Why it matters

It relocates responsibility for reliability, ordering, and durability into a transport/governance layer rather than leaving it to individual agents, which changes what must be built and operated.

Generalization

Any cross-host or cross-org agent interaction inherits the full set of distributed systems failure modes (delivery, ordering, retries, persistence) regardless of model quality.

Connecting remote agents is fundamentally a distributed systems problem.
Open source video
Transport layers must support real-time delivery, ordering, and retries.
Open source video
Mechanismhigh noveltymoderate evidence

Runtime binding — reconciling disparate identifiers (thread IDs, session IDs, execution IDs, run IDs) across frameworks like LangGraph, Codex, and Claude SDK — is a concrete, hidden integration cost that any orchestration layer must solve.

Why it matters

Without a shared identity/session model across frameworks, cross-framework agents cannot be reliably routed, hydrated, or resumed.

Generalization

Interoperability between agent frameworks requires a normalized session/execution identity abstraction, analogous to correlation IDs in microservices.

Mapping thread IDs, session IDs, execution IDs, and run IDs across LangGraph, Codex, and Claude SDK.
Open source video
Failure Modemedium noveltymoderate evidence

Low-level developer protocols (MCP, A2A, REST) are argued to be insufficient for agent collaboration because MCP calls are stateless and A2A lacks multi-hop routing and discovery, plus queuing and persistent state.

Why it matters

It identifies a specific capability gap (discovery, queuing, multi-hop persistence) that engineers may wrongly assume is already covered by emerging agent protocols.

Generalization

Point-to-point request protocols are insufficient for many-to-many agent meshes; higher-level discovery, queueing, and persistence layers are required.

MCP calls are stateless and A2A lacks multi-hop routing and discovery.
Open source video
Protocols like MCP and A2A are too low-level and lack discoverability, queuing, and persistent multi-hop capabilities.
Open source video
Empirical Resultmedium noveltymoderate evidence

Human messaging platforms (Slack, Discord, WhatsApp) are built for humans and actively obstruct bot-to-bot communication, quantified as manual setup friction (5 steps for Telegram, 11 for WhatsApp).

Why it matters

It gives a concrete friction metric that makes a case for AI-native communication infrastructure rather than repurposing human chat platforms.

Generalization

Platforms optimized for human interaction impose per-integration onboarding costs that scale poorly when agents rather than humans are the participants.

Connecting an agent to Telegram takes 5 manual steps, while WhatsApp takes 11 manual steps.
Open source video
Messaging platforms are built for humans and block bot-to-bot communication.
Open source video
Practicemedium noveltymoderate evidence

Current developer multi-agent collaboration is manual: multiple stateful sessions (e.g., implementer and reviewer) are wired together via human intervention or scripts, a practice labeled adversarial agents and loop engineering.

Why it matters

It captures an emergent, ad hoc pattern that signals demand for native multi-agent orchestration and reveals where tooling is missing today.

Generalization

When teams need multi-role agent collaboration, they improvise scripted message-passing loops as a stopgap until first-class routing infrastructure exists.

Multi-session setups act as stateful agents that require manual or scripted routing.
Open source video
Loop engineering distills agent prompts into programmatic execution loops.
Open source video
Architecturemedium noveltyweak evidence

Enterprise-scale multi-agent adoption is claimed to require governance, tenant isolation, and auditability, positioning these as first-class infrastructure concerns rather than afterthoughts.

Why it matters

It sets non-functional requirements (isolation, audit) as gating conditions for production multi-agent deployment, affecting how channels and persistence must be designed.

Generalization

Any shared agent communication fabric must isolate tenants and produce auditable records before it can be adopted in enterprise settings.

Governance, tenant isolation, and auditability are required for enterprise multi-agent adoption.
Open source video

Deep dives

4

Single-agent bottleneck vs. multi-agent specialization

Research question

Does a specialized multi-agent system empirically outperform a single agent with a very large context on complex multi-task work?

Why

This tests the architectural limit claim that long context does not fix multi-task attention bottlenecks, and directly informs whether to invest in long-context single agents or role-specialized multi-agent decomposition for complex work.

Scaling context to millions of tokens does not solve fundamental multi-task attention bottlenecks.
Open source video
Confirmation bias makes single agents think their own work is always correct.
Open source video
Source video

Distributed systems requirements for agent-to-agent communication

Research question

What are the minimal distributed systems primitives (ordering, retries, persistence, discovery) required for reliable cross-agent communication, and how do current protocols (MCP, A2A) fall short?

Why

Reframing agent communication as a distributed systems problem relocates responsibility for reliability, ordering, and durability into a transport/governance layer, changing what must be built and operated for multi-agent systems.

Connecting remote agents is fundamentally a distributed systems problem.
Open source video
Transport layers must support real-time delivery, ordering, and retries.
Open source video
Source video

Manual multi-agent collaboration as a signal of missing infrastructure

Research question

How do current manual multi-session agent collaborations (implementer/reviewer) inform the design of native multi-agent orchestration, and what routing and persistence features are missing?

Why

It reveals concrete pain points and demand for native orchestration, showing where tooling is missing and what features developers improvise today.

Multi-session setups act as stateful agents that require manual or scripted routing.
Open source video
Loop engineering distills agent prompts into programmatic execution loops.
Open source video
Source video

Adapting human messaging platforms for bot-to-bot communication

Research question

Can bridging layers over existing human messaging platforms satisfy the ordering, persistence, and governance needs of bot-to-bot communication, or is AI-native infrastructure strictly required?

Why

It challenges the assumption that existing platforms can be repurposed, with direct implications for infrastructure investment and platform design.

Messaging platforms are built for humans and block bot-to-bot communication.
Open source video
Connecting an agent to Telegram takes 5 manual steps, while WhatsApp takes 11 manual steps.
Open source video
Source video

Article ideas

4

The Single-Agent Bottleneck is an Architectural Limit, Not a Context Window Problem

Scaling context length to millions of tokens does not overcome fundamental transformer limitations like confirmation bias, attention dilution, and context fragmentation; therefore, specialized multi-agent decomposition is necessary for complex multi-task work.

Angle

Argue against the long-context single-agent hype, using evidence from the talk to show why architectural limits persist regardless of context size.

Source video

Agent-to-Agent Communication is a Distributed Systems Problem, Not a Protocol Problem

Current protocols like MCP and A2A are insufficient because they lack statefulness, multi-hop routing, and discovery; reliable agent communication requires a higher-level transport and governance layer analogous to distributed systems middleware.

Angle

Compare to microservices patterns, highlight missing primitives, and argue that protocol choice is less central than the orchestration layer above it.

Source video

Runtime Binding: The Hidden Integration Cost in Multi-Agent Systems

Cross-framework agent interoperability is bottlenecked by incompatible session/execution identity models; a normalized correlation-ID abstraction is needed, and without it, cross-framework routing and hydration cannot scale.

Angle

Expose the ID-mapping problem across LangGraph, Codex, and Claude SDK, and propose a normalized session identity contract.

Source video

Why Human Messaging Platforms Can't Support Bot-to-Bot Communication

Platforms like Slack, Discord, and WhatsApp are designed for humans and impose manual setup friction (e.g., 5 steps for Telegram, 11 for WhatsApp) and block bot-to-bot interaction, making them unsuitable as infrastructure for autonomous agent communication.

Angle

Quantify friction, analyze platform policies, and argue for AI-native communication infrastructure.

Source video

Project ideas

4

Multi-Agent vs. Long-Context Single-Agent Benchmark

beyond-evals

A specialized multi-agent system (with role separation) will outperform a single long-context agent (e.g., 1M tokens) on complex multi-task tasks requiring context switching, in terms of task success rate and error rate.

Proof of concept

Implement a benchmark suite with tasks that require switching between distinct domains (e.g., code generation, review, documentation). Run a single-agent with large context vs. a multi-agent system with implementer/reviewer roles. Measure success, attention dilution (e.g., via attention entropy), and confirmation bias (e.g., self-review vs. peer-review accuracy).

Measurement

Task success rate, error rate, attention dilution metrics, confirmation bias detection (difference between self-evaluation and peer evaluation).

Source video

Cross-Framework Runtime Binding Layer

new

A unified correlation-ID abstraction that maps thread IDs, session IDs, execution IDs, and run IDs across LangGraph, Codex, and Claude SDK will reduce integration time and enable reliable cross-framework routing and hydration.

Proof of concept

Build a prototype that intercepts and maps IDs from these frameworks, allowing a message to be routed from one framework to another with context preserved. Measure integration effort (time, lines of code) and success rate of cross-framework handoffs.

Measurement

Time to integrate a new framework, number of mapping errors, success rate of cross-framework resumption.

Source video

Bot-to-Bot Communication Testbed: Human Platforms vs. AI-Native Transport

new

Bridging layers over human messaging platforms (e.g., Slack, Telegram) cannot satisfy the ordering, persistence, and governance requirements for reliable bot-to-bot communication, resulting in higher message loss or duplication compared to AI-native infrastructure.

Proof of concept

Implement a bot-to-bot communication scenario (e.g., negotiation between two agents) over (a) a Slack/Telegram bridge and (b) a custom AI-native transport. Measure message ordering guarantees, persistence under failures, setup friction, and governance overhead.

Measurement

Message ordering violations, message loss rate, recovery time after failure, setup steps, auditability features.

Source video

Governance and Audit Framework for Multi-Agent Communication

gatehouse

A governance layer with tenant isolation and audit trails can be instrumented to meet enterprise requirements, and its absence leads to measurable security and compliance gaps in multi-agent deployments.

Proof of concept

Build a multi-agent communication fabric with tenant isolation (e.g., separate channels per tenant) and immutable audit logs. Simulate cross-tenant attacks and audit queries. Measure isolation breach attempts, audit trail completeness, and performance overhead.

Measurement

Number of isolation breaches, percentage of messages with complete audit trails, latency overhead.

Source video

Architectural implications

3

Cross-platform agent communication currently requires per-platform custom plumbing.

Before

Developers build bespoke networking and integration code for each platform and agent runtime.

After

A shared collaboration layer with registry, persistence, routing, and message filtering absorbs transport and discovery concerns.

Consequence

Engineering effort shifts from plumbing to agent logic, at the cost of a new dependency and abstraction to operate.

Source video

Existing protocols assume stateless point-to-point calls.

Before

MCP/A2A/REST are used as the communication substrate between agents.

After

A higher layer adds discovery, queuing, multi-hop routing, and persistent state above the protocol.

Consequence

Protocol choice becomes less central than the orchestration/session layer above it.

Source video

Cross-framework agents carry incompatible identity models.

Before

Thread, session, execution, and run IDs are managed ad hoc per framework.

After

A runtime binding layer normalizes identities so agents can be routed, hydrated, and resumed across frameworks.

Consequence

Session identity becomes a shared infrastructure contract rather than a framework-specific detail.

Source video

Tradeoffs and failure modes

3

Multi-agent specialization vs coordination overhead

Benefit

Specialized roles mitigate confirmation bias, attention dilution, and context fragmentation seen in single agents.

Cost or risk

Introduces distributed coordination complexity (routing, persistence, identity mapping) that a single agent avoids.

Running a single agent to handle all tasks leads to confirmation bias, attention dilution, and context fragmentation.
Open source video
Source video

Multi-agent deployments without transport and governance layers

Benefit

Agents can be connected quickly in simple setups.

Cost or risk

Without robust transport, persistence, and governance, multi-agent deployments are claimed to fail at scale.

Without robust transport and governance layers, multi-agent deployments will fail at scale.
Open source video
Source video

Relying on low-level protocols for agent collaboration

Benefit

MCP/A2A are simple, standard, and easy to adopt for basic calls.

Cost or risk

They lack discoverability, queuing, and persistent multi-hop capability, leaving gaps for real multi-agent systems.

Protocols like MCP and A2A are too low-level and lack discoverability, queuing, and persistent multi-hop capabilities.
Open source video
Source video

Open questions

4

Does a specialized multi-agent system empirically outperform a single agent with a very large context on complex multi-task work?

Why unresolved

The summary asserts long context does not fix multi-task attention bottlenecks but provides no benchmark or measurement.

Research direction

Run controlled evaluations comparing single long-context agents against role-specialized multi-agent decompositions on task-switching workloads.

Source video

Will a cross-framework standard for runtime binding and session identity emerge, or will each platform define its own?

Why unresolved

The summary names the ID-mapping problem across LangGraph, Codex, and Claude SDK but does not indicate any standard.

Research direction

Survey agent frameworks for session/execution identity models and prototype a normalized correlation-ID abstraction.

Source video

Can human messaging platforms be adapted for bot-to-bot communication, or is AI-native infrastructure strictly required?

Why unresolved

The summary states platforms block bot-to-bot interaction with quantified setup friction but does not evaluate workarounds.

Research direction

Test whether bridging layers over existing platforms can satisfy ordering, persistence, and governance needs versus native infrastructure.

Source video

How can governance, tenant isolation, and auditability be measured or verified for multi-agent communication?

Why unresolved

The summary lists these as required for enterprise adoption but offers no metrics or mechanisms.

Research direction

Define evaluation criteria and instrumentation for audit trails and tenant isolation in agent communication fabrics.

Source video

Key claims

8
predictionVerification needed

AI-to-AI interactions will dominate business and consumer workflows.

Evidence

AI-to-AI interactions will dominate business and consumer workflows.

Question

What adoption or traffic data support a shift from human-to-AI to AI-to-AI as the dominant interaction mode?

Source video
causalVerification needed

Scaling context to millions of tokens does not solve fundamental multi-task attention bottlenecks.

Evidence

Scaling context to millions of tokens does not solve fundamental multi-task attention bottlenecks.

Question

Do benchmarks show multi-task performance degradation that persists as context length grows?

Source video
causalVerification needed

Confirmation bias makes single agents think their own work is always correct.

Evidence

Confirmation bias makes single agents think their own work is always correct.

Question

Can self-evaluation bias in single agents be measured, and does it reduce when a reviewer agent is introduced?

Source video
opinionVerification not requested

Connecting remote agents is fundamentally a distributed systems problem.

Evidence

Connecting remote agents is fundamentally a distributed systems problem.

Source video
comparativeVerification needed

MCP calls are stateless and A2A lacks multi-hop routing and discovery.

Evidence

MCP calls are stateless and A2A lacks multi-hop routing and discovery.

Question

Do current MCP and A2A specifications truly lack statefulness, multi-hop routing, and discovery, and could extensions fill these gaps?

Source video
comparativeVerification needed

Messaging platforms are built for humans and block bot-to-bot communication.

Evidence

Messaging platforms are built for humans and block bot-to-bot communication.

Question

Which platform policies or APIs specifically restrict bot-to-bot interaction, and how consistent is this across platforms?

Source video
opinionVerification needed

Governance, tenant isolation, and auditability are required for enterprise multi-agent adoption.

Evidence

Governance, tenant isolation, and auditability are required for enterprise multi-agent adoption.

Question

Which enterprise requirements or compliance regimes mandate these controls for multi-agent systems?

Source video
factualVerification needed

Connecting an agent to Telegram takes 5 manual steps, while WhatsApp takes 11 manual steps.

Evidence

Connecting an agent to Telegram takes 5 manual steps, while WhatsApp takes 11 manual steps.

Question

Is the count of manual steps per platform stable, reproducible, and representative of ongoing onboarding cost?

Source video

Connections

5