Seed: Minimal, self-modifying agent harness
github.com
August 21, 2026
2 min read
43/100
Summary
Seed is an open-source agent starter that gives a language model a single exec tool for running shell commands. Its system prompt is loaded from self/SELF.md, and the agent can edit the self/ directory to preserve tools, notes, and behavior across otherwise ephemeral sessions. Rather than receiving a prebuilt framework’s memory, skills, tools, and conventions, each agent develops them over time by writing files into that directory. Running uvx --from git+https://github.com/vivekhaldar/seed.git seed in a new directory copies seed.py and run_seed.sh without overwriting existing files, creates self/SELF.md, initializes a Git repository, and opens a REPL. Each directory becomes a distinct agent whose retained files and Git history reflect its own interactions. The local runner can reopen an existing agent and optionally select a model, including gemini-2.5-pro. Seed records verbatim session transcripts in self/sessions/*.json after every turn, but does not automatically load those transcripts at startup. Model access is managed by Simon Willison’s llm library; the documented default is openai-codex/gpt-5.6-sol using a ChatGPT login through the Codex CLI. Supported providers include OpenAI, Anthropic, Gemini, and OpenRouter.
Key Takeaways
- Seed starts with one shell-command execution tool and lets an agent build persistent capabilities by editing its self/ directory.
- Seed initializes each installed agent in its own Git repository, allowing separate directories to develop independently.
- Session transcripts are saved as JSON files after each turn but are not used as automatic startup memory.
- Seed uses the llm library for model providers and documents OpenAI, Anthropic, Gemini, and OpenRouter support.
What the discussion said
The thread mostly debated whether a tiny, self-modifying agent harness is a useful starting point or merely a familiar autonomous-agent demo with the hard parts omitted. Supporters liked the discipline of freezing almost nothing: rather than shipping a sprawling framework, it gives an agent room to grow tools and workflows around a concrete task. That appeals especially to people trapped in existing harnesses that mostly work but resist customization; a minimal seed could be a practical escape hatch without forcing them to build an agent runtime from scratch. Some also connected the idea to repository-native swarms, where containerized agents share durable context and continuously work through a codebase. Skeptics wanted a stronger account of what this buys over established tool sets and agent frameworks. If code execution, search, fetching, and ordinary plugin writing already cover most jobs, an agent that mutates its own harness can look like needless novelty. Several readers framed it as an experiment rather than a production tool, recalling the early Auto-GPT era’s promises of recursive self-improvement. The sharpest criticism was not that minimalism is bad, but that autonomous tool creation has many more ways to fail than to become genuinely useful, potentially turning into an elaborate mechanism for frustrating users. Overall, interest in the clean design outweighed confidence that self-modification is the missing capability.
Where opinion split
The core dispute is whether a bare, self-extending harness creates meaningful leverage beyond conventional agents with a fixed set of tools. Advocates see minimalism as the point: it avoids framework bloat and lets capabilities emerge for the task at hand. Critics argue that common tools and existing extensible agents already handle most needs, while self-modification mainly opens new failure modes without a demonstrated payoff.
Community Sentiment
Positives
- The deliberately tiny frozen core appeals as an antidote to overbuilt agent frameworks, letting task-specific tools emerge instead of imposing a large abstraction stack upfront.
- For developers constrained by a mostly workable but awkward harness, this could be a lightweight launch point for custom agent behavior without authoring an entire runtime.
- The repository-as-swarm idea makes persistent, containerized agents sharing project history feel like a plausible path toward continuous AI-assisted development rather than isolated chat sessions.
- Several readers value the project as a crisp experiment in agent architecture, precisely because its small surface area makes resulting complexity easier to observe.
Concerns
- The project does not clearly justify why self-generated tools beat the familiar combination of code execution, web access, and plugins that already covers most agent tasks.
- Readers worry it repeats early autonomous-agent ambitions: recursive coding and self-improvement sound exciting, but history supplies little evidence that they reliably produce useful systems.
- A self-modifying agent has far more routes to create brittle, surprising behavior than to find productive new capabilities, risking a system that consumes user attention rather than saving it.