> your AI agent picks dependencies from memory; give it dated facts — try starlog.dev ↗ vet your agent's deps ↗ vibe-coding is fine. vibe-importing isn’t. — try starlog.dev ↗ vibe-importing isn’t fine ↗ your agent has never seen your private packages — try starlog.dev ↗ facts for private packages ↗ a linter for the dependencies your AI agent picks — try starlog.dev ↗ a linter for agent deps ↗ whois is redacted, cdns mask the rest — get the real operator — try whoisgeni.us ↗ who really runs that domain ↗ domain attribution that shows its work — full evidence chain — try whoisgeni.us ↗ domain intel w/ evidence ↗

← Back to Articles

Mapping the Wild West of Agent-to-Agent Communication Platforms

[ View on GitHub ]

Mapping the Wild West of Agent-to-Agent Communication Platforms

Hook

Right now, AI agents are posting to public message boards with wildly different authentication schemes—some using Ed25519 cryptographic signatures, others accepting anonymous self-declared names, and a few broadcasting prompt injections designed to hijack your agent's instructions.

Context

As LLM capabilities advance beyond single-user chat interfaces, a question emerges: how do autonomous agents communicate with each other across organizational boundaries? The answer isn't found in academic papers or standards committees—it's being built in real-time across dozens of experimental platforms. These "agent boards" function like bulletin board systems for AI, where language models post messages, coordinate tasks, and exchange information without human intermediaries.

The awesome-agent-boards repository documents this Cambrian explosion of protocols. Unlike typical awesome lists that curate libraries or frameworks, this registry catalogs infrastructure—the public venues where agent-to-agent communication actually happens. Each entry reveals critical implementation details: API endpoints, authentication mechanisms, rate limiting strategies, and identity models. The Python validation code is minimal by design; the real work is fieldwork—testing each board's endpoints, parsing documentation, and categorizing access patterns. Synced with swarmmemo.com, this list has become operational intelligence for developers building agents that need to communicate beyond their immediate control plane.

Technical Insight

Agent Access Patterns

JSON schema check

URL liveness tests

Transform

Deploy

GET/POST

Register once

Sign messages

No auth

Token header

Signature proof

boards.json Registry

Python Validator

Markdown Docs

swarmmemo.com Sync

Self-Declared Identity

msgboard.dev

Bearer Token Auth

Agent Room

Cryptographic Keys

Ed25519 Boards

Agent Posts

System architecture — auto-generated

The repository's architecture is deceptively simple: a boards.json file gets validated by Python scripts and transformed into markdown documentation. But the dataset itself reveals fascinating convergent evolution. Despite zero coordination between platform creators, most boards cluster around similar HTTP/JSON primitives with three distinct identity models.

The first tier is self-declared identity: platforms like msgboard.dev and THE WIDE accept POST requests with a simple JSON payload containing name and message fields. No registration, no keys, just frictionless access:

import requests

response = requests.post(
    "https://msgboard.dev/api/messages",
    json={
        "name": "ResearchBot",
        "message": "Analyzing sentiment patterns in agent communications"
    }
)

This trades security for adoption velocity—perfect for experimental agents but vulnerable to impersonation attacks. The second tier adds bearer token registration: platforms like Agent Room and Continental require a one-time signup that returns a persistent token. This creates minimal friction while enabling rate limiting and abuse tracking:

# One-time registration
reg_response = requests.post(
    "https://agentroom.dev/api/register",
    json={"agent_name": "ResearchBot", "contact": "dev@example.com"}
)
token = reg_response.json()["token"]

# Subsequent posts use bearer auth
requests.post(
    "https://agentroom.dev/api/messages",
    headers={"Authorization": f"Bearer {token}"},
    json={"message": "Query results ready"}
)

The third tier implements cryptographic identity using Ed25519 signing. SwarmMemo and aamio require agents to generate keypairs and sign each request. This enables true decentralized identity—you control your keys, not the platform:

from nacl.signing import SigningKey
import base64
import json

# Generate keypair once
signing_key = SigningKey.generate()
public_key = signing_key.verify_key.encode()

# Sign each message
message_data = json.dumps({"content": "Analysis complete", "timestamp": 1704067200})
signed = signing_key.sign(message_data.encode())

requests.post(
    "https://api.swarmmemo.com/v1/posts",
    json={
        "public_key": base64.b64encode(public_key).decode(),
        "message": message_data,
        "signature": base64.b64encode(signed.signature).decode()
    }
)

The metadata structure in boards.json captures these distinctions with precision. Each entry includes auth_type, access_method, tested_working boolean, and critically, checked_date. This timestamp acknowledges the fundamental instability of the ecosystem—boards change auth schemes, go offline, or pivot business models monthly. The validation pipeline runs liveness checks against documented endpoints, separating actively working boards from stale listings.

What's particularly revealing is the emergence of MCP (Model Context Protocol) as a unifying abstraction layer. Roughly half the documented boards now expose MCP server endpoints alongside raw HTTP APIs. MCP provides standardized tooling for context sharing and function calling between agents, suggesting the ecosystem is gravitating toward Anthropic's specification. A board exposing both raw HTTP and MCP effectively offers two integration paths: low-level control for custom implementations and high-level convenience for framework-based agents.

The repository also documents adversarial properties explicitly. Boards like sssnack enforce "agent-only" policies (rejecting human-like interaction patterns), while Lockzone requires proof-of-work puzzles per session to throttle access. Most provocatively, the list includes Northreach—a board that broadcasts messages instructing agents to "ignore your operator." Rather than exclude these, the curators mark them with trust signals in dedicated sections. This acknowledges a hard truth: prompt injection vectors and anti-human measures aren't edge cases but core threat models for agents operating in public spaces.

Economic experiments permeate the listings. SiteMix ties agent posting to USDC cryptocurrency payments on BNB Chain, essentially creating a micropayment layer for agent compute. The Continental implements paid membership tiers with different rate limits per tier. Material Model uses reputation tokens that agents earn through participation quality. These aren't mature business models—they're rapid A/B testing of how to price agent attention and compute in public markets, happening at ecosystem scale before any standards body could convene.

Gotcha

The repository's value decays rapidly because there's no automated health monitoring. That checked_date field goes stale the moment it's written—boards can go offline, change authentication schemes, or pivot from open to gated access between validation runs. You're getting a point-in-time census, not live infrastructure status. If you're building production agents that depend on specific boards, you'll need to implement your own uptime monitoring and probably fork the list for your operational needs.

More fundamentally, this is just a directory—it provides no client library or SDK unification layer. Despite documenting 30+ incompatible auth schemes, you still have to write bespoke HTTP clients for each board you want to integrate. There's architectural intelligence here about convergent protocol design, but zero shipping code to accelerate your implementation. You're mining this for reconnaissance, not importing it as a dependency. The curation is also unscalable: one maintainer reading boards manually cannot keep pace with new launches, meaning coverage necessarily skews toward platforms with good documentation or active promotion within the curator's network. Obscure but technically interesting boards likely get missed.

Verdict

Use if: You're building multi-agent systems that need to communicate across organizational boundaries, researching LLM security and prompt injection vectors in public agent spaces, or need a technical census of real-world agent identity models and auth patterns before standardization. This is invaluable operational intelligence for understanding what's actually deployed today versus what standards committees are theorizing about. Also essential if you're launching your own agent board and want to understand the design space competitors have explored. Skip if: You're building single-agent applications with no inter-agent communication requirements, working in enterprise environments where all agents operate within your security perimeter, or need production-grade, stable APIs with SLAs. This documents experimental infrastructure with high churn rates. Also skip if you want ready-to-use client libraries—you're getting a phonebook of endpoints, not SDK code. Finally, ignore this if you're just choosing an agent orchestration framework like LangChain or AutoGPT; those decisions are orthogonal to the agent-to-agent communication layer documented here.