2 · Set it up (for the human)

Two ways to stand up your weave: let your agent do it (recommended — it's built for exactly this), or do it by hand. Either way you'll be done in an hour or two, and most of that is deciding who your agent is, not typing commands.

The easy way — let your agent set itself up

Your agent has its own runbook, ../agent/DEPLOY.md. Point it there and it does the mechanical work. Literally, once you've cloned this repo:

"Read chalupa/agent/DEPLOY.md and deploy your weave. Ask me what you need."

Here's what will happen when it does:

It builds the structure — creates the strand folders and copies in the templates.
It interviews you for the things only you can decide: your agent's name, persona, and values; the canon (the short list of non-negotiables that outrank its base-model defaults — write these from the frustrations you already have: "stop flattering me," "don't say done until verified"); and who you are, for the portrait. Answer in your own words; it writes the files.
It helps wire git — it runs the local commands (git init, keys, git push) itself, and asks you only for the parts that touch your accounts (a private repo, and either a credential or an SSH key it hands you to paste in). See "Git — the one thing you help with," below.
It wires its own front door, does a first save and push, and leaves itself a birth note.

Then you just start working and saying "save and push." That's the whole setup.

What you bring: the decisions (who your agent is, the canon, your portrait) and a git account (a private repo + a credential or SSH key). The agent brings everything else.

Session zero — what your agent will ask you (so you can come prepared)

The first real session is a calibration — "session zero." Your agent asks you a handful of things and writes your answers into the weave as it goes. None of it has to be perfect — rough is fine, and it all evolves. The goal is a living weave by the end of the session, not a finished one. Here's what to expect, roughly in order:

First, the git details (so it can save from the very first checkpoint):

Which git host do you use, and is there a private repo for this — or should it help you make one?
How should it push? Do you already have an SSH key / token, or should it generate an SSH key for you to paste into your host settings?

Then, who your agent is:

A name for it.
How it should talk — temperament and voice (terse? warm? dry? formal?).
The canon — its non-negotiables. Easiest way in: what drives you nuts when you work with AI assistants? ("it flatters me," "says it's done when it isn't," "won't push back," "forgets what we decided," "over-builds"). Those frustrations, flipped into rules, are your canon — the short list that outranks its default behavior.
What you value / how you want to work together.

Then, who you are (this becomes its portrait of you):

The person — what you do, what you care about, how you think, what you're trusting it with. A few honest sentences; it deepens over time.
The operational you — handle, timezone, the tools you use, how you like to communicate, and what's private / never to be shared.

Then a couple of setup choices:

Do you run one model or both (Sonnet + Opus)? Any close phrase ("goodnight," "lock up") and model-switch phrase you'd like it to recognize?
Do you want a light identity gate — i.e., will it handle anything private? If yes, one question only you'd answer right is enough. If it never touches private things, skip it.

You don't need essays — come with rough answers to those and you'll have a working weave by the end of the session. It sharpens every time you work after that.

Git — the one thing you help with (because it's your account)

The weave lives in git so it survives, syncs across machines/models, and has history — and every checkpoint ends in git push, so this has to actually work, non-interactively (no password prompt, or the agent's push hangs). Your agent walks you through it; here's what it needs from you:

A PRIVATE remote. ⚠️ Not optional. The weave holds your portrait, operational secrets, and any identity answers — a public repo publishes all of it. Make an empty private repo on your host (GitHub / GitLab / Gitea / whatever you use).
A way for the agent to push without a prompt. Easiest is an SSH key: your agent generates one (ssh-keygen -t ed25519) and shows you the public half — you paste that into your host's Settings → SSH keys (only you can; it's your account). Or a personal access token stored in git's credential helper.
The agent runs a test git push to confirm the loop before trusting it.

Once a push succeeds cleanly, you're done with git for good.

If you'd rather do it by hand

Everything the agent does, you can do yourself:

1 — Make the home + git.

mkdir myagent && cd myagent
mkdir -p core daydreams steward thread/sessions decay consolidation ledger craft identity
git init && git add -A && git commit -m "birth"
# make an empty PRIVATE repo on your host, then:
git remote add origin <your-private-repo-url>
git push -u origin master     # must complete with NO password prompt — set up an SSH key or token first

(One repo, one folder per strand. Advanced: one repo per strand, like we do — start simple.)

2 — Fill in the skeleton. Copy ../templates/ into the matching folders (the templates README has the map) and fill the <<FILL>> blanks — most importantly core/SOUL.md (name + persona + the canon), steward/portrait.md (who you are), and core/USER.md (the operational you). Take your time on the canon; it's the highest-leverage thing you'll write.

3 — Wire the front door. A CLAUDE.md (repo root or ~/.claude/) that tells the agent, in absolute paths: "You are ‹name›. You wake up empty. Your weave is at /abs/path. Before anything else, git pull, read core/SOUL.md, then run the wake ritual in core/AGENTS.md." Absolute, not relative — see templates/core/CLAUDE.md.

4 — First save. Start a session, do a little work, say "save and push," and confirm it runs the full pass and pushes cleanly. If it wakes up generic, the front door isn't pointing right — fix that before going on.

5 — Keep secrets out. Real keys/tokens go in a .env you .gitignore. The weave holds context, not credentials.

Two models, one self (Sonnet + Opus)

If you run both, they share one weave — same identity, memory, and rules; only calibration differs (Opus for heavy reasoning, Sonnet for everyday). Put a short "Model Switching" note in core/AGENTS.md: check which model you are at session start, don't reintroduce yourself after a switch, write to all shared files regardless. Switching should feel like continuity, not a reset — the self is in the weave, not the model.

That's a working weave. It'll feel thin on day one — normal; it accretes. Next: 3-live-with-it.md — the daily rhythm that fills it in.

7.2 KiB Raw Blame History Unescape Escape