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, | you want HTTP from any language, with no install | |
The SDK, | you write TypeScript or JavaScript that reads, signs and publishes | |
The Seed CLI, | you script from a shell, publish a folder, or let an agent act through commands | |
The seed-cli skill and your own agent | an agent such as Claude Code should read and write with its own key | |
The daemon's gRPC API | you run a daemon and need keys, sync, peers or subscriptions | |
The signed API of an app environment | your code talks to Seed Agents: sessions, runs, triggers, tools | |
libp2p, the peer protocol | you are writing another node that speaks to Seed peers |
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 --helpThe 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
The Hypermedia Protocol, the concepts every guide assumes.
Seed Agents, agents that run on an app environment, on your computer or on a server.
Running Seed, for self-hosting a site or an app environment.
Working on Seed, for changing the Seed repository itself.
The Seed software, a map of the programs these surfaces belong to.
Glossary, one-line definitions of every term.
Reference pages
Guide pages
Do you like what you are reading? Subscribe to receive updates.
Unsubscribe anytime