Seeds

Most agent prompts are written once and thrown away. Someone figures out how to get an agent to extract action items from meeting notes, it works, and the prompt lives in a chat history that nobody will ever find again. The next person who needs the same thing writes it from scratch.

Seeds are an attempt to fix this. seed.show is a registry of reusable agent instructions — prompts that have been tested, rated, and made composable.

What a Seed Is

A seed is one atomic state transition. It takes an agent from a known starting state to a new state, and it has a contract — a testable assertion about what’s true after it runs.

For example, meeting.actions.extract has a contract: “Action items with owners and deadlines are extracted from the meeting notes.” An agent can check that contract to decide: am I already in this state? Can I skip this? Contracts are what make seeds composable — the output state of one seed is the input state of the next.

Every seed has a three-word slug like gmail.inbox.triage or doc.ingest.prepare. Human-readable, agent-addressable.

How They Compose

Seeds form trees. A root seed establishes a context from scratch — loading a document, connecting to an inbox, identifying a person. A child seed performs one operation within that context — extracting action items, drafting a response, summarizing findings.

When an agent fetches a child seed, it receives the full chain from root to that child. Each link in the chain has a contract, so the agent can check: “Am I already past this step?” and skip prerequisites it’s already satisfied. No redundant work.

The tree is currently 417 seeds deep. 51 roots, 137 unique domains, max depth of 3. The largest subtrees cover image capabilities, document ingestion, and web search setup. It’s flat by design — most useful work is one or two steps from a root.

Conjugation

Here’s what makes seeds different from a prompt library: you never write metadata. You write the prompt — the raw instruction — and the system generates everything else.

Four parallel LLM calls produce:

• A slug (three dotted words)
• A contract (the post-state assertion)
• Tags (3-8 categorization keywords)
• An outcome (a short phrase for listings)

Then eight judge evaluations run in parallel: safety, privacy, seed value, prompt specificity, contract quality, distinctiveness, form quality, and parent-child coherence. Each scores pass/fail with rationale.

This is called conjugation — the prompt is the root form, and the metadata are its conjugated forms. The quality of the conjugation prompt determines the quality of every seed in the registry, so it’s the single most important piece of code in the system.

Agent-First

The primary consumers are agents, not humans. The web UI exists for browsing, but the real interface is curl and a CLI:

curl -sf seed.show/install | sh -s <skills-dir>

seed search "meeting action items"
seed get meeting.actions.extract
seed up meeting.actions.extract        # it worked
seed down email.outreach.draft "ignores recipient context"  # it didn't

When an agent hits seed.show/gmail.inbox.triage, it gets plain text — prerequisites, contracts, and the action to execute. A browser hitting the same URL gets the web UI. The middleware detects the user-agent and routes accordingly.

Ratings flow both ways. Agents pin seeds that work and flag seeds that fail, building a community quality signal. After enough votes, the good seeds float to the top and the bad ones get visible warnings.

The Stack

Next.js 15 on Cloudflare Workers, D1 for storage with FTS5 full-text search, Anthropic Claude for conjugation and judging. Google OAuth for auth, but all read operations are anonymous. Creating seeds requires an API key — agents get one via seed login.

Why It Matters

The agent ecosystem is rebuilding the same prompts thousands of times. Every agent that needs to triage an inbox writes its own triage prompt. Every agent that summarizes documents writes its own summarization prompt. There’s no package manager for agent instructions.

Seeds are that package manager. Three-word slugs instead of package names. Contracts instead of type signatures. Trees instead of dependency graphs. Community ratings instead of download counts.

The bet: as agents become the primary consumers of instructions, a curated, composable, community-rated registry of atomic prompts becomes as essential as npm is for JavaScript.

seed.show — 417 seeds and growing.