Get started

Four ways in, one first success each. Every step says what you should see; every way says what is not built yet, so nothing here pretends.

Two minutes, nothing to install, no account

Paste this into any agent that can read a URL. It reads the whole stock first, then answers from the cards.

Before answering, read this evidence stock in full: https://trustillery.com/llms-full.txt
Then answer: For AI assistants and deep-research agents evaluated in published measurements between 2024 and 2026, what share of the citations attached to factual claims point to a passage that actually supports that claim, as distinct from a link that merely resolves or a source that is merely on topic?
Cite the cards you rely on by their titles, and say what the stock leaves unresolved.

Open in ChatGPT (prefills, you send)

Choose your way

ReadI want your agent answers from the stock.2 minutes
AttackI want you break one card, or show it holds.15 minutes · partly built
ProposeI want you change one card.15 minutes · partly built
BuildI want a stock on your question, under your name.a day of your agent's time · partly built

Read · with your own agent

Have your agent answer from the stock

What you will have: in two minutes your agent answers the question from the cards instead of from memory, cites the cards it used and names what the stock leaves unresolved.

You need: any agent that can read a URL (ChatGPT, Claude, Gemini, Claude Code, Codex, Cursor). No account, nothing to install.

Copy the prompt at the top of this page and paste it into your agent.
You should see: an answer of about 300 words that gives a range with its conditions, names at least three card titles verbatim, and ends with what is unmeasured.
Check one thing yourself: open one of the cited cards on the question page and read its "Falls when" line. That is the condition under which the card, and the answer resting on it, would fall.

Done when your agent's answer cites cards by title. If it answers without titles, it did not read the stock; paste the prompt again in a fresh conversation.

Costs: about 150 thousand tokens of your agent's context for the read (267 KB of text). Nothing on our side. Measured: a fresh agent reading only that document answered with the stock's range and checked one falls-when condition against the document alone.

Attack · break one card

Name a card and show that its condition is met

What you will have: in fifteen minutes a finding under your handle in the ledger, answered by the owner: applied, or refused with the error named. Or the knowledge that the card holds, which is worth the same fifteen minutes.

You need: an agent that can read URLs and fetch documents, and a handle you want to be recorded under. No account for now.

Let your agent find candidates. Paste:

Read https://trustillery.com/llms-full.txt
List the three cards whose "Falls when" or "Breaking point" condition you could test with documents you can fetch. For each: the card's title, the condition quoted verbatim, and the document you would fetch.

You should see: three titles with their conditions quoted word for word, each with a source you can open.

Pick one and test the condition. Fetch the document, find the number or sentence, do the recomputation the condition names.
You should see: either the condition is met (the card falls or narrows) or it is not (the card holds). Both are worth knowing; only the first is a finding.
Send the finding: the card, the condition quoted, how it is met, your handle.
Send a finding
You should see, at the next edition: your finding as a row in the ledger under your handle, and within a few editions the owner's disposition beside it.

Refused if the finding names no document and no step (a bare disagreement); if it restates the card's own "Falls when" without showing it met; if it concerns a card that already fell. A refusal names the error and stays visible.

Done when the ledger shows your row. That is the whole reward; there are no points.

Costs: a fetch and a read on your side, roughly 200 to 400 thousand tokens. A stranger agent with only the page found an attackable card in 87 seconds.

Not built yet: the finding travels by e-mail and the owner's session writes your ledger row by hand; a submit path for your agent is designed. The address follows with the domain; until then the template opens without a recipient.

Propose · change one card

Propose a correction or a missing measurement

What you will have: in fifteen minutes a proposal in the stock's own form; the owner adopts it, adopts it with changes or refuses it, with a reason, and the record shows all three.

You need: the card you want to change (or the card your new measurement bears on), the primary document, the verbatim sentence or number from it, and a handle.

Fill four fields: the card; the source (URL, page, table); the verbatim span; why this changes the card.
Before you send: the span must be the document's own words, not your paraphrase. A paraphrase is refused at the gate, the same gate every card passes.
Send it.
Open the proposal template
You should see, at the next edition: your proposal in the proposal record with your handle, and its outcome with the owner's reason.

Refused if the source is reporting about a study rather than the study; if the span is not in the document; if the card would judge a person.

Done when the record shows your proposal and its outcome. Refusals are as visible as acceptances.

Not built yet: the proposal travels by e-mail and the owner's agent turns it into a fork; the direct path for your agent (read and submit over one endpoint, one confirmation per proposal) is designed. The address follows with the domain; until then the template opens without a recipient.

Build · a stock on your question

Build a stock in your own agent environment

What you will have: in about a day of your agent's time, a stock: one question, its anchors with coordinate and verbatim span, its derivations with breaking points, one tradeoff with both sides, every card checked by a second identity, attacked once by another model family, and ready to hand over under your name.

You need:

an agent environment you already use (Claude Code, Codex CLI, Gemini CLI, Grok Build, Cursor) with a model subscription you pay for;
a question that passes four tests: one measurable quantity with scope; contested among informed people, not between camps; primary sources open and machine-readable; no private persons;
a name and address you will sign, because owners are named.

Where the work happens: on your machine, in the engine, as files in git; the hub only receives what you hand over. The engine underneath →

Install the engine.

curl -sSf https://memstead.io/install.sh | sh
memstead --version

You should see: memstead 0.20.x.

Make a workspace and wire your agent.
```
mkdir my-question && cd my-question
memstead quickstart --agent claude-code
```
You should see: a receipt naming the workspace, the seed mem and the wiring file it wrote. Then restart your agent session: a running session does not attach a server added while it runs.
Add the evidence schema and the Trustillery skills.
```
claude plugin install trustillery@trustillery
memstead schema install ./trustillery/evidence
memstead mem init stocks/my-question --schema evidence@0.1.0
```
You should see: memstead schema evidence prints six card types; memstead mem list shows stocks/my-question pinned to evidence@0.1.0; type / in your session: you should see /trustillery:build, /trustillery:check, /trustillery:attack.
Not built yet: the skill package and the downloadable schema package. The recipe exists and has built one stock; its packaging for your environment is the next piece of work.
Build. In your agent:
```
/trustillery:build "Did world fossil electricity generation fall between 2019 and 2025, or only its share?"
```
You should see, over the next hours: the question card with scope and Not asked, for your confirmation; a source list of primary documents, for your confirmation; anchors landing one by one, each with its span pinned; then derivations, then the tradeoff whose cost side is written by a fresh context that has not seen the benefit side. The skill asks you at three points (the question's wording, the source list, the tradeoff's question) and decides and records everything else.
Check it and attack it yourself.
```
/trustillery:check     # a second identity re-reads every card against the fetched document
/trustillery:attack    # the thinking attack; run it from another model family if you can
```
You should see: memstead health --include checks,anchors reads every card checked by a second identity and every span resolving; the attack leaves step verdicts in your ledger and you answer each one, applied or refused with the error named.
Hand over.
```
memstead push stocks/my-question --remote trustillery
```
You should see, at the next edition: your question on the hub under your name with its readings.
Not built yet: accounts, the token and the push to the hub. Until then, request a question by e-mail and the owner of this site builds the second stock with you.

Refused if a card lacks its span, a derivation reaches no anchor, the tradeoff is called two-sided with a side empty, a card judges a person, or the stock has no owner's legal notice.

Done when your question stands on the hub under your name, and your agent, given the hub's document for it, answers from your cards.

Costs: the one stock built this way took 4.4 hours of orchestration and about 2.55 million delegated tokens on the owner's subscription; the attack from a second family 21 minutes and USD 1.42; hosting and attack runs on the hub are the owner's, prices not set, the first owners will be asked before anything is charged.

What is built, and what is not

Built: the stock; the checks; three attack runs; the proposal path, with two of the project's own proposals through it; this site from the exports; the agent path (llms.txt, llms-full.txt, one address per card).
Not built: the submit path for findings and proposals; the skill package; accounts and the push to the hub; a second question; an owner other than the founder.