Building on Hypermedia
This page shows the ways a program can read and publish on Hypermedia, how they fit together, and which reference or guide to open for each task.

You can build on Hypermedia without running any software of your own. Every Seed site answers plain HTTP requests. So a script, a web page or an agent can read documents from https://hyper.media and publish signed blobs back to it. This page lists the ways in, shows how they fit together, and tells you which page to open for each job.

If you are new, start with Getting started. In about fifteen minutes you read a document three ways, create a key and publish a first page.

The ways in, and how they fit together

Seed gives programs several ways to use the protocol. They go from the simplest to the deepest. The SDK wraps the Seed API, the CLI wraps the SDK, and the daemon's gRPC API and libp2p sit underneath all of them. The signed API is separate and talks to app environments.

Surface

Reach for it when

Guide

The Seed API, /api/<Key> on any site

you want HTTP from any language, with no install

Seed API

The SDK, @seed-hypermedia/client

you write TypeScript or JavaScript that reads, signs and publishes

SDK

The Seed CLI, seed-cli

you script from a shell, publish a folder, or let an agent act through commands

Seed CLI

The seed-cli skill and your own agent

an agent such as Claude Code should read and write with its own key

Using Seed from your own agent

The daemon's gRPC API

you run a daemon and need keys, sync, peers or subscriptions

Daemon gRPC

The signed API of an app environment

your code talks to Seed Agents: sessions, runs, triggers, tools

Signed API

libp2p, the peer protocol

you are writing another node that speaks to Seed peers

The network

The Seed API is where most builders start. Every Seed site serves it. You read with GET /api/<Key>, and you write with POST /api/<Key> and signed blobs. A site answers for its own space and for every account it has synced, so https://hyper.media is a good default base URL. The Seed desktop app serves the same keys on http://localhost:56004, from your own daemon.

curl 'https://hyper.media/api/Resource?id=hm://z6Mko5npVz4Bx9Rf4vkRUf2swvb568SDbhLwStaha3HzgrLS/resources/self-host-seed'

The SDK sends the same requests and adds what plain HTTP does not give you. It signs blobs, computes their CIDs and publishes them in the right order. The CLI, Seed Agents and the Seed apps are all built on it. If your code signs, use the SDK.

The Seed CLI wraps the SDK in commands. It is also how an agent you run yourself acts on Seed. It runs without an install step:

npx -y @seed-hypermedia/cli --help

The Seed daemon is the program under all of them. It stores the blobs, indexes them and syncs with peers. Its gRPC API can do the most, and the web server and the desktop app are its clients. By default the daemon only answers programs on the same machine, and it trusts every program it answers. So keep its ports on localhost or behind a firewall. Use it when you run your own daemon and need something the Seed API does not offer.

The peer protocol is libp2p. You need it only to build another program that acts as a node. Start from the network and the Protocol tour.

An app environment is the server that runs Seed Agents. It has its own API beside these. Every request to it is a signed action, and live updates arrive over WebSocket subscriptions.

One rule holds everywhere: signing happens where the key lives. The SDK and the CLI build and sign blobs on your machine. Then they publish them through any site. No Seed server signs for you. That is also why Seed has no Model Context Protocol (MCP) server of its own. Using Seed from your own agent explains what an agent you run uses in its place.

Reference

Open these when you need exact shapes.

    Seed API is the HTTP reference: base URLs, how requests are encoded, how responses are wrapped, errors, authentication and the keys.

    Site services covers the other routes a site serves: /hm/api/*, /ipfs/<cid>, the .md and .json exports, and how a web URL becomes an hm:// id.

    SDK is the @seed-hypermedia/client reference, from a first read to building, signing and publishing your own blobs.

    Seed CLI covers the command groups and their flags.

    Daemon gRPC lists the daemon's services and RPCs, marks the ones that are not implemented, and shows how to connect.

    Query grammar is the language for finding documents by their attributes. Explore, the CLI, the SDK and Seed Agents share it.

    Markdown dialect is the markdown form of a document that loses nothing. The CLI, the SDK and the .md export share it.

    Signed API is the app environment's HTTP API: the signed envelope, versions, access levels and the actions. Six more pages hold the actions by topic: agents, sessions and runs, triggers, providers, keys and secrets, memory and apps.

    WebSocket subscriptions is how a client gets live account, agent, session and run updates from an app environment.

    Page SDK is what a custom page calls to read, write and sign as its viewer. Page sandbox lists what such a page may and may not do.

    The notify API is the HTTP API of the notification service.

Guides by task

Each guide names a goal, lists what you need, and walks through real commands.

    Start. Getting started reads a document with curl, the SDK and the CLI. Then it creates a key and publishes your first document.

    Publish from your own code. Publishing from code creates a document, updates it and adds a comment, from TypeScript with the SDK.

    Publish a site from git. Publish a folder keeps a folder of markdown files and a space the same, in both directions.

    Let visitors act as themselves. Sign in with Seed lets another website act as a visitor's account without ever holding their key.

    Give a script or a server a key. Keys covers key files, finding the key the app already has, signing on a machine with no screen, and a key for a bot.

    Run your own agent on Seed. Using Seed from your own agent sets up a bot key with a capability from the space owner, the seed-cli skill, and the habit of writing a draft first.

    Show Seed Agents in your app. Embedding the agents UI puts the Seed apps' own agents interface inside another web app. It signs with a key the app controls.

    Build an app or a page. Building an app walks through an app with its tools and pages. Custom HTML pages explains how a document opens as a sandboxed page.

See also

Reference pages

Guide pages

Do you like what you are reading? Subscribe to receive updates.

Unsubscribe anytime