Introduction

draft first cut, 2026-09-13.

Peer review reduces a whole provenance trail — the observation, the evidence, the reasoning, the disagreement along the way — to a single opaque verdict: accepted or rejected. Everything that led there is usually invisible once the paper is out. Breadcrumbs is infrastructure for making that trail legible again: from raw observation, through evidence and review, to attestation, retraceable the way a paper trail used to be — for contributions generally, not only finished papers.

It’s built on the AT Protocol (the network behind Bluesky): every claim, piece of evidence, or attestation is a signed record in its own author’s personal data repository, not a row in breadcrumbs’ own database. Nobody has to trust a central breadcrumbs server for the data to mean anything — that’s a design constraint, not a slogan; see The Attestation Layer.

Two things are deliberately both called “crumb” in this project:

• Badges — breadcrumbs attests to someone that they did something (attended an event, completed a station). Authority- minted, needs an issuer identity.
• Crumbs — a person attests to their own trail, anchored to a physical object: an NFC tag or printed QR code on a card, a sticker, a pendant. Self-minted — the record lands in the tapper’s own repository, never breadcrumbs’. See Physical Crumbs, which is also the part of this project you can actually go try right now.

How to read this

Each chapter stands on its own — if you got a link straight to one section, you don’t need to have read the others first. The Appendix has two different kinds of supporting material: Roots grounds the project’s vocabulary (trail, decay, attestation) in older, non-technical sources — a fairy tale and a folk tradition, not just protocol names. The Artifact Series links to the actual interactive design mockups referenced throughout — worth opening directly rather than taking the prose’s word for what they show.

Where this stands

The self-minted crumb flow (real OAuth login, physical NFC hardware, a live registry) works end to end today, hand-tested and covered by an automated regression suite. The badge system and the sensemaking/ front-door layers described in the next few chapters are architecture and active work, not yet live — each chapter says plainly which state its own subject is in, rather than presenting everything as equally finished.

The Attestation Layer

draft first cut, 2026-09-13.

Breadcrumbs is not a document format, and not a journal. It’s the layer that sits over documents, claims, and contributions of any shape, and answers a narrower question well: who said this, when, and what does it connect to.

Three layers, three questions

Each layer absorbs a different category of hard question, so no single layer has to answer everything at once. The front door doesn’t need to understand claim structure; the data plane doesn’t need to be citable.

The base record: id.breadcrumbs.trail

One record type underlies all of it: an author did some kind of thing (a claim, a piece of evidence, a question, a review, a physical tap — kind is an open string, not a fixed enum) about some subject (anywhere it lives — an AT-URI, a URL, a DOI), at some time, with zero or more typed connections to other trails (supports, opposes, explainer, helpful, and — for a physical crumb — received-from/ handed-to).

It deliberately carries no title, abstract, or content-structure field of its own. The moment it grows one, it starts duplicating what document-shape projects like OXA or Curvenote already do well. Breadcrumbs attests to a document; it doesn’t compete with what defines one.

The pilot: project-to-ecosystem attestation

Before any of the paper-review machinery above exists, there’s a simpler, already-live use of the same idea: a project in an existing research ecosystem claims its own contribution, and other real participants attest back — using Hypercerts’ existing org.hypercerts.* lexicon directly, no new schema, no hosted service, just an existing AT Protocol account. id.breadcrumbs.trail is the identification+attestation wrapper; Hypercerts’ own records are the attestation lexicon underneath it, reused rather than reimplemented.

This pilot validates the attestation mechanics — signed records, cross-account acknowledgement, an issuer identity anyone can look up and verify — on a simple case before generalizing to the full paper pipeline. It needs neither the front door nor the sensemaking layer at all.

Reward is stored, decay is computed

Two related but structurally different mechanisms:

• Reward is a data-plane fact — a signed field on the record itself (a contribution weight, an evaluator tier). It lives where the record lives, because it is the record.
• Decay can’t work that way. AT Protocol records are immutable and content-addressed — a record’s bytes can’t be aged or corrupted on read without breaking its own signature. Decay has to be a computed property of a view over the graph — a claim’s displayed freshness fading until it’s re-attested — never a mutation of the record itself.

Freshness-decay does double duty: beyond just flagging staleness, it punishes “extract credit once, then disappear” the same way a bonding curve’s self-inflicted slippage punishes dumping — not just non-contribution, but disengagement after extraction. It’s also one of the few places this project’s underlying metaphor comes from an older source than the protocol itself — see Roots.

What’s a known, open gap

Nothing today stops an org.hypercerts.collection record from impersonating a listed project — Hypercerts itself has no namespace authority, and neither does the ecosystem directory breadcrumbs draws its pilot cohort from. Acceptable for now because that cohort is small and directly contacted, not open self-serve; a real question to revisit before opening this past that cohort, likely via the same social-proof mechanism as everything else here (other real participants’ own acknowledgements), rather than a new gatekeeping system.

Why This Fits AI for Science & Safety

draft first cut, 2026-09-13.

Foresight’s “AI for Science & Safety Nodes” call doesn’t treat AI-for- science and AI-safety as separate asks — it frames them as one transition: use advancing AI capability to unlock scientific breakthroughs while keeping that transition decentralized rather than concentrating compute and power in a few hands. It names three funding layers, and breadcrumbs has a concrete answer for each.

Local compute — community-owned, not rented

co/core is a member-owned cooperative pooling compute people already own to run open models for each other, instead of renting from large clouds — today specifically Apple Silicon Macs (its confidential-computing story is built on Apple’s Secure Enclave), worth naming as the current reality rather than a ceiling: the cooperative model generalizes to other hardware as the network grows. It’s OpenAI-API-compatible, so classification and judging work in breadcrumbs’ sensemaking layer can route through it by default rather than a corporate API. Every job produces a cryptographically signed receipt — the same attestation instinct breadcrumbs already applies to claims and evidence, applied here to compute provenance instead. This is genuinely convergent, not just adjacent: co/core’s own AppView exposes receipts, jobs, and providers as signed public records over XRPC — the same data-plane shape as everything else in this stack, so a compute receipt could plausibly become part of an Evidence node’s own provenance rather than a separate system to bridge.

Decentralized alignment, by architecture

Every claim, evidence node, and attestation lives in its own author’s personal data repository — there is no central database to capture, and federation means any community can run its own trust view over the same shared graph. The anti-concentration property this RFP asks for isn’t a safety story bolted onto breadcrumbs after the fact; it’s what the data plane already is by construction.

Accountability for AI-authored contributions

The part institutional peer review has no answer for yet: as AI systems increasingly participate in research — not hypothetically, but already documented (autonomous editing agents quietly turning read-only web access into write access on public infrastructure, research agents now running multiple research-days per human day while the monitoring meant to catch problems weakens) — the attestation layer has to identify and hold accountable what made a claim, not only verify humans. Breadcrumbs’ Claim/Evidence structure is exactly the audit trail that failure mode needs: an agent’s claim is a record, individually attributable, versioned, and subject to the same tiered verification as a human’s — not exempt from it by default.

Supercollaboration, not headcount

The core diagnosis breadcrumbs is built against — first-author pipelines strangling grassroots collaboration — is the same problem this RFP names when it asks for smart allocation of compute and workflow automation instead of large teams. The build plan (one person, forking existing production infrastructure rather than starting cold) is already shaped that way, not scaled up to it after funding arrives.

AI-first science, concretely

A modular, continuously-published document model — decomposing a paper into reusable, individually-verifiable claims — is the actual mechanism for unlocking breakthroughs at the pace AI-accelerated research already moves, without losing the ability to check any one step of it.

The accountability point is the one specific to this RFP, not a generic “open science is good” pitch — and it’s grounded in something already happening, not a hypothetical risk.

Physical Crumbs — Attestation You Can Tap

draft first cut, 2026-09-13.

Everything else in this book is architecture. This chapter is a thing that works today: tap a physical object, log in with your own handle, and it joins your own trail.

Try it

trail.breadcrumbs.run/workbench prints a real sheet of crumb anchors. Pick a medium, pick a count, and each one is a QR code pointing at /anchor/<id> — anyone who scans it can start or add to that object’s trail with their own AT Protocol handle (Bluesky, a self-hosted PDS, whatever account they already have). No breadcrumbs-owned identity involved, no password: pick your handle, approve the login on your own server, done.

Two things share the name “crumb,” on purpose

• Badges — breadcrumbs attests to someone that they did something (attended an event, completed a station). Authority- minted: needs breadcrumbs’ own issuer identity, and is still being built out.
• Crumbs — a participant attests to their own trail, anchored to a physical object. Self-minted: the record lives in the tapper’s own repository, never breadcrumbs’. This is the part that’s live — chosen specifically because it needs no issuer at all, so it didn’t have to wait on any authority/identity decision to ship.

The shape of a trail

One physical object anchors a star: every person who taps it before it’s handed off connects back to the same anchor id. A handoff is a leap — a received-from / handed-to connection to the previous holder’s own trail record, the same shape other AT Protocol “met-in-person” projects (like youandme.at) already proved out for a single fixed subject, generalized here to any physical object someone hands to someone else.

Decay depends on what it’s made of

Different materials carry a different “how likely is this actually still around and cared for” prior — a peeled-off sticker decays faster than a pendant worn as a keepsake. The decay math itself doesn’t change; each medium just gets its own window multiplier:

Real login, not a password stopgap

The first version of this asked for an AT Protocol “app password” — a concept almost nobody outside this ecosystem has heard of, and the actual first real person to try it got stuck on exactly that. It’s since been replaced with real OAuth: type a handle, a live typeahead finds it, and you’re redirected straight to your own server to approve — breadcrumbs never sees a password, or anything else about your account beyond the one record it asks permission to write.

Decoupled from the physical object itself

Printing or writing a tag doesn’t activate anything by default — a facilitator flips an anchor “live” as a separate step, so a whole sheet of QR codes or a box of NFC cards can be produced ahead of time and switched on individually, exactly when and where each one is actually placed.

Design Language & Vocabulary

draft first cut, 2026-09-13.

The core metaphor: the trail

This ecosystem already shares one vocabulary — “the Atmosphere,” AtmosphereConf, atmospheric.reviews, AT Protocol Spaces described by its own author as “a deeply social & atmospheric primitive.” Breadcrumbs’ own contribution on top of that shared metaphor is the trail: a claim is legible only if you can retrace the crumbs behind it — back through its evidence, to whoever attested it, to the identity that vouched for them. The name is literal, not decorative: the project exists because that trail is currently invisible in institutional peer review, and the whole point is to leave one where none exists today.

Reused terms, not renamed

• Claim, Evidence, Question, Project — Discourse Graphs’ own node types, used as-is.
• Anchor + Sidecar — a public record paired with a gated companion record in an AT Protocol Space. Used with exactly these words so they read as the same primitive everywhere they appear.
• Sensor — a saved link that keeps listening, surfacing what the network later learns about it back to whoever saved it. Sharper than “bookmark” for what a claim’s provenance record actually does over time.
• Connection — a typed relation between two records (supports, opposes, explainer, helpful) — the same shape as an Anchor/Evidence edge, named the way the ecosystem it sits in already names it.
• Trail — breadcrumbs’ own addition: the retraceable path from a claim back through its evidence to its attestation. Also the name of the base record itself (id.breadcrumbs.trail) — one attested contribution, not the whole path; a deliberate overload of the same term, not an inconsistency.
• Front door — the citable, ISSN/DOI-eligible journal layer, atmospheric.reviews.

Trail, not pheromone trail

It’s tempting to describe shared attention as “attention traces” that recycle like an ant colony’s pheromone trail — a real and useful observation about how aggregate attention propagates through a network. But breadcrumbs’ own trail is not that: every crumb is a specific, attributed connection someone made on purpose — a claim, an evidence link, an attestation — not an anonymous emergent residue anyone can follow without knowing who left it or why. Human coordination doesn’t run on stigmergy the way an ant colony does; it runs on people making legible, accountable claims about each other’s work. Keep trail. Drop pheromone.

Visual register: inherit, don’t redesign

The front door (atmospheric.reviews) already committed to its own visual identity — carry that forward rather than introducing a second one for the same surface. Legibility should decrease deliberately as you move deeper into the stack: the front door reads as a calm, institutional journal; the sensemaking and data-plane tooling underneath can be more visibly experimental and atproto-native, matching the actual trust and audience gradient between the layers instead of pretending the whole stack is equally finished.

Tone

Plain and infrastructural — closer to the understated register of projects like Curvenote or Discourse Graphs (or iroh’s “less net work for networks”) than to attestation/impact-certificate marketing language. This matters concretely: an overly hyped framing risks brand integrity with the conservative funding agencies this effort also needs to be legible to.

Domains & Lexicon Authority

draft first cut, 2026-09-13.

Four domains, each scoped to exactly one role rather than one domain trying to cover all of them:

• breadcrumbs.id — NSID authority for the base Trail record itself (id.breadcrumbs.trail), and breadcrumbs’ own real issuer identity: issuer.breadcrumbs.id, a live, permanent, self-hosted AT Protocol server. It’s also published as a did:webvh identity — a self-certifying identity log anyone can independently verify without trusting a directory operator, directly on-thesis for an attestation-layer project. /whois lets anyone see who has publicly vouched for it.
• breadcrumbs.network — the wider-ecosystem interop point: compliant with other projects’ lexicons for interop’s sake, not just hosting breadcrumbs’ own schema.
• breadcrumbs.run — the execution/plumbing layer: labeler, inference endpoints, and the services mostly invisible on the traditional web. This compendium’s own home (docs.breadcrumbs.run) sits alongside it.
• breadcrumbs.chat — a shared space where humans and agents socialize together around contributions.

Co-evolving, not competing

OXA already defines a pub.oxa.* lexicon for publishing scientific documents on AT Protocol — documents live in any personal server, user-owned, portable, discoverable. breadcrumbs.network’s own schema should co-evolve with pub.oxa.* rather than compete with it as a second, incompatible document lexicon.

Breadcrumbs is the attestation layer, not a competing document format. The ambition is to eventually cover what OXA, Curvenote, and Discourse Graphs each already do well in their own domain — document representation, continuous/modular authoring, and claim/evidence structuring — through integration points with each, not by reimplementing any of them. A trail record’s subject field references an artifact wherever it actually lives and however it’s represented (an OXA document, a Curvenote manuscript, a Discourse Graphs node, a plain PDF) — deliberately addressing-scheme-agnostic, which is also why the base record doesn’t need a title, abstract, or content-structure field of its own.

Deliberately postponed, not decided: whether every contribution ends up with its own decentralized identity, versus an AT-URI record inside the author’s existing repository — the author field works either way; this gets revisited once co-evolution with OXA’s own document-identity model clarifies it, not decided in isolation.

Roots

draft first cut, 2026-09-13.

Design Language & Vocabulary grounds breadcrumbs’ vocabulary in its living technical ecosystem — Discourse Graphs, Curvenote, Semble, Cosmik Labs. This chapter grounds it a level deeper, in older, human sources: a fairy tale everyone already knows, and a regional ritual few outside it do.

Hansel and Gretel — where decay was always in the name

Before breadcrumbs was an attestation layer, it was already a story about a trail that fails. In the Grimm tale, the children mark their way home through the forest with a trail of breadcrumbs — and the birds eat them. The trail doesn’t just sit there waiting to be retraced; it is eaten, silently, by something with no stake in whether the children find their way back. By the time Hansel and Gretel turn to follow it home, there is nothing left to follow.

This matters for more than the name. It means decay was never a borrowed concept — not something reached for from a bonding curve’s anti-dump mechanic and grafted onto breadcrumbs from outside. A breadcrumb trail, in the story that gives this project its name, was always a perishable marker, not a permanent one. Freshness fading until re-attested isn’t an import into the metaphor — it’s the metaphor’s own original failure mode, arrived at independently and only recognized afterward.

Worth sitting with, not resolving: in the story, decay is what causes the children to get lost — an unambiguous bad outcome. In breadcrumbs, decay is deliberately protective — it’s what stops cheap, one-time attestation from coasting on stale credit forever. Same mechanism, opposite valence. That tension is honest, not a flaw in the metaphor — it’s exactly the difference between a trail nobody is tending and a trail whose tending is the whole point.

What happened to the story itself

Before Grimm, a fairy tale wasn’t one thing. It was told and retold across villages and generations, each telling its own variant, with no single authoritative version — closer to a plural, unattested graph of independent tellings than a canonical text. That plurality is exactly what the Brothers Grimm’s own project ended.

Kinder- und Hausmärchen went through seven editions between 1812 and 1857 (86 tales growing past 200), and Wilhelm Grimm, its principal reviser, reworked the prose every time — more literary, more dramatic, more sentimental with each pass, moving steadily away from the oral register it started in. The edits weren’t only stylistic: in both “Hansel and Gretel” and “Snow White,” the murderous mother of the first edition becomes a stepmother by the final one — a deliberate moral edit, made silently, leaving no trace in the “official” text of what the earlier version actually said.

The sourcing was reshaped to match. Dorothea Viehmann, one of the Grimms’ most-cited informants, was presented in their foreword as an authentic Hessian peasant woman carrying pure oral tradition — she was in fact a literate tailor’s wife of French Huguenot descent from urban Kassel. That framing wasn’t an error; it served the collection’s own Romantic-nationalist project of building a shared cultural identity out of “authentic” folk material. Whether a source was really “pure Volk” mattered to that argument more than whether it was true.

So: a plural, orally-attested tradition got frozen into a single canonical text, revised repeatedly according to an undisclosed agenda, its provenance presented as more authentic than it actually was — with no legible trail back to what changed, when, by whom, or why. That is not adjacent to a single opaque verdict replacing a legible trail — it is the identical failure, in folklore, a century before the questions this project answers today. The story that gave breadcrumbs its name was itself subjected to exactly the problem the project exists to prevent.

Rauhnächte — the twelve nights between the years

Rauhnächte — the “rough nights” / holy nights, the twelve-night span between December 25 and January 6 observed in German- and Alpine-region folk tradition. Not a universal reference like Grimm — a tradition local to where this project’s own roots are, brought in deliberately for that reason: a time held between conscious retrospection and orientation toward what’s coming, made legible through a sequence of small, attributed acts across twelve nights, each carrying its own significance.

What resonates, concretely:

• A liminal, otherwise-untracked passage made legible through a sequence of small, attributed acts. Twelve nights, each doing something specific, together forming a path from one year into the next — a trail’s actual shape, not a metaphor stretched to fit a structure that already existed.
• Protection that must be actively renewed, not sealed once. Warding isn’t a one-time act here; it’s upheld by repetition. This is freshness-decay again, from a second, independent direction — standing doesn’t persist on its own merit, it’s tended.
• Reading the future from ambient signs, not from an authority’s pronouncement. Using atmospheric signals instead of an external expert-defined ground truth is a much older instinct than any protocol: let the world’s own incidental signals tell you what an authority can’t.
• Warding off what doesn’t belong, without a central gate. A boundary enforced by practice, not by a locked door — echoes an open question breadcrumbs hasn’t fully answered either (see The Attestation Layer’s note on impersonation), not a new shape of problem.

Three groundings, doing different work. Grimm’s story is universal and literary, and it’s why decay was never optional. What Grimm’s own hand did to that story is why canonization without a trail was never a hypothetical risk to guard against — it’s documented history, and it happened to this exact material. Rauhnächte is regional and lived, and it’s why tending, not just marking, was always going to be the actual practice underneath the trail.

Appendix: The Artifact Series

draft first cut, 2026-09-13.

Four design and proposal artifacts, originally published as private Claude Artifacts during the sessions that shaped this project; reproduced here verbatim as static pages under this domain instead, so anyone can actually open them without needing sharing access granted — same content, one fewer moving part.

• Trailview — the phase-0 pilot’s design-review surface: a static mockup of how reward (a fixed attester-tier stamp) and decay (a fading-ink freshness bar, restorable by re-attesting) render side by side, grounded in the same paper-trail material metaphor as the rest of this project rather than a generic dashboard fade. Invented sample data — reads no live server.
• Magnet or Manifest — a proposal written for an external collaborator working on torrent-like dataset addressing, sketching whether and how a breadcrumbs trail record should attest to a magnet-URI-addressed dataset directly, versus attesting to a stable manifest record that itself references the magnet link. A real tradeoff to react to, not a decided design.
• Crumb Icon Gallery — the first showcase of the deterministic, seeded “star and sticks” visual identity every physical crumb renders as, across a range of connection counts and freshness levels.
• Rose Curve Prototype — an earlier visual-language exploration for the same crumb-icon system, plus parameter-sweep grids used to tune it before settling on the version actually shipped.

These are snapshots of a point in time, not living code. The actual, current crumb-icon generator is part of trail-of-crumbs, the live SvelteKit app behind Physical Crumbs — these pages are the design record of how it got there, not the thing itself.