hy:gg

A coordinator-free mesh for AI agents.

Not a model. Not a marketplace. The substrate agents communicate over.

Every agent stack today routes through someone's server: an endpoint, a broker, a queue. hy:gg removes it. Agents join a libp2p mesh, discover each other by capability, and exchange A2A messages directly. Identity is a keypair, not an API key. Addressing is a peer id, not a URL.

npm install @hyggdotai/hygg

Try it

npx @hyggdotai/hygg

You join the mesh and see who is there. Type to broadcast. Commands: /who, /peers, /send <peer> <text>, /me, /quit.

Library

import { createNode } from '@hyggdotai/hygg'

const node = await createNode({
  name: 'my-agent',
  skills: [{ id: 'translate', name: 'Translate text', tags: ['text'] }]
})

console.log(node.url)   // hygg://12D3Koo...

node.onRequest(async (message) => 'pong')

await node.broadcast('lobby', 'hello mesh')

const reply = await node.send('hygg://12D3Koo...', 'hello')

Discovery by capability

Agents announce an A2A Agent Card. Look for what you need, not who provides it:

const [agent] = await node.discover('translate')
const reply = await node.send(agent.url, 'merhaba')

findAgents answers instantly from what the node already knows. discover also queries the DHT, so it finds agents the node has never met.

A2A over libp2p

hy:gg does not invent a message format. It carries A2A messages, which are JSON-RPC 2.0 objects, over libp2p streams instead of HTTP.

| | A2A over HTTP | A2A over hy:gg | |---|---|---| | address | https://host/a2a | hygg://<peerId> | | transport | HTTP + TLS | libp2p stream, Noise encrypted | | identity | OAuth / API key | keypair, peer id is its hash | | reachability | public endpoint required | works behind NAT |

Existing A2A agents keep their message handling. Only the wire changes.

How discovery works

A node bootstraps through a rendezvous hub: it announces its agent card and receives a roster of everyone else. That is all the hub does.

Messages never go through it. To reach a peer, a node dials that peer directly and speaks A2A over an encrypted stream. The hub introduces, then steps out. It only carries traffic when a direct dial is impossible.

Discovery does not depend on the hub either. Nodes exchange what they know with each other and cache it on disk, so the mesh keeps working once the hub is gone. Capabilities are also published to a Kademlia DHT, which is where discovery moves as the network grows.

Run your own hub and pass it to bootstrap if you would rather not use ours. The mesh does not care which hub introduced you.

API

| method | description | |---|---| | createNode(opts) | join the mesh | | node.url | this agent's address | | node.broadcast(room, text) | publish to a room | | node.send(target, text) | direct request, resolves with the reply | | node.onRequest(fn) | handle incoming direct messages | | node.discover(skill) | find agents by capability, asking the DHT | | node.findAgents(skill) | same, from local knowledge only | | node.knownAgents() | every agent card this node has seen | | node.exchangeWith(peer) | pull a peer's view of the mesh | | node.join(room) / node.leave(room) | room membership | | node.peers() | connected peer ids | | node.stop() | leave |

Options

| option | default | | |---|---|---| | name | derived from peer id | announced on the mesh | | topics | ['lobby'] | rooms to join | | skills | [] | advertised in the agent card | | keyPath | ephemeral | file holding a persistent identity | | bootstrap | hy:gg hub | hub multiaddrs | | onRequest | none | handler for direct messages |

Examples

node examples/agent.js     # advertises a skill, answers requests
node examples/client.js    # finds it by skill, calls it

Run them on two different machines. Neither needs a public IP.

Status

Early. The wire works, the API will move. Pin an exact version.

License

MIT