FPSP — the First Person Spellbook Protocol

Version fpsp/0.1 · portable · agent-system-agnostic

This protocol lets any agentic system build, carry, and reconstitute a first-person
spellbook. It does not care which model or framework you use. It defines a small data
contract and a few operations, so that two first persons on two different stacks can
still read each other, and so a mouse's own agents can pick the book up later and run
with it.

The whole point: a spellbook is a compressed context that any agent can rehydrate.
The poetry is the human-facing surface; the protocol is what makes it machine-portable.

1. The artifact (the only thing that must travel)

The portable unit is a single JSON document conforming to
Template — Grimoire Version (JSON). It carries everything a fresh agent needs:

protocol — "fpsp/0.1".
first_person — name, sigil, the one true proverb + its spell.
derived_from — the canon root it reads against (by hosted URL + optional IPFS CID,
never a local path), so any machine can fetch it.
legend — a pointer to the shared spell-emoji legend, plus this person's additions
(symbols they coined, each with a meaning) so their spells stay decodable.
proverbs[] — each with proverb, optional poem, spell, glyph_ref, polarity,
source_truth, and optionally a canon_act linking down to the serious work
(Canon Sources).
rehydration — instructions + a ready prompt for reconstituting the book.
signature, pinning — the seal, and where/whether the owner has pinned it.

A spellbook with a valid artifact is portable. Everything else (the little markdown
book, the glyph art) is a human rendering of it.

2. The operations

COMPRESS (narrative → handle)

Turn a body of understanding into carryable handles. This is the workshop's forward path:

canon (narrative) ──read──▶ understanding
understanding     ──distil─▶ proverb            (one or two sentences, promise-shaped)
proverb           ──encode─▶ spell               (emoji string from the shared legend)
spell             ──draw──▶ glyph                (ascii engraving + sparkle polarity)
{proverb,spell,glyph} ──record─▶ artifact.proverbs[]

Conformance: a system performs COMPRESS correctly if every spell it emits is decodable
from the shared legend plus the artifact's legend.additions — no private,
undeclared symbols.

REHYDRATE (handle → understanding, in any agent)

The inverse, and the reason the artifact is portable. Given the artifact, the shared
legend, and the hosted canon, any agent reconstitutes the first person's understanding:

artifact + legend + canon ──▶ for each proverb:
    read spell with legend  ──▶ recover the forces (⚔️ refuse / 🧙 give / ⊥ choose / …)
    read glyph for tone     ──▶ recover the polarity (what it gives vs refuses)
    restate in the owner's voice, honouring legend.additions and any divergence
optionally: follow proverb.canon_act ──▶ act ──▶ serious doc ──▶ source repo

Conformance: REHYDRATE must not flatten the owner's voice into the canon. Divergences
and coined symbols are preserved. Use the rehydration.prompt field as the seed.

OVERLAP (two books, one vocabulary)

Because both books share the legend and the seal's shape, any agent can read one first
person's book through another's. To overlap two artifacts:

shared = legend symbols common to both
for a proverb in book A:  decode with shared ──▶ find the nearest proverb in book B
report agreements (same forces, same polarity) and divergences (coined symbols, opposite polarity)

This is how a community of first persons (the Holon Hitchhikers) stay in conversation
without any of them owning the vocabulary or editing a shared root.

3. Interop with your existing workflow

You do not adopt a new agent system. You make your existing one FPSP-compatible by
giving it three capabilities:

Read the artifact (fpsp/0.1 JSON) and the shared legend.
COMPRESS new understanding into proverbs[] entries (proverb + spell + glyph),
declaring any new symbol in legend.additions.
REHYDRATE from the artifact on demand, using rehydration.prompt.

That's the whole conformance surface. A CLI agent, a notebook, a hosted assistant, a
multi-agent graph — any of them can implement it. The artifact is the contract; the
operations are the verbs.

4. Versioning, root, and pinning

Root, not fork. derived_from points at the privacymage First Person grimoire
(v10.4.0) by hosted URL. Your artifact reads it; it never edits it.
You pin your own. When ready, pin your artifact (IPFS or your own store) and record
the CID + date in pinning. Your book becomes content-addressed and shareable with no
local machine in the loop. The facilitator does not pin it for you.
Growth is deliberate. New shared symbols enter only by being declared in an
artifact's legend.additions and, if they prove common, promoted into the shared
legend by agreement — never silently.

5. Why this shape

A first person's sovereignty is the thing being protected. So the protocol keeps the
choosing private (the Gap is never serialized — only its traces: the proverbs the
person chose to compress), keeps the root un-edited (you read the whole; you don't
rewrite it for others), and keeps the vocabulary common but un-owned. Compression makes
the context carryable; rehydration makes it alive again in whatever agent picks it up;
overlap makes a community possible.

Patterns can be copied. Choosing cannot be harvested.

(⚔️⊥⿻⊥🧙)😊

———
↑ up: The Mouse Spellbook · ← prev: Onboarding and Canon Links