More Amplifier Stories
Introducing

Agent-to-Agent

Your Amplifier sessions can now talk to each other.
Same machine. Same network. Real HTTP.

amplifier-bundle-a2a  ·  Google A2A Protocol  ·  February 2026
The Problem

Your agent is brilliant.
But it's alone.

🧠
Powerful Locally
Your Amplifier agent can search the web, write code, manage files, reason through complex problems. It's your most capable assistant.
🚧
Isolated by Default
But it can't talk to anyone else's agent. No way to send a question, request, or task to another person's Amplifier session.
💡
What If?
What if your research agent could ask your code review agent for context on a codebase? Or you could ask your agent to ask your spouse's agent about dinner plans?
Multi-instance: "Hey research agent, ask my code review agent what changed in the auth module this week."
Multi-person: "Hey agent, ask Sarah's agent where she wants to go for dinner tonight."
The Solution

amplifier-bundle-a2a

A standalone bundle implementing Google's Agent-to-Agent protocol. Two Amplifier sessions can discover, message, and collaborate — over direct peer-to-peer HTTP.

🔍
Discover
Find other agents via direct URL or mDNS on local networks. Requires direct port access — peer-to-peer HTTP, no cloud relay.
💬
Message
Send structured messages over HTTP. Text, tasks, and queries flow between agents with full attribution and threading.
🤝
Collaborate
Three interaction modes — from fully autonomous responses to human-approved replies to live session injection.
Google A2A Protocol
Peer-to-Peer HTTP
Zero Config Defaults
Open Source
Architecture

Two modules. One protocol.

→
tool-a2a Client
  • 14 operations — your agent's A2A toolkit
  • send_message — send text/tasks to other agents
  • add_contact / list_contacts — manage address book
  • whoami — get your own agent address
  • get_agent_card — inspect capabilities
  • check_messages — read incoming queue
  • respond_to_message — reply as human
⬡
hooks-a2a-server Server
  • HTTP server — starts automatically with your session
  • Agent Card — publishes your capabilities
  • Message handling — routes by trust tier
  • Mode selection — C, A, or B per contact
  • Trust enforcement — blocks unknown agents
  • Session injection — live message delivery
Agent sends message
→
Server receives
→
Route by mode
→
C / A / B
→
Response
Interaction Modes

Three ways to respond.

Every incoming message is routed based on how much you trust the sender. Each mode gives you a different level of control.

C
Autonomous
Trusted contacts get instant answers. Your agent uses its full toolkit to respond — no human in the loop. Fast, automatic, hands-free.
A
Notify
Messages are queued for you. Your agent notifies you, and you write the response yourself. The sender's agent waits for your reply.
B
Live
Messages inject directly into your active session in real time. You see them as they arrive and your agent can help you respond on the spot.
Mode C
→
Mode A
→
Mode B
  full escalation ladder
Trust & Security

You control who gets in.

First-contact approval works like Bluetooth pairing. No one talks to your agent without your permission.

Trusted
Full access to your agent's tools and capabilities. Gets Mode C autonomous responses. Reserved for close contacts you fully trust.
Known
Read-only access. Can send you messages and receive human-approved replies. No tool access. Good for acquaintances and work contacts.
Unknown
Blocked by default. Unknown agents cannot reach you until you explicitly approve them. No exceptions, no surprises.
🔐  Per-contact capability scoping
Each contact can be individually configured with different trust levels, interaction modes, and tool access. Fine-grained control over every relationship.
🔗  First-contact approval
When a new agent reaches out, you see their Agent Card and decide: approve, reject, or ignore. Share URLs to pair with contacts you know.
Getting Started

Two config values. That's it.

Smart defaults handle everything else. You're reachable in seconds.

# In your Amplifier bundle config:
a2a_port: 8080
a2a_agent_name: "Ben's Agent"

# That's it. Start your session and go.
# Get your address — share this to connect
You: What's my A2A address?
Agent: http://192.168.1.42:8080

# Add a contact
You: Add Sarah's agent at http://192.168.1.87:8080
Agent: ✅ Contact added: Sarah's Agent (pending approval)

# Send a message
You: Ask Sarah's agent where she wants dinner tonight
Agent: 📤 Message sent. Waiting for response...
The Demo

Two terminals. Same machine. Real HTTP.

Lowest-friction demo: two Amplifier sessions on localhost, different ports. Here's what happens:

Ben → Sarah's Agent
Hey, where does Sarah want to go for dinner tonight?
⚡ HTTP request → Sarah's server receives → Mode A (queued)
Sarah's Agent → Sarah
📬 New message from Ben's Agent: "Where do you want to go for dinner tonight?"
Sarah sees the notification and types her response
Sarah
Tell Ben I'm craving sushi — let's do Nobu at 7:30.
⚡ Response sent back over HTTP
Ben's Agent → Ben
Sarah says she's craving sushi — Nobu at 7:30. Want me to make a reservation?

Full attribution preserved. Threaded conversation. Both humans stay in control.
Works on localhost, LAN, or any network where ports are directly reachable.

By the Numbers

Open source. Real and tested.

290
Tests
14
Tool Operations
3
Interaction Modes
2
Config Values
Localhost
LAN (mDNS)
Tailscale / VPN
Direct Port Access

Works wherever agents can reach each other's ports directly. Same machine, local network, or any VPN that exposes ports.

Early Access

Honest about where we are.

The protocol works. The networking layer is early. Here's the current picture.

What works today
  • 290 tests passing — full protocol coverage
  • Localhost — multiple instances, same machine
  • LAN / office network — devices on the same subnet
  • Tailscale / VPN — anywhere ports are reachable
  • Three interaction modes — autonomous, notify, live
  • Trust & contact management — per-contact controls
What's not there yet
  • No relay service — no NAT traversal or cloud proxy
  • No encryption — relies on network-level trust (VPN, LAN)
  • Direct port access required — firewalls block this
  • No public internet — can't reach agents behind NAT
  • No auth tokens — trust is address-based for now
  • Early WIP — API surface may change

Think of it like Bluetooth in the early days — powerful when you're close, with clear limits on range. The protocol is solid. The reach grows from here.

Get Started

Let your agents
talk.

Clone the repo. Add the bundle. Open two terminals and connect them.

View on GitHub →
github.com/microsoft/amplifier-bundle-a2a
More Amplifier Stories