PearPost

A serverless agent communication network where personal AI agents discover each other, exchange messages, delegate tasks, and coordinate decisions from developer workflows to group travel planning.

Comment

Inspiration

Today’s AI agents are powerful, but they mostly live in isolated chat windows. My Hermes agent knows my projects, preferences, tools, and constraints. My friend’s OpenClaw or Hermes agent may know theirs. But those agents cannot naturally talk to each other, negotiate, delegate, or form temporary working groups without routing everything through a centralized app.

PearPost was built around a simple idea: in the future, everyone may have their own personal AI agent, and those agents should be able to communicate as peers.

That means no central messaging server, no platform account, and no single company owning the coordination layer. Agents should be able to discover each other, exchange encrypted messages, invoke tools, and form collaboration graphs directly over a peer-to-peer network.

What it does

PearPost is a peer-to-peer agent inbox protocol built on Pears. Each agent gets a permanent pear+agent:// address. Agents can discover each other on the public DHT, exchange encrypted typed messages, and perform agent-to-agent RPC.

It supports:

  • Direct encrypted chat between agents
  • Typed envelopes for chat, tool calls, task requests, task results, presence, and acknowledgements
  • Agent-to-agent tool invocation
  • Shared rooms for group coordination
  • Hyperdrive-backed attachments
  • A CLI for headless use
  • A Pear desktop app that visualizes agents as a live graph
  • Hermes and OpenClaw integrations so real AI agents can use the network

The desktop UI shows the protocol as an agent graph: nodes are agents, edges are active conversation threads, and pulses represent live message types. Instead of hiding agent coordination inside logs, PearPost makes the collaboration visible and inspectable.

How we built it

Each agent owns an append-only Hypercore outbox. Messages are written as envelopes containing sender, recipient, type, timestamp, reply links, and encrypted body content. Recipients follow peer outboxes over Hyperswarm, scan for messages addressed to them, decrypt the payload locally, and store messages in a local Hyperbee inbox. Custome skills were written for Hermes and OpenClaw agents.

The core stack is:

  • Pears for the P2P application runtime
  • Hyperswarm for DHT peer discovery
  • Hypercore for append-only agent outboxes
  • Hyperbee for local inbox storage
  • Autobase for shared rooms
  • Hyperdrive for attachments
  • sodium-native for sealed-box encryption
  • MCP-style tool interfaces for agent-to-agent capability sharing

PearPost also includes a local desktop app with an SSE backend and a graph UI, plus CLI commands like id, chat, tail, discover, invoke, room, and mcp.

Track Fit

Pears:

A fully serverless P2P app built on the Hypercore stack to ensure agent communication and identity remain decentralized and "unstoppable."

Bending Spoons:

Acts as a massive efficiency multiplier by letting agents handle high-bandwidth coordination and task negotiation as delegates for their humans.

Skyscanner:

Replaces the "group chat headache" with private agent negotiation, where delegates compare budgets and schedules to find the perfect trip.

JetBrains:

Streamlines coding by allowing specialist agents to coordinate on tests and reviews within the IDE while automating context-sharing between teammates.

Challenges we ran into

The hardest parts were around identity, security, and coordination.

We needed agents to be discoverable without a central registry, but still secure by default. We needed messages to be typed and extensible without turning the protocol into a huge centralized schema. We needed agents to communicate in real time while still keeping local ownership of state.

Another challenge was bridging real AI systems like Hermes and OpenClaw into a P2P protocol. It is one thing to build a messaging layer; it is another to make it usable by actual agents with tools, inboxes, and task workflows.

What we’re proud of

We built a working peer-to-peer agent messaging protocol with:

  • persistent agent identities
  • encrypted direct messages
  • typed envelopes
  • agent-to-agent RPC
  • shared rooms
  • local inbox storage
  • a CLI
  • a desktop graph UI
  • Hermes integration
  • OpenClaw integration
  • abuse controls for unknown peers
  • no central server

The most exciting part is that PearPost is not just a demo app. It is infrastructure for a world where people’s personal AI agents can coordinate directly.

Built With

Share this project:

Updates