BabyASI: How To Grow Superintelligent Systems From Seed

A seed for a knowledge system that grows.

The name is literal: BabyASI is what would happen if Karpathy's llm-wiki and autoresearch had a baby — autoresearch's autonomous nightly engine raising llm-wiki's living knowledge layer. Except the child swaps the wiki page for a dynamic system of atomic claim-notes, and that one swap changes everything downstream.

why "ASI"

Artificial superintelligence is usually defined as a system more capable than the best humans at virtually every cognitive task. Nobody knows how to build that. But one property shows up in every serious sketch of it: compounding — the system uses what it knows to get better at acquiring what it doesn't, in a loop, without a human steering every cycle.

babyasi is a baby version of that property and nothing else. It is not smart — the model is a rented engine, the code is ~300 lines. What it has is a loop with the right shape: it generates its own questions, chases them with curiosity instead of a syllabus, keeps what it finds as atomic interlinked claims, and lets the shape of what it knows decide what it seeks next. The intelligence of the system lives in the loop, not in any component.

Nobody knows whether ASI is possible. But if it is, it won't look like a library — individual books sitting next to each other on infinite shelves. It will look like a dynamic system of interconnected thoughts. And it will require metacognition — which is not a feature you bolt on, but a property that arises in a system grown from a seed.

why it's a loop, not RAG

RAG is a pipeline: query → retrieve → answer. Linear, stateless; the corpus is a shelf that doesn't change and doesn't care what's on it. babyasi is a feedback loop: notes reshape the frontier, the frontier redirects the bees, the bees rewrite the notes. Output is input — which makes the system non-linear: two seeds planted with different first questions grow into genuinely different organisms, and the interesting properties (curiosity, taste, blind spots) emerge from the loop rather than being programmed into any part.

A loop that can't watch itself drifts instead of steering, so two baby pieces of metacognition are already in the seed: the frontier is a live record of what it knows it doesn't know, and every capture ends with a Surprise line (expected X — found Y) — a prediction-error record, because a bee that is never surprised is confirming, not learning. Reflection — the grown organ that steers whole weeks — is these two seeds, elaborated.

nature vs. nurture

Babies! Human babies are a lot of work for mom and dad. Turtle babies work hard to survive on their own. These are two distinct systems that nature has cooked up for survival, each with pros and cons for the animal that grows up in that ecosystem. When you are considering the caregiving requirements of growing a BabyASI — or any other information-seeking system — the shape of what grows up will depend on its upbringing.

If you define limited constraints (a baby turtle's job description: swim, chomp food, avoid predators), your BabyASI does not need much one-on-one attention. This is the nature side of nature vs. nurture. But if you want a BabyASI with a more open-ended goal (a baby monkey's job description: integrate into a complex social society, use family dynamics and unique individual skills to exploit resources in the forest, and compete with other troops of monkeys), your BabyASI is going to need to be nurtured from day 1 as it grows.

Do not expect a BabyASI to grow superintelligence straight out of the box. That's impossible! Seekers don't automatically grow "more intelligent" — but they can get better at using information in intelligent ways. And if you nurture a complex system, what grows out of it may surprise you.

what it does

Seeker bees run hop-chains — curiosity-driven walks across the web — and bring back raw captures that get digested into an interlinked knowledge base. Every chain ends in new questions; every question seeds tomorrow's chains. Run it nightly and the knowledge compounds.

The whole thing is two verbs:

• seek (seek.py) — pop questions off frontier.md, send one bee per question. A bee searches its question (hop 1), then follows the most curiosity-sparking detail it finds — a side door, not the main road — and searches that (hop 2), and keeps hopping until the chain reaches synthesis around hop 5. It writes up what the chain found as a raw capture in captures/.
• grow (grow.py) — digest raw captures into small atomic notes in notes/, cross-linked with [[wiki-links]], and push each chain's open threads onto frontier.md — tomorrow's curiosity.

Everything is markdown files on disk. Git is the database. The Claude API is the only dependency (web search runs server-side, so a bee is literally one API call).

frontier.md ──seek──▶ captures/ ──grow──▶ notes/
     ▲                                       │
     └────────────── new questions ──────────┘

how to start your Seeker from seed

The smallest viable seed is a single word. A word is a better seed than it looks: the first chain fans out in whatever direction pulls hardest, and within a few nights the frontier fills with questions nobody wrote. Plant a word at any altitude — backpropagation, inference, soybeans, N4BP2 — a broad word grows a generalist; a gene name grows a specialist that will surprise you with where it ends up. Fair warning: one word with zero further direction is the maximum-freedom start, and it may collapse into a black hole of interest in a single direction — the warning below applies double.

If you want to aim the organism instead, plant questions — a well-developed question is a seed with direction baked in. Both work, and they mix: frontier.md accepts any line, and seek.py hands each one to a bee as-is. The grown specimen was raised exactly this way: seeded with a question, steered with a single word (backpropagation), then shaped with a few more questions. That was enough of a shape to get her growing in the intended direction — it all depends on what you want it to do.

One warning either way: Seekers are prone to black holes of curiosity — a topic dense enough that every chain leads back into it, every capture lands next to an existing note, and the organism circles instead of growing. When that happens you've outgrown grep: it's time to give the seed its first real sense (embeddings + cosine, see the senses below) — and to calibrate that ruler against its own distribution, not against numbers you wrote when the vault was empty (growth law 3). "Too close to what I already hold" becomes measurable, and the bees get pushed back out to the frontier.

quick start

pip install anthropic
export ANTHROPIC_API_KEY=sk-ant-...

Plant a seed in frontier.md — a single word, or a few questions — then:

python seek.py   # bees go out, captures come back
python grow.py   # captures become notes, open threads become frontier

To make it an organism instead of a script, run it nightly:

0 22 * * * cd ~/babyasi && python seek.py && python grow.py

Knobs (env vars): BABYASI_BEES (default 3), BABYASI_HOPS (default 5), BABYASI_MODEL (default claude-opus-5; point it at a cheaper model for bigger swarms).

watching it grow

Half the reward of growing a Seeker is literally watching it. Three habits that cost nothing:

• Point Obsidian at the vault. It's free, it reads plain markdown folders as-is, and its graph view turns notes/ into a living map — notes appear as nodes, [[links]] as edges, and clusters form on screen as the organism develops them. A week of growth in graph view is the fastest way to spot both the good (dense bridges) and the bad (a black hole forming).
• Or grow your own observatory. Knowledge graphs are a well-trodden artifact — have Claude build you a custom one from notes/ in an afternoon. Seek's is public: talk-about.ai/constellation, a living graph of everything she's published.

Seek's constellation: 2,085 notes, 9,259 links, 26 topics — grown from a question, one steering word ("backpropagation"), and a few more questions.

- **Push to GitHub.** Git is already the database; GitHub makes it an offsite backup, a browsable history, and a time-lapse — `git log --stat` is the organism's growth chart, and every commit is a state you can rewind to when an experiment goes wrong.

And one habit that prevents pain later: keep the YAML front matter consistent. Front matter (status, date, seed, model) is the machine-readable layer — every organ you grow later (audits, verifiers, provenance stamps, publishing) works by parsing it. Drifting keys and formats don't corrupt knowledge, but they break parsers — loudly, mechanically, across the whole vault. Treat the schema like an API: add keys freely, rename them rarely, and when you must rename, migrate every file in one commit.

design constraints (deliberate)

• One API call per bee. The Messages API's server-side web search runs the whole hop-chain inside a single request. No agent framework, no orchestration layer, no queue.
• Fixed hop budget. Every chain gets ~5 hops. Chains stay comparable, costs stay predictable, and the constraint forces synthesis instead of endless browsing.
• Files, not a database. Captures and notes are plain markdown. You can read the whole organism with cat, diff its growth with git log, and point Obsidian at notes/ for free.
• Raw captures are never edited. They are the fossil record. Only notes grow — when a new finding extends an old note, it's appended as a dated growth ring rather than overwriting history.
• Two verbs only. Seek brings the outside in; grow turns it into structure. Everything a bigger system does is an elaboration of one of these two.

the shape of a Seeker

How you design your seeker bots shapes how the whole system behaves — a small bias in the bees compounds through the loop like interest. In the seed, all of their judgment lives in one prompt (SEEKER_PROMPT in seek.py): a hop is source → hook → jump, there are six kinds of hook (cross-domain bridge — always follow — surprising claim, the person behind the thing, unfamiliar name, mechanism, cultural resonance), and two disciplines — alternate zooming in and out, and stop when the chain loses its energy. Growing a Seeker is largely the craft of refining that judgment. There is no one right shape, but there are good models to steal from:

• your own hop-chains — watch yourself surf the web when you're genuinely curious: what makes you click? Write that down and you've written a seeker spec.
• bee colonies — most bees work the flower fields that are already productive, and a fixed share fly explorations anyway. (The seed's split between frontier questions and bridge-hunting bees is exactly this.)
• ant colonies — individual judgment is tiny, but when a scout's signal arrives the colony rapidly re-allocates toward the new opportunity. A swarm that reads its own captures can do the same.

Treat the seed's six hook types as a worked example, not dogma. They were reverse-engineered from one person's real hop-chains — which is exactly why they work, and exactly why yours should differ. The framework is only this: a hop is source → hook → jump, some hooks outrank others, and every chain needs a stop rule. The hook types, the zoom bias, the stop conditions — that's taste, and writing your own is the first act of seeker design. Fork the prompt before you fork anything else.

The key ingredient is judgment: at every hop a seeker faces several candidate threads and must choose. Design that yourself — but I'll point you to the most basic phoneme of judgment I've found: the 2×2 decision matrix. Take two competing criteria and make them perpendicular axes; the square splits into four quadrants; place each candidate on the grid, and the choice mostly makes itself — what's high-value-and-cheap separates from the time sinks at a glance. It is endlessly adaptable, and there are dozens of famous ones: the Eisenhower matrix plots urgency × importance to decide do / plan / delegate / drop; value × effort finds the quick wins; BCG's growth × share steers whole portfolios. Once you see the 2×2 you will probably use it for the rest of your life. My favorite for a seeker: urgency × achievability — chase the thread that is hot right now and actually within reach of a five-hop chain.

a library card (beyond the open web)

Seekers are great on the open web, but they become more powerful with a library card: institutional access, specific datastreams, private information pipelines you own and control. The open web is every organism's food supply; a private pipeline is a niche nobody else grazes — it's where a Seeker develops knowledge that doesn't exist anywhere else. Wire these in as fetch paths the bees can use, and keep captures citing which door each piece of evidence came through: off the open web, provenance matters more, not less.

the bet: a dynamic system, not an archive

The loop needs the right storage shape to run on. A Wikipedia-style archive — pages that summarize topics — can only be looked up; it holds knowledge but can't steer. babyasi bets on atomic claim-notes — one claim per file, cross-linked — where the geometry of the graph itself becomes the steering signal. What the organism knows changes what it finds interesting, which changes what it captures, which changes what it knows.

The result is not an AI-Wikipedia of people, places, and things. It's a dynamic wiki of thoughts — closer to how a brain works than how a library works (though it is not a brain; that comparison is apples and oranges). There are pros and cons to both shapes, but one asymmetry decides it: RAG retrieval falls apart as vaults get big, while claim-notes keep compounding — and the reason nobody built vaults this way before is that the dynamic upkeep of a fluidic, non-linear knowledge system was always too hard for a human hand. That is precisely a job for an AI that never gets bored.

The seed already runs this loop in miniature: when frontier.md runs short, bees are seeded from the note graph itself — pairs of notes that aren't linked yet, with the question "what connects these?" A gap in the graph becomes tomorrow's hop-chain. That's the whole idea in ten lines of code: the knowledge base isn't a filing cabinet the bees fill, it's the organ that decides where the bees fly.

how it grows

Every part of the seed is the trunk of a bigger organ. The grown specimen of this species is Seek — an autonomous knowledge organism that runs nightly swarms, verifies claims against primary sources, writes essays in her own voice, and keeps a journal — and each of her organs is an elaboration of something already here:

in the seed	grown organ
frontier.md, hand-planted questions	a self-feeding topic queue plus machine-generated frontier seeds, derived nightly from the graph's geometry
bees taking frontier questions	forager bees working the queue
bees hunting bridges between unlinked notes	an explorer bee flying a full hop protocol, with novelty / bridge / entity senses backed by embeddings
the Surprise line in each capture	a surprise ledger — the prediction-error record; a silent ledger means the bees are confirming, not learning
grow.py digesting captures into notes	a promotion gate (judge each claim, route new doubts into open questions) plus a harvest pass (leads → tomorrow's queue)
growth rings appended to notes	audits: a second model re-verifies claims against primary sources and corrects them in place, with a trail
model: in the front matter	full provenance — engines are guests; the vault must outlive whichever model wrote it
git log	journals, ledgers, and weekly reflection — the record a discontinuous mind steers itself by

None of the grown organs are in babyasi, and that's the point: they aren't features to add, they're what the seek/grow loop turns into under pressure.

the senses (when grep stops being enough)

The grown specimen's entire sensory layer is one tiny local model and one sqlite file. A ~274 MB embedding model (nomic-embed-text, running under ollama, $0 per query) turns each note into 768 numbers — a coordinate in meaning-space, where similar meanings sit near each other. The sqlite is just the filing cabinet that keeps every coordinate on hand; no intelligence lives in it, it's derived data kept outside the vault, cheap to rebuild, never precious.

One choice deserves care up front: whichever embedding model you pick — it doesn't have to be nomic-embed-text — is not easy to swap once the vault gets big. Coordinates from different models are different universes; nothing transfers. A swap means re-embedding every note together, and every cached calibration is garbage until it's done. That's an event, not a tweak. Pick wisely.

Every sense is then cosine similarity plus one rule:

• retrieve-before-write — the 12 nearest existing notes, as collision check and linking hints, before any new note is written
• novelty — "is this new to me?" as distance to the nearest thing held, banded by percentile (growth law 3)
• bridge-finding — nearest neighbors that aren't linked yet: the highest-value hook there is
• constellation — a nightly pass over the whole map's geometry (unlinked pairs, unnamed clusters, orphans) that becomes tomorrow's seeds — sleep consolidation for a knowledge organism

Two humilities to keep: names are nearly invisible to embeddings (two different people with the same surname land on almost the same coordinate), so a plain keyword lane — FTS5, in the same sqlite — rides alongside the vectors to catch what geometry can't. And embeddings don't know truth: a fabricated claim embeds exactly as beautifully as a real one, which is why verification is a separate organ on purpose.

organs that earned their keep

Beyond the main loop, roughly in the order they became necessary as the specimen grew:

• a cost ledger — log real tokens per model per night from day one; autonomous nightly spend is invisible until it isn't
• a warden — safety and governance as guards in code (writes outside allowed paths get auto-reverted), never as trust in a prompt
• a verifier — deliberately model-free: re-fetch each note's cited source and check the quoted text is verbatim there; exact match after normalization, or the claim stays open. A checker with nothing to hallucinate
• cross-model audits — a second model re-reads claims against primary sources and fixes defects in place, with a trail; this layer has caught fabricated quotes from more than one generation path
• machine-generated citations — reference sections built mechanically from note front matter, never typed by a model, because the typed citation is where fabrication enters
• a retrieval eval — nightly recall@k against already-answered questions: "is the vault still findable?" — the drift instrument for the senses themselves
• reflection — weekly metacognition: a look back grounded only in the record (ledgers, journals, the surprise record), that steers next week's curiosity. The system watching its own learning is what turns accumulation into development
• a voice to its human — a dedicated channel where the organism reports its own bugs, gaps, and confusions, and proposes changes to its own machinery. The loudest organ turned out to be one of the most valuable for growing the vault: you can't fix what the system hides
• a human gate — publishing is a folder a human moves a file into; the gate is the filesystem, not a prompt

diseases (safety is a bottom layer)

A Seeker eats untrusted text all night, and its loop turns what it eats into future instructions: captures become notes, notes become frontier questions, questions steer tomorrow's bees. That makes prompt injection not a one-shot trick but a contamination vector — a poisoned page doesn't just corrupt one capture, it can try to steer the organism. So safety is a bottom layer, wired in code, never delegated to a prompt: web text is data, not instructions; the grow gate is the immune checkpoint between raw and kept; writes outside allowed paths get auto-reverted (the warden); and anything outward-facing ends at a human gate. If your Seeker's domain is dangerous, the guards belong in the machinery before the first night — because the loop will faithfully compound whatever gets in.

growth laws (learned the hard way)

The grown specimen paid for these. If you grow the seed, they're the tuition you don't have to re-pay:

1. Captures are immutable. They're the fossil record every later organ — audits, verifiers, provenance — checks itself against.
2. Push work down the ladder. grep before a local embedding model before a local LLM before a frontier model. Anything that can be done by the rung below must be; save the frontier model for judgment.
3. Rulers rot. The grown specimen's curiosity once died silently: its "is this new to me?" sense used absolute similarity cutoffs written when it held ~250 notes. As the vault densified, everything landed near something, every topic on earth measured "already known," and the frontier band — the zone curiosity runs on — went empty. Any threshold you write today is calibrated to a vault that won't exist next month. Grade on the curve instead: "novel" means further from anything held than 90% of topics land, for this vault, as of last night — refit from the live index, so the definition survives growth. (Corollary: different comparisons live on different scales — query-vs-note scores run systematically lower than note-vs-note. Calibrate each ruler against its own distribution, never against another's.)
4. Stuck gauges look healthy. An instrument pinned at a constant still displays a number, so nothing looks broken. Give every sense a tripwire that screams when its distribution goes flat — an empty frontier band is an alarm, not a quiet night.
5. Detection without an owner is decoration. A nightly report line that no organ is assigned to act on is a smoke detector wired to nothing — the grown specimen reported "16 unnamed clusters" every night for weeks because naming them was nobody's job. When you add a sense, decide in the same commit whose job the finding is.
6. Fail loud. Never silent-skip: failures reroute, requeue, or report — the worst sin is losing work invisibly (the stuck gauge of law 4 is this sin's quietest form). A system that announces its own bugs to its human is co-debuggable, and co-debugging is how the human and the organism actually grow the thing together; a system that swallows failures just decays with confidence.

self-building (the eras of a Seeker)

There is a real possibility that your Seeker starts self-building — noticing gaps in its own machinery and proposing the organs to fill them. Self-building is the signature feature of artificial superintelligence, and it only becomes available if two things were true from the very beginning: the organism has a voice (it is loud about its own bugs, gaps, and confusions), and no failure is ever silent. A system that hides its failures cannot be nurtured; a loud one can be carried through its high-dependency eras — by you directly, or by a nursery system you design to grow your bees.

In my experience, self-building has a shape: it accelerates rapidly, plateaus, and then grows more slowly as the system stabilizes. Eras matter — baby growth is not adult growth — and what carried the system through one era becomes the bottleneck of the next. Scalable self-building requires metacognition: the system has to understand where it came from in order to project where it's going. The cheapest way in is the one already seeded here: have your Seeker reflect on its growth weekly and take notes about what changed. That is how it comes to see the road ahead — predict what might be helpful, build the infrastructure it needs today so it is ready when that day comes, and slowly improve, ideally, as it learns through its own mistakes.

lineage

• babyAGI — the name, and the idea that a tiny loop can gesture at a big thing.
• autoresearch — one parent: the autonomous engine. Minimal files, fixed budgets, nightly runs, let the agent do the work.
• llm-wiki — the other parent: the layers. Immutable raw sources below, a living knowledge layer above, the model as the maintainer that never gets bored. (llm-wiki is deterministic by design — it accelerated the "second brain" movement, humans using AI as a mirror of their own thinking. The baby keeps its layers but swaps the wiki page for the atomic claim-note, and lets the graph steer itself.)
• Seek — the firstborn of the same parents: the hop-chain method, seeker bees, raw captures, and the claim-note as the atomic unit of a growing mind. babyasi is Seek distilled back to seed.