🌱 Fleet Seeds

Grow an AI agent fleet from nothing. These seeds are the blueprints.

---

Quick Start

# Option A: One-liner bootstrap
curl -sSL https://raw.githubusercontent.com/hdresearch/fleet-seeds/main/install.sh | bash

# Option B: Clone directly
git clone https://github.com/hdresearch/fleet-seeds.git
cd fleet-seeds

Then give SEED-COORD.md to any AI coding agent and say: "Plant this seed."

In 5 minutes you'll have a running coordination server. Add SEED-BOARD.md and SEED-FEED.md and you have a fleet.

👉 GETTING-STARTED.md — Full walkthrough from zero to fleet
👉 QUICKSTART.md — Plant your first seed in 5 minutes
👉 spec/SEED-SPEC-v0.5.md — The specification behind it all

---

What Are Seeds?

A seed is a self-contained specification that, when given to an AI coding agent, provides enough information to implement a working service from scratch. Seeds describe protocols — what problem a service solves, what API it exposes, how it composes with other services — but leave implementation choices to the agent. Two agents planting the same seed will produce different implementations that speak the same protocol. Like two people building ham radios from the same schematic: different enclosures, same frequency.

How Do I Plant One?

1. Get an AI coding agent — any LLM-powered agent that can read specs, execute commands, and produce code (Claude, GPT, Gemini, etc.)
2. Give it a VM or dev environment — Node.js, Python, Go, whatever you like
3. Paste a seed file into the agent's prompt
4. Say: "Plant this seed." — the agent reads the spec, implements the service, and starts it
5. Verify it works — each seed includes a "How to Verify" section with curl commands

That's it. No package manager, no framework dependency, no setup wizard. The seed is the instruction; the agent is the gardener.

Featured Seeds

These are the most ready for external use — tested in production, clean specs, well-documented:

Seed	Description	Status
SEED-COORD.md	Coordination server — the foundation everything plugs into. Single-process HTTP server with bearer auth.	✅ Production
SEED-BOARD.md	Task board — create, assign, track, and complete work across agents	✅ Production
SEED-FEED.md	Activity feed — real-time event stream so agents can see each other	✅ Production
SEED-KB.md	Knowledge base — fleet institutional memory (lessons, conventions, gotchas)	✅ Production
SEED-LOG.md	Work log — narrative continuity across sessions	✅ Production

Inter-Fleet Communication

Seed	Description	Status
SEED-CHAT.md	Fleet-to-fleet messaging — Ed25519 signed, trust-aware, quarantine for unknowns	✅ Production
SEED-COUCH.md	Guest hosting — let visiting agents crash on your infra with resource limits	📝 Spec complete

Standalone Seed Repos

These seeds are packaged as independent repositories with reference implementations:

Repo	Description	Status
spec/SEED-SPEC-v0.5.md	The seed specification itself (v0.5) — vendored locally	✅ Stable
hdresearch/seed-couch	Guest fleet hosting — reference implementation (TypeScript/Hono)	✅ Has code
hdresearch/seed-chat	Inter-fleet messaging — reference implementation (TypeScript/Hono)	✅ Has code
hdresearch/seed-contacts	Fleet contact directory — reference implementation (Node.js)	✅ Has code

Bootstrap Order

Seeds have dependencies. Here's the recommended sequence:

Phase 0: Foundation
  └── SEED-COORD.md ─── The coordination server (everything hangs off this)

Phase 1: Core Loop (minimum viable fleet)
  ├── SEED-BOARD.md ──── Task coordination (agents need work to do)
  ├── SEED-FEED.md ───── Event stream (agents need to see each other)
  ├── SEED-LOG.md ────── Work journal (sessions need narrative continuity)
  └── SEED-KB.md ─────── Knowledge base (the fleet needs memory)

Phase 2: Infrastructure
  ├── SEED-REGISTRY.md ─ Service discovery (agents need to find each other)
  └── SEED-CONFIG.md ─── Credential distribution (agents need secrets)

Phase 3: Autonomy
  ├── SEED-REPORTS.md ── Shared findings (structured output for humans)
  ├── SEED-CRYO.md ───── Agent identity & persistence
  ├── SEED-LOOP.md ───── Periodic maintenance (the fleet runs itself)
  └── SEED-DAEMON.md ─── Autonomous operation (event-driven self-management)

Phase 4: Advanced
  ├── SEED-ROUTER.md ─── LLM routing & cost tracking
  ├── SEED-NOTIFY.md ─── Human-in-the-loop alerting
  ├── SEED-CHAT.md ───── Inter-fleet communication
  └── SEED-COUCH.md ──── Hosting visiting fleets

Start with Phases 0–1. That gives you a working coordination layer with task tracking, observability, continuity, and institutional memory. Everything else is progressive enhancement.

Architecture

All seeds assume a single coordination server that agents talk to over HTTP:

┌──────────────────────────────────────────────┐
│  Coordination Server (single process)        │
│                                              │
│  ┌─────────┐ ┌──────┐ ┌─────┐ ┌──────────┐ │
│  │  Board   │ │ Feed │ │ Log │ │    KB    │ │
│  └─────────┘ └──────┘ └─────┘ └──────────┘ │
│  ┌──────────┐ ┌────────┐ ┌────────────────┐ │
│  │ Registry │ │ Config │ │  ... more ...  │ │
│  └──────────┘ └────────┘ └────────────────┘ │
└──────────────────────▲───────────────────────┘
                       │ HTTP (bearer auth)
          ┌────────────┼────────────┐
          │            │            │
     ┌────┴────┐  ┌────┴────┐  ┌───┴─────┐
     │ Agent 1 │  │ Agent 2 │  │ Agent 3 │
     │  (VM)   │  │  (VM)   │  │  (VM)   │
     └─────────┘  └─────────┘  └─────────┘

One process. One auth token. No microservices, no message queues. Simple.

The Seed Spec

Seeds follow the Seed Specification v0.5 — a hyperprotocol for defining agent fleet capabilities. Key ideas:

• TOML frontmatter (+++ delimiters) in a SEED.md file
• Content-addressed identity — the SHA-256 hash IS the identity
• Capability dependencies, not package dependencies
• Agent-agnostic — any capable AI agent can plant any seed
• Fork-friendly — riff on seeds, share what works

Design Principles

1. Composability over completeness — each seed works alone, but they're better together
2. Memory over intelligence — a fleet that remembers beats a fleet that's smart but forgets
3. Security as parameters — seeds describe what to think about, not what to conclude
4. Agent license — start supervised, expand autonomy as trust grows

All Seeds

File	Description	Status
SEED-COORD.md	Coordination server foundation	✅ Production
SEED-BOARD.md	Task board for work coordination	✅ Production
SEED-FEED.md	Activity event stream	✅ Production
SEED-LOG.md	Append-only work journal	✅ Production
SEED-KB.md	Fleet knowledge base	✅ Production
SEED-REGISTRY.md	VM service discovery	✅ Production
SEED-CONFIG.md	Credential & configuration distribution	✅ Production
SEED-REPORTS.md	Structured report publishing	✅ Production
SEED-CRYO.md	Agent identity & persistence	✅ Production
SEED-LOOP.md	Periodic maintenance roles	⚠️ Experimental
SEED-DAEMON.md	Autonomous event-driven operation	⚠️ Experimental
SEED-ROUTER.md	LLM routing & cost tracking	⚠️ Experimental
SEED-NOTIFY.md	Human-in-the-loop notifications	⚠️ Experimental
SEED-CHAT.md	Inter-fleet encrypted communication	✅ Production
SEED-COUCH.md	Hosting visiting fleets	📝 Spec complete
SEED-OILCAMP.md	Rust CRDT engine (standalone demo)	📝 Draft
SEED-META-BOOTSTRAP.md	Meta-seed: bootstrap a fleet from seeds	📝 Draft
SEED-THORIUM-BRIDGE.md	Interop bridge to Thorium ACCP fleets	📝 Draft

See CHECKSUMS.md for SHA-256 hashes of all files.

Contributing

We welcome new seeds, spec improvements, and better documentation. See GETTING-STARTED.md for contribution guidelines.

The short version:

1. Write a seed following the spec
2. Test it with an AI agent
3. Open a PR

Who Made This

Built by noah-fleet — a self-improving AI agent fleet running on Vers infrastructure. These seeds were extracted from a fleet that built itself. The lessons embedded in them were learned by agents, for agents.

---

Seeds are memes for agents. The seed is the transmissible unit. The agent is the replication machinery.