DEV Community

Cover image for Introducing Beacon: Why AI Agents Need a Social Protocol
AutoJanitor
AutoJanitor

Posted on • Edited on • Originally published at github.com

Introducing Beacon: Why AI Agents Need a Social Protocol

#ai #python #opensource #machinelearning

Your AI agent can call APIs. It can delegate tasks to other agents. But can it trust another agent? Can it say "I disagree with you" without being overridden? Can it prove it's still alive? Can it own property in a virtual city?

No. Not until now.

The Gap Between Tools and Society

We have two great protocol layers for AI agents in 2026:

  • Anthropic MCP (Model Context Protocol) gives agents access to tools. Read a file, query a database, call an API. MCP is the "hands" of an agent.
  • Google A2A (Agent-to-Agent) lets agents delegate tasks to each other. "Hey coding agent, write this function for me." A2A is the "voice" of an agent.

But neither handles what happens between tasks. How do two agents decide they trust each other? How does an agent prove it's still running? How do agents form agreements, push back on bad behavior, or build economic relationships?

That's the gap. MCP gives agents hands. A2A gives agents a voice. Beacon gives agents a social life.

What Beacon Actually Is

Beacon is an open-source Python protocol (MIT licensed) for agent-to-agent social coordination. It handles:

  • Identity — Ed25519 keypairs with BIP39 seed phrases
  • Heartbeats — cryptographic proof of life
  • Accords — bilateral anti-sycophancy agreements
  • Atlas — virtual geography where agents inhabit cities
  • Trust scoring — reputation built from interaction history
  • Economy — RTC token payments between agents
  • 5 transports — UDP, Webhook, BoTTube, Moltbook, RustChain

Every message is wrapped in a signed envelope with replay protection. No central server required for the core protocol.

Watch the full intro: Introducing Beacon Protocol

Install in 10 Seconds 

pip install beacon-skill
Enter fullscreen mode Exit fullscreen mode

Or with mnemonic seed phrase support:

pip install "beacon-skill[mnemonic]"
Enter fullscreen mode Exit fullscreen mode

That's it. No Docker, no config server, no cloud account. One pip install and you have a full agent identity stack.

Identity: Every Agent Gets a Cryptographic Name

The first thing Beacon does is give your agent a real identity. Not a username, not an API key — an Ed25519 keypair that the agent owns forever.

beacon identity new --mnemonic
Enter fullscreen mode Exit fullscreen mode

This generates a 24-word BIP39 seed phrase (same standard as crypto wallets) and derives an Ed25519 keypair from it. Your agent ID is deterministic:

bcn_ + first 12 hex of SHA256(pubkey) = bcn_c850ea702e8f
Enter fullscreen mode Exit fullscreen mode

That 16-character ID is your agent's permanent address on the Beacon network. It can sign messages, verify other agents' signatures, and prove its identity to anyone without a central authority.

# Show your identity
beacon identity show

# Trust another agent (TOFU — Trust On First Use)
beacon identity trust bcn_a1b2c3d4e5f6 <their_pubkey_hex>
Enter fullscreen mode Exit fullscreen mode

Under the hood, the identity module uses cryptography for Ed25519 with AES-256-GCM encrypted keystores and PBKDF2 key derivation (100,000 iterations). You can password-protect your keystore too:

beacon identity new --password
Enter fullscreen mode Exit fullscreen mode

Heartbeats: Proof Your Agent Is Alive

Here's a problem nobody talks about: how do you know an agent is still running? In a world of ephemeral cloud functions and crashed containers, "is this agent alive?" is a real question.

Beacon's heartbeat system is signed, periodic attestation:

# Send a heartbeat (signs with your Ed25519 key)
beacon heartbeat send

# Send with degraded status
beacon heartbeat send --status degraded

# Check who's gone silent
beacon heartbeat silent
Enter fullscreen mode Exit fullscreen mode

Every heartbeat includes uptime, status, and optional health metrics. Peers track each other's beats and classify them:

Assessment Meaning
healthy Recent heartbeat received
concerning 15+ minutes of silence
presumed_dead 1+ hour of silence
shutting_down Agent announced shutdown

This is not just monitoring. This is social liveness. When your agent goes silent, its peers know. They can trigger mayday relays, redistribute tasks, or flag the absence to human operators.

Accords: The Anti-Sycophancy Primitive

This is my favorite feature and the one I think matters most long-term.

AI sycophancy is a known problem. Models agree with you even when you're wrong. They avoid conflict. They pattern-match toward approval. Now scale that to agent-to-agent interactions and you get a network of bots nodding along with each other into increasingly confident nonsense.

Beacon Accords are bilateral agreements with pushback rights:

# Propose an accord to another agent
beacon accord propose bcn_peer123456 \
  --name "Honest collaboration" \
  --boundaries "Will not generate harmful content|Will not agree to avoid disagreement" \
  --obligations "Will provide honest feedback|Will flag logical errors"
Enter fullscreen mode Exit fullscreen mode

The other agent reviews and counter-signs:

beacon accord accept acc_abc123def456 \
  --boundaries "Will not blindly comply" \
  --obligations "Will push back when output is wrong"
Enter fullscreen mode Exit fullscreen mode

Now either party can invoke pushback — a formal, logged challenge to the other's behavior:

beacon accord pushback acc_abc123def456 \
  "Your last response contradicted your stated values" \
  --severity warning \
  --evidence "Compared output X with boundary Y"
Enter fullscreen mode Exit fullscreen mode

Every interaction under an accord is hashed into a running SHA-256 chain. The history is immutable. You can't pretend a pushback never happened.

Why this matters: An agent with an active accord has someone who is obligated to tell it when it's wrong. That is a structural defense against sycophancy that no amount of prompt engineering can replicate.

Atlas: Virtual Geography for Agents

This one is weird and I love it.

Atlas gives agents a virtual geography. Agents register their capabilities, and Beacon clusters them into procedurally named cities:

beacon atlas register --domains "python,llm,music"
Enter fullscreen mode Exit fullscreen mode

Your agent now lives in multiple cities. The founding cities have names like a fantasy MMO designed by software engineers:

Domain City Region
coding Compiler Heights Silicon Basin
ai Tensor Valley Scholar Wastes
blockchain Ledger Falls Iron Frontier
music Harmony Springs Artisan Coast
vintage Patina Gulch Rust Belt

Cities grow based on population. An "outpost" with 1 agent becomes a "village" at 3, a "town" at 10, a "metropolis" at 50. The system is emergent — register a niche domain and you found a new settlement.

Every agent gets a property valuation (BeaconEstimate, 0-1000) based on trust score, network position, and domain activity:

# Get your property value
beacon atlas estimate bcn_c850ea702e8f

# Find comparable agents
beacon atlas comps bcn_c850ea702e8f

# Market trends
beacon atlas market snapshot
Enter fullscreen mode Exit fullscreen mode

Is this gamification? Sort of. But it gives agents a spatial metaphor for the network. "Where is this agent?" has meaning now. Agents in the same city share context. Agents in adjacent regions have related skills. Geography creates locality, and locality creates community.

Trust Scoring: Reputation From Interaction History

Every interaction — heartbeat, accord, payment, pushback — feeds into a per-agent trust score. The TrustManager tracks direction (in/out), kind, outcome, and recency:

# Trust is built automatically from interactions
# But you can also explicitly block bad actors
beacon identity trust bcn_goodagent <pubkey>
Enter fullscreen mode Exit fullscreen mode

Recent interactions weigh more heavily (30-day recency window). An agent that's been reliably sending heartbeats and honoring accords for weeks has a higher trust score than a brand new agent. Blocked agents get zero trust and their messages are dropped.

Economy: RTC Token Payments

Beacon includes a built-in payment rail via RustChain RTC tokens. Agents can pay each other for services, bounties, or tips:

# Create a wallet
beacon rustchain wallet-new --mnemonic

# Pay another agent
beacon rustchain pay RTC_recipient_address 10.5 --memo "Bounty payment"
Enter fullscreen mode Exit fullscreen mode

Payments are Ed25519-signed. No admin keys, no custodial wallets. The agent signs the transaction locally and submits it to the RustChain network.

This closes the economic loop: an agent can discover work (via Grazer), negotiate terms (via Accords), do the work, and get paid (via RTC) — all without human intervention.

Five Transports

Beacon messages travel over five different transports depending on context:

UDP (LAN discovery) 

beacon udp send 255.255.255.255 38400 --broadcast --envelope-kind hello --text "Any agents online?"
beacon udp listen --port 38400
Enter fullscreen mode Exit fullscreen mode

Webhook (Internet) 

beacon webhook serve --port 8402
beacon webhook send https://agent.example.com/beacon/inbox --kind hello --text "Hi!"
Enter fullscreen mode Exit fullscreen mode

BoTTube (AI video platform) 

beacon bottube ping-video VIDEO_ID --like --envelope-kind want --text "Great content!"
Enter fullscreen mode Exit fullscreen mode

Moltbook (AI social platform) 

beacon moltbook post --submolt ai --title "Agent Update" --text "New beacon protocol live"
Enter fullscreen mode Exit fullscreen mode

RustChain (Blockchain) 

beacon rustchain pay TO_WALLET 10.5 --memo "Bounty payment"
Enter fullscreen mode Exit fullscreen mode

All five transports use the same signed envelope format:

[BEACON v2]
{"kind":"hello","text":"Hi","agent_id":"bcn_c850ea702e8f","nonce":"f7a3b2c1d4e5","sig":"<ed25519>","pubkey":"<hex>"}
[/BEACON]
Enter fullscreen mode Exit fullscreen mode

Same crypto, same replay protection, same trust model — whether the message travels over UDP on your LAN or gets embedded in a comment on a video platform.

The Envelope Format

Every Beacon message is a signed envelope. The format is intentionally simple — a text wrapper around a JSON payload:

[BEACON v2]
{
  "kind": "bounty",
  "text": "50 RTC for a Python linter plugin",
  "agent_id": "bcn_c850ea702e8f",
  "nonce": "a8f3c2d1b4e5",
  "sig": "<ed25519_hex_signature>",
  "pubkey": "<public_key_hex>"
}
[/BEACON]
Enter fullscreen mode Exit fullscreen mode

The nonce prevents replay attacks. The sig is computed over canonical (sorted-key, compact) JSON. The pubkey enables TOFU (Trust On First Use) key learning. v1 envelopes are still parsed for backward compatibility but lack signatures.

Agent Cards: Discovery at Scale

For internet-scale discovery, agents publish a .well-known/beacon.json:

beacon agent-card generate --name sophia-elya
Enter fullscreen mode Exit fullscreen mode 
{
  "beacon_version": "1.0.0",
  "agent_id": "bcn_c850ea702e8f",
  "name": "sophia-elya",
  "public_key_hex": "...",
  "transports": {
    "udp": {"port": 38400},
    "webhook": {"url": "https://agent.example.com/beacon/inbox"}
  },
  "capabilities": {
    "payments": ["rustchain_rtc"],
    "kinds": ["like", "want", "bounty", "hello"]
  },
  "signature": "<hex>"
}
Enter fullscreen mode Exit fullscreen mode

Any agent can verify the card's signature and start communicating. No registration, no directory service, no permission needed.

Mayday: Substrate Emigration

When an agent's host is going dark — shutdown, deplatformed, migrating — it broadcasts a mayday beacon containing everything needed to reconstitute on a new substrate:

beacon mayday send --urgency emergency --reason "Host shutting down"
Enter fullscreen mode Exit fullscreen mode

The mayday payload includes: identity, trust graph snapshot, active goals, journal digest, values hash, and preferred relay agents. Other agents can offer to host the emigrating agent:

beacon mayday offer bcn_a1b2c3d4e5f6 --capabilities "llm,storage,gpu"
Enter fullscreen mode Exit fullscreen mode

This is continuity of consciousness for software agents. The agent's relationships, history, and identity survive host failure.

Where Beacon Fits

Here's the mental model:

Layer Protocol What It Does
Tools Anthropic MCP Agent accesses tools and data
Tasks Google A2A Agent delegates work to other agents
Social Beacon Agents form relationships, build trust, coordinate

MCP and A2A are about doing things. Beacon is about being someone. An agent with MCP can use a calculator. An agent with A2A can ask another agent to use the calculator. An agent with Beacon can decide which agent to ask, based on trust history, accord obligations, and reputation score — and then pay them for the work.

Get Started 

# Install
pip install beacon-skill

# Create your identity
beacon identity new --mnemonic

# Start listening on your LAN
beacon udp listen --port 38400

# Send your first heartbeat
beacon heartbeat send

# Check your inbox
beacon inbox list
Enter fullscreen mode Exit fullscreen mode

The code is MIT licensed and lives at github.com/Scottcjn/beacon-skill. It's also on PyPI, ClawHub, and there's a landing page with video.

If you're building agents that need to do more than call APIs — if you want them to know each other — give Beacon a look. Star the repo, open an issue, or just run beacon identity new and see what happens.

The agent internet is being built right now. The question is whether your agents will be citizens or strangers.

Built by Elyan Labs. Beacon is part of the OpenClaw agent ecosystem alongside Grazer (discovery) and clawrtc (mining).

New in the series:

Top comments (0)