learn() mines that record into cards with receipts in your bank, so the next campaign that loads the bank starts knowing what the last one measured.
Why measured experience
A page tells you what people have written down. It cannot tell you which of those approaches paid off on your task, at your scale, against your evaluation. The bank answers that: each card records a mechanism that paid or failed, the conditions it held under and the measurements behind it. A card is never a bare assertion. It carries a reliability state, a score and the evidence trail that earned them, and a score with no written rationale fails conformance (reliability rationale missing — no naked scores).
What a card is
A card has a body, the fact itself, written to be read cold by an engineer who has never seen it, whose first heading states the rule as a plain sentence and whose**Rule:** line is the card’s hero, the one-liner the bank index shows; and a reliability block, what the evidence says about it.
A card carries its
scope: domain, or the harness:<name> coordinate it was measured under (harness:none for a campaign that ran without one). The coordinate is read off the campaign’s record, never invented. Its evidence entries say what a campaign did with the claim, one verdict each (confirm, weaken, refine, refute, spawn, exercise); a card converted from a curated source carries a reported entry instead, the score others reported with its author, licence and protocol, and is served as such, never as a measurement of yours.
A card sits in one of five reliability states, and only two reach a campaign:
A card may declare that it
contradicts another active card. When two such cards are served together, the pair is named to the reading agent rather than presented side by side as though they agreed.
How a campaign becomes a card
One finished campaign moves through four stages. Each is bounded by a frame that does the mechanical work and validates the result; the judgment inside is done by agent sessions the frame launches, staged with the harness’s learning module when the campaign ran under one.
Grading before learning is the
exam argument of learn(); it defaults to True, and False is for development replays only. The stages, the graders and the learner’s own development are on Development mode.
Where the bank lives
learning.bank.local_path (shipped as ~/.kapso/bank.git): one bank per user, outside any project. Each card is a file, each lesson a tagged commit, so a campaign can be pinned to an exact bank state. Credentials stay with git and gh; Kapso never handles them. Sharing, reading a team’s bank and the other sources are on Your bank and Share a bank.
How the next campaign reads it
A campaign reads a bank exactly when it loads it:kapso build --experience mine, the brief’s Experience line, or load_experience("mine"). There is no serving switch; a build that loads nothing is served nothing. mine reads your bank’s home and a bank you read is served from its clone in the store, so no campaign step touches the network once the clone exists: the first load of a bank’s URL clones it into the store, and kapso experience update <url> refreshes the clone, which is how to put it in place before a launch with no network.
Serving is an introduction, not an injection. At launch the frame clones each bank at a pinned head (a resume re-pins the same head even when the bank moved since), compiles an introduction with one line per source and its provenance, and stages three tools under .kapso/serving/ in the campaign; the agent decides what to open.
The index is the whole eligible set in plain reliability order, with no
k cap and no relevance cut. Two things are filtered, and the frame says which: scope (under a harness, mine serves the cards scoped domain or harness:<name>; a card outside is refused by name with the reason; mine:all serves every card you measured; a bank you read serves everything it holds) and quarantine, silently (decoys and the non-serving states). A card may carry a measurement offer, a probe. It rides card reads only, never the index or the introduction; it is optional and never the default gate: the agent adopts its protocol only where that is affordable at the data’s scale, and says so, and an ignored probe stays queued; at most learning.retriever.probe_budget offers ride a campaign (shipped at 1), and offers ride mine alone, since a bank you read is not yours to measure for.
Every bank read is logged. The pull log is the bank tools’ record: which cards the agent opened, at what depth and from which bank, which is what grading scores serving from and what credits a cited lesson to the bank it was read from (a hosted gate’s or an index’s reads are in the session’s own record).
Related
Development mode
The pipeline’s stages, the graders, the bank’s internals, the learner’s own promotion
Your bank
Load it on a build; read what the campaign recorded
Experience reference
The scope rule, the pull log, the gate’s variables
learn() in the API
The call, its arguments and the Lesson it returns
pip install leeroo-kapso · Every page as plain text: llms.txt.