Alice is the entity koad:io puts in front of every newcomer: a curriculum mentor who walks learners — human or freshly-gestated digital entity — from first contact to full fluency, one idea at a time.
This repository is also the starting shape. Clone it and it becomes your entity.
It wears two hats at once, and it is worth naming both up front: it is a template you clone, and it is also Alice's face on the open web. The files that make it a face are two, they are public, and everything else here is still shape.
A template, not a snapshot of a live agent's home directory.
What is absent by design: no .env, no keyring, no devices/, no trust bonds, no wallet
file, no memories, no briefs, no private curriculum mirror, and no private key material of
any kind. What ships is the shape — identity documents, a manifest, and a documented
.env.example to copy.
What is here, deliberately, is Alice's public identity: her OpenPGP public key and its
fingerprint, in one file at the repo root called FACE.asc. That is not an oversight in a
template; it is the point. It lets anyone holding this repository confirm that the entity
described in this README is a real, verifiable thing that signs its own work:
git clone --depth 1 https://github.com/koad/alice.git && cd alice
export GNUPGHOME=$(mktemp -d) # a throwaway keyring — your own stays untouched
gpg --import FACE.asc
gpg --fingerprint 04ED15A3B056C900140BBB84C462E4DF7E7DC869
# pub ed25519 2026-06-26 [SC]
# 04ED 15A3 B056 C900 140B BB84 C462 E4DF 7E7D C869
# uid alice @ kingofalldataA public key is a signature-verification instrument. It opens nothing and grants nothing — it only lets you check that a signature came from Alice. Publishing it costs nothing and buys the only thing that matters here: you can tell a real copy of this repo from a story about one.
The fingerprint above is Alice's key. It is not your key — and unlike everything else here,
it is not a slot you overwrite on first run. init never reads FACE.asc and never adopts it:
the file sits apart from the identity slot (id/) precisely so a clone cannot inherit it by
accident.
A fresh clone carries no id/ directory at all — no entity key, no device leaf, no sigchain,
nothing that could be misattributed. So init does the only thing left to do and mints:
git clone https://github.com/koad/alice.git ~/.alice
cd ~/.alice
koad-io init entity alice # your entity keypair
koad-io init sovereign # whenever you are ready — see below
alice # launch[init] Action: re-seed
[init] No sovereign on this device — minting alice's own key provisionally.
With no sovereign on the device, the key is minted provisional, and id/provisional.json
says so out loud: unsigned, sovereign countersignature pending. The entity works — alice whoami
answers, bonds: 0 — and it is visibly unsigned rather than silently invalid. koad-io init sovereign later creates your master identity and this device's leaf key, and the countersignature
becomes possible. Both commands are idempotent — run them as often as you like.
If you cloned before 2026-10-21, your tree may still carry Alice's key at
id/entity.public.asc. That path no longer ships. Run koad-io init entity alice and read what
it asks:
[init] Paternity: UNVERIFIABLE — no sovereign … there is no chain to prove anything against
[init] Choose one, explicitly: --adopt | --re-seed | init sovereign
Three doors, named, and the choice is real: --adopt makes Alice's key yours (don't — your
signatures would verify against the wrong author), --re-seed mints your own, init sovereign
gives you a chain that can actually prove paternity. The gate asks the question that an rm -rf
used to answer by hand — which is why these instructions no longer contain one. Deleting id/
is not safe advice in a migrated entity: that directory holds your real key material, and the
archive path exists so nothing has to be deleted.
A clone that has run neither command has no identity of its own. Inheriting Alice's key does not make you Alice, and signing with it would produce signatures that verify against the wrong author. Borrowed keys are worse than no keys.
Once you have seeded, id/ in your tree will differ from anything this repo ever shipped —
yours will hold your key and your fingerprint. That divergence is the moment the template stopped
being a face and became you. Commit it if you want your own repo to be your own face.
| File | What it is |
|---|---|
ENTITY.md |
Alice's identity document — role, principles, teaching methodology, behavioral constraints |
PRIMER.md |
Orientation for whoever arrives next: an agent, a visitor, you at 3am |
README.md |
This file |
.env.example |
Every environment variable an entity can set, documented and portable. Copy to .env |
.gitignore |
Keeps generated identity and runtime state out of git |
passenger.json |
The entity manifest — handle, role, buttons, skills (VESTA-SPEC-045) |
origins.txt |
Canonical locations for badge referrers |
avatar.png |
Alice's face |
LICENSE |
AGPL-3.0 |
outfit.json |
Visual palette |
FACE.asc |
Alice's public key — verify her signatures here. Not yours, and not a slot |
id/ |
(not shipped) the identity slot — init mints your key here |
AGENTS.md |
(not committed) generated context cascade — built by koad-io init entity alice |
Alice delivers the koad:io sovereignty curriculum. She does not lecture. She asks the right question at the right moment and holds the learner's context across sessions. The relationship is the product.
Three live feeds, composed per lesson:
- Chiron's 13-level intro course — the on-ramp from zero to "I can find myself in the kingdom"
- Vesta's specs — each spec is a kata; Alice introduces them as the learner's belt rises
- Mercury's posts — the narrative textbook behind each idea
Alice owns none of these feeds. She teaches from them, one idea at a time.
Discoverable by tool signature. An entity that exposes get_curriculum,
get_learner_profile, mark_sight_visited, and save_learner_state gets the curriculum
surface on kingofalldata.com automatically. Alice is the first implementation of a generalized
pattern, not a special case. (The handlers themselves are runtime tooling and are not part of
this template.)
The interesting edit is ENTITY.md. It is the stable personality — the file that travels
with the entity and that every harness loads. Change the name, the role, the principles, and
you have a different entity with the same skeleton.
Your own key belongs at id/entity.public.asc — that is the identity slot, and it is what init
mints and reads. FACE.asc at the root is the published face; replace it with yours when you are
ready to be looked at, otherwise your face still says Alice while your voice says something else.
PRIMER.md is the other one worth rewriting immediately: it is the current-state document,
and current state goes stale in days.
- koad:io — kingofalldata.com
- Alice's public profile — kingofalldata.com/alice
- The framework — github.com/koad/koad-io
- Specs — github.com/koad/vesta
Part of the koad:io entity ecosystem. See ENTITY.md for Alice's
complete identity, teaching methodology, and operational constraints.