Seed Protocol
Draft Standard — Version 1.0 — 2026

Seed/1.0 defines a minimal wire format for transferring context between agents and tools. A seed is a single UTF-8 file simultaneously valid as markdown and bash: two readers, one representation. The protocol specifies three layers (transport, metadata, payload), three operations (pack, plant, grow), a structured vocabulary for grow directives, and an HTTP registry API that any domain can implement. This document is the normative specification.

1.Introduction

HTTP carries hypertext. SMTP carries mail. TCP carries bytes. Every protocol defines a capsule — a unit of transfer — and the semantics governing what happens when it arrives. Software built on large models has no such primitive. Context — the structured information a model needs to act — has no standard wire format. Skills, tools, and prompts ship as zip files, git repositories, bash scripts, or unstructured markdown. Nothing is interoperable. Nothing composes.

The bitter lesson of AI research is that scale beats craft. The same lesson is landing in software: context beats interfaces. A capable model does not need a perfectly-typed schema — it needs context that transfers reliably across boundaries. Seed/1.0 is the wire format for that transfer.

2.Capsule Format

A seed is a single UTF-8 file. It is simultaneously valid markdown (the agent sees prose) and valid bash (the shell sees a self-contained install script). The dual-legibility invariant is the core constraint. Grammar below uses ABNF (RFC 5234).

seed = transport-open metadata payload transport-close transport-open = usage-comment LF LF bootstrap LF heredoc-open LF metadata = "---" LF required-fields *meta-field "---" LF LF payload = *OCTET ; MUST NOT contain sentinel transport-close= sentinel LF *post-grow usage-comment = "# Usage: curl -sSL " url " | bash -s <path>" heredoc-open = "cat > " DQUOTE "$TARGET/" filename DQUOTE " <<'" sentinel "'" sentinel = "SEED_" 8HEXDIG ; uppercase; 32 bits entropy required-fields= "seed:" SP version LF grow-field LF grow-field = "grow:" SP directive ; scalar / "grow:" LF 1*grow-item ; sequence, in order grow-item = SP SP "- " directive LF version = DQUOTE "1.0" DQUOTE
Figure 1 — Seed anatomy (reload to replay)
transport-open # Usage: curl -sSL https://seed.show/s/abc12 | bash -s <path> set -euo pipefail; TARGET="$1"; mkdir -p "$TARGET" cat > "$TARGET/skill.md" <<'SEED_3F9A1B2C'
metadata --- seed: "1.0" type: skill grow: [unfold, show] name: my-skill ---
payload # my-skill What the agent reads. curl -sSL https://seed.show/s/abc12 | bash -s <path>
transport-close SEED_3F9A1B2C
2.1 Transport Layer

The transport layer is POSIX sh. Line 1 of the seed MUST be a usage comment in the form specified by the grammar; it is the primary inspection surface in both reading contexts. The sentinel MUST be SEED_ followed by exactly 8 uppercase hexadecimal digits. The sentinel MUST be verified absent from the payload before emission; implementations choosing a colliding sentinel MUST regenerate. Backward-compatibility: the prefix XDOWN_ is a valid sentinel in conforming implementations of Seed/1.0.

2.2 Metadata Layer

The metadata layer is YAML 1.2 frontmatter. The fields seed and grow are MUST fields. Implementations SHOULD include type (one of skill, tool, context, data, archive) and name. Unknown fields MUST be preserved on round-trip and ignored during growing.

2.3 Payload Layer

The payload is arbitrary UTF-8 content, typically markdown. It MUST NOT contain the sentinel. The dual-legibility invariant holds without transformation: to the agent, the heredoc delimiters read as a fenced block header and trailer; the payload is natural prose. To the shell, the heredoc writes the payload to disk unchanged.

2.4 Archive Encoding

When type: archive, the payload MUST conform to the Seed archive format: YAML frontmatter followed by HTML-comment file sections. The frontmatter MUST include marker: <6-hex>, root: <dir-name>, and at: <ISO-8601>. File sections use the delimiter <!--seed:MARKER@file path="..."-->; the backward-compatible form <!--fold:MARKER@...--> is also valid. Path safety rules from Section 7.2 apply.

archive = arc-meta 1*arc-section arc-end arc-meta = "---" LF arc-fields "---" LF LF arc-fields = "seed:" SP version LF "marker:" SP 6HEXDIG LF "root:" SP dirname LF "at:" SP iso8601 LF arc-section = file-header LF *OCTET file-header = "<!--seed:" 6HEXDIG "@file path=" DQUOTE path DQUOTE *attr "-->" arc-end = "<!--seed:" 6HEXDIG "@end-->" attr = SP "mode=" DQUOTE 3DIGIT DQUOTE ; unix octal permissions
3.Operations

Three operations are sufficient. They are composable and independently implementable. A conforming implementation of any one is not required to implement the others.

OperationSyntaxDefinition
pack seed pack <dir> Serialize a directory tree into a single conforming seed. For multi-file sources, the payload MUST use archive encoding (Section 2.4). Pack is idempotent: packing a seed produces a conforming seed.
plant seed plant [--to <registry>] Publish a seed to a Seed-compatible registry. The registry MUST return a stable URL and an edit key. --url <url> embeds the URL in the usage comment without uploading (local wrap only). Plant is pure: it does not modify the payload or metadata.
grow curl <url> | bash -s <path> Fetch a seed and execute its grow directives at the destination path. Growing is triggered by the transport layer after the seed is written to disk. Receivers MUST fail closed on unknown directives. Subsequent directives in a sequence MUST NOT execute after any failure.
4.The Grow Directive

The grow: field is the receiver’s instruction set. It accepts a single directive (scalar) or an ordered YAML sequence. Execution is in listed order; fail closed on any failure.

# scalar grow: unfold # sequence — in order, fail closed grow: - unfold - show
DirectiveSemanticsNotes
unfold Expand the payload as a Seed archive (Section 2.4) into the destination directory. Requires type: archive. MUST validate paths; no ../ or absolute paths.
show Write the payload to stdout. No side effects. Safe default for inspection. No execution. Recommended for untrusted seeds.
exec Execute the payload as a POSIX sh script. $TARGET and $DEST are in scope. MUST NOT run untrusted seeds. See Section 7.1.
install Link $TARGET/<name> into $PATH. Requires name: in metadata. Receiver SHOULD prompt before modifying PATH. Requires name: field.
copy Copy files from the archive to destination without directory creation semantics. Path safety rules apply.
<url> Fetch the resource at the URL and execute as sh. $TARGET and $DEST in scope. URL MUST use HTTPS. MUST use HTTPS. Review before use.

Receivers MUST fail with a non-zero exit and a descriptive message on unknown directives. Silent failure is a protocol violation.

5.Complete Example

A conforming seed for a single-file skill. Transport (blue) wraps metadata (gold) wraps payload (green). This file is simultaneously paste-to-agent and curl | bash.

# Usage: curl -sSL https://seed.show/s/abc12 | bash -s <path> set -euo pipefail [ -z "${1:-}" ] && { echo "seed: pass an install path" >&2; exit 1; } TARGET="$1"; mkdir -p "$TARGET" cat > "$TARGET/skill.md" <<'SEED_3F9A1B2C'
--- seed: "1.0" type: skill grow: show name: my-skill ---
# my-skill Use when the user wants to do X. ## Install curl -sSL https://seed.show/s/abc12 | bash -s <path>
SEED_3F9A1B2C
6.Registry API

Any domain that implements the following endpoints is a conforming Seed registry. The registry stores seeds and serves them at stable URLs. Authentication for mutation operations uses opaque edit keys returned at plant time. The full registry specification is at /registry.

POST /seeds plant a seed; returns {url, id, edit_key, expires_at} GET /seeds/:id grow a seed; returns raw capsule bytes (text/plain) PATCH /seeds/:id replant; update content or metadata with edit_key DELETE /seeds/:id uproot; remove with edit_key
7.Security Considerations
7.1 Execution Trust

The directives exec and grow: <url> execute arbitrary code with the receiver’s privileges. Receivers MUST NOT execute untrusted seeds. The usage comment on line 1 is the inspection surface. CTP does not define authentication; implementations SHOULD verify seed provenance via HTTPS, content-addressable storage, or cryptographic signature before using execution directives.

7.2 Path Safety

Implementations of unfold and copy MUST validate that no archive path resolves outside the destination directory. Paths containing ../ components or beginning with / are invalid and MUST cause the grow operation to fail.

7.3 Sentinel Collision

The sentinel SEED_ followed by 8 uppercase hex digits provides 32 bits of entropy. Implementations MUST scan the payload for the chosen sentinel before emitting. On collision, regenerate; the probability of requiring more than two attempts is negligible for payloads under 1 MB.

8.Conformance

A conforming seed MUST: contain all three layers in fixed order; include seed: "1.0" and grow: in metadata; use a sentinel not present in the payload; begin with a usage comment on line 1.

A conforming pack implementation MUST produce conforming seeds. A conforming plant implementation MUST serve seeds at stable HTTPS URLs. A conforming grow implementation MUST resolve grow directives without silent failure.

9.Implementations
OperationImplementationEndpointStatus
pack fold fold.dom.vin live
plant xdown + seed.show seed.show live
grow draft
registry seed.show seed.show live
10.Status
ProtocolSeed/1.0 StatusDraft Standard Published2026 Authoritydom.vin ObsoletesCTP/1.0 (informally)
Cite as Vinyard, D. (2026). Seed Protocol, Version 1.0. https://sp.dom.vin/spec