Grow a research assistant with a persistent, measurable character from your research reports — no API keys, no fine-tuning, no dependencies.

SeedGrow is an agent skill (built for Claude Code, adaptable to any coding agent that can read a markdown playbook and run Python). The model hosting your session does the thinking; a small deterministic engine keeps an append-only, hash-chained memory that accumulates into an evolving identity.

Everyone is generating deep-research reports. Most get read once and die in a folder. SeedGrow turns them into a compounding asset: every report you ingest shapes what the assistant notices, how it connects things, and who it becomes.

your reports ──ingest──▶ salience-filtered notes ──consolidate──▶ syntheses + identity block
                                                                        │
your question ──query──▶ BM25 retrieval + identity ──▶ Explorer view / Auditor view

• Two lenses, one memory. An Explorer (drawn to novelty, cross-document connections) and an Auditor (procedures, exceptions, contradictions) grow side by side from the same corpus with different attention weights. Their views are always presented separately — merging strong characters into one voice is a measured failure mode.
• Identity lives in memory, not weights. No fine-tuning ever happens. In our experiments the identity payload (seed + memory + identity block) carried across model substrates with the identity signal ≈ 2.2× the substrate signal — your assistant is portable, not vendor-locked.
• The grounding rule. One rule is always active: never claim what the sources don't contain. In our dose-response measurements this single rule accounted for ~97% of confabulation protection.
• Auditable by construction. Append-only store, recomputable hash chain (verify detects tampering), and exportable identity artifacts (Passport / Biography / Attestation, JSON-Schema validated).

git clone https://github.com/ferhatvonkaplan/seedgrow
mkdir -p ~/.claude/skills
ln -s "$(pwd)/seedgrow" ~/.claude/skills/seedgrow

Then in any Claude Code session: "use seedgrow to ingest the reports in ./my-research" — the skill's playbook (SKILL.md) drives the workflow. No configuration, no API keys; Python 3.10+ standard library only.

python3 engine.py init ./store                 # create a store (Explorer + Auditor seeds)
python3 engine.py queue ./store ./my-research  # what's next to ingest (≤2 per session)
python3 engine.py ingest ./store payload.json  # commit extracted notes (host model wrote them)
python3 engine.py consolidate-input ./store    # → material for the identity-forming step
python3 engine.py consolidate-commit ./store payload.json
python3 engine.py query ./store "what connects X and Y?"
python3 engine.py status ./store               # sessions, memory, identity layers
python3 engine.py verify ./store               # hash-chain integrity (tamper check)
python3 engine.py export ./store ./artifacts   # Passport / Biography / Attestation

Growth needs pacing: ≤2 documents per session, consolidation every 2 sessions. Bulk-loading a folder produces retrieval, not character.

SeedGrow is the applied distillation of SeedLoop, a research program on growing and measuring agent identity (identity = seed temperament × experience, on frozen weights). The design choices here are not vibes — they are pre-registered experimental results:

Honest limits: confabulation is reduced, not eliminated (open field problem — the chain gives you traceability, not immunity); results come from controlled fictional-domain experiments at small scale; your mileage depends on corpus quality.

• SKILL.md — the playbook the host model follows (workflows + rules)
• engine.py — deterministic memory core (~400 lines, stdlib only)
• schemas/ — JSON Schemas for the exported identity artifacts

Apache-2.0. Contributions welcome — especially second implementations of the identity-artifact schemas and corpus-quality gate ideas.