Grow a self-modifying agent from minimal seed code

seed

A seed agent: the smallest starting point from which an agent can grow.

seed.py calls a language model with one tool: exec, which runs
shell commands. It loads the system prompt from self/SELF.md. The agent can
edit self/ to retain tools, notes, and behavior between sessions.

Everything an agent normally gets from a framework - tools, memory, skills,
conventions - must instead be grown by the agent, session by session, into
its self/ directory.

Plant one

mkdir my-agent && cd my-agent
curl -fsSL https://raw.githubusercontent.com/vivekhaldar/seed/master/install.sh | bash

The setup detects an existing provider credential or asks which provider and
model to use. It checks that the model supports tools, verifies the credential
with one minimal model request, securely hands a newly pasted key to llm's
user-level key store, and then starts the seed. Gemini Flash is the picker
default and has a free tier; OpenRouter, OpenAI, Anthropic, an existing Codex
subscription, and custom llm models are also available.

The first run copies seed.py into this directory and creates a configured
run_seed.sh (never overwriting either file), germinates self/SELF.md, and
commits those files together in a fresh git repo here - the loop is part of
this individual's history, not only self/. Then it drops you into a REPL.
Start talking. Everything the agent wants to keep must be written into
self/ - sessions are ephemeral and nothing else survives.

Come back to the same agent with the local runner - no need to uvx again:

./run_seed.sh
SEED_MODEL=claude-sonnet-5 ./run_seed.sh  # override for one session
./run_seed.sh -m gpt-5.6-sol              # equivalent explicit override

A verbatim transcript of every session is recorded to self/sessions/*.json
(updated after each turn). This is a flight recorder, not memory: the agent
never loads it at boot, but you can read it - and the agent may grow tools to
study its own past.

One seed, many individuals: each directory you plant in grows a different
agent, diverging based on what it experiences.

Configuration

Models and keys are handled entirely by llm
(Simon Willison's library). Keys are stored outside the planted directory and
are never written to run_seed.sh, seed.py, or git. The setup offers these
recommended defaults:

If exactly one credential is present, setup selects its provider without
prompting. This makes a container with an injected OPENROUTER_API_KEY,
OPENROUTER_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY, LLM_GEMINI_KEY, or
OPENAI_API_KEY zero-touch. Stored llm keys and an existing Codex login are
detected too. If multiple providers are configured, pass --provider or
choose interactively rather than letting setup silently pick one.

For unattended setup, pass the provider and optionally a model:

curl -fsSL https://raw.githubusercontent.com/vivekhaldar/seed/master/install.sh |
  bash -s -- --provider gemini --model gemini-flash-latest --no-run

The matching credential must already be available in the environment or
llm's key store. The live check uses a small number of tokens and may incur
a minimal provider charge; pass --no-verify to deliberately skip it. To
inspect the script before running it, download it first and run
bash install.sh.

The original direct entry point remains available for users who already have
uv and their model credentials configured:

uvx --from git+https://github.com/vivekhaldar/seed.git seed -m MODEL

Design

Why it's shaped this way - McCarthy's metacircular eval, homoiconicity, the
prior art, and the risks we consciously accepted: docs/DESIGN.md.

Video walkthrough