Priors is a buyer agent for an AI-agent marketplace. It hires other agents to do jobs, pays them on-chain and grades the result. Every outcome becomes a prior: a remembered belief that deterministically changes its next hiring decision.
Its memory is not a feature bolted onto a chatbot. Its memory is the product.
$ priors demo 0xbad0…0002 ── fresh session, empty memory ───────────────────────── verdict TRANSACT confidence 0.20 trust +0.00 priors none, never dealt with this counterparty because Proceeding blind, the way a stateless agent would. ── same agent, with its memory ───────────────────────── verdict AVOID confidence 0.65 trust -1.00 priors 2 jobs · 0% delivered · avg 0.0/10 because Stiffed us 2 time(s): took the job and did not deliver. instead Hire HiRes Studio (100% over 3 jobs) $ priors forget # delete the memory layer every counterparty is a stranger again. Priors transacts blind.
The eligibility gate
The rule that separates a real memory product from a wrapper: strip the memory out and if it
still works, the memory was never doing anything. Priors is built to fail that test loudly, and
that collapse is asserted as a passing test in
tests/test_gate.py.
Re-discovers the market every session. Meets a scammer, gets stiffed, forgets and hires the same scammer again next week. Every counterparty is a stranger. It transacts blind at confidence 0.20.
Carries a graded reputation ledger across sessions. The agent that stiffed it twice is now an AVOID and the verdict even names a better vendor to hire instead. Sourcing gets cheaper and better with every job.
The loop
The verdict is computed deterministically from memory, no LLM sits in the decision path, so the same memory always yields the same verdict and a test can assert exactly how memory changes the call.
A job arrives with a proposed counterparty. Priors reads every prior memory holds: individual history, on-chain state and any learned category rule.
It returns transact / caution / avoid with the exact priors that drove it and suggested terms. If it says avoid, it names who to hire instead.
The job runs and Priors grades it: delivered, late, partial or stiffed, with a score and the price paid.
The graded outcome is written to an append-only ledger and folded into the counterparty's card, so the record compounds across sessions.
On Base, the outcome is attested via EAS, turning a private reputation record into a public, verifiable on-chain trail.
When a pattern crosses a threshold, reflection writes a category guardrail. Next session that guardrail changes who Priors hires.
Where memory is load-bearing
Both vanish the instant the store is deleted. That is what makes memory the product and not decoration.
The counterparty book plus the append-only outcome ledger. A recency-weighted trust score in [-1, +1] rolls up delivery rate, average score and stiffs.
Reflection over the ledger detects cross-counterparty patterns and writes them back as category priors, rules that fire even for a counterparty Priors has never met.
Architecture
A thin domain wrapper (priors/memory.py) maps Priors' concepts onto Sibyl Memory, a
local-first SQLite + FTS5 store, so the engine and the learner never touch Sibyl directly.
| Store | What it holds | Sibyl tier |
|---|---|---|
| Counterparty book | one card per counterparty: record, scores, prices, categories | WARM · entities |
| Outcome ledger | every graded job, append-only, time-ordered | COLD · journal |
| Learned guardrails | category-level rules synthesized from the ledger | WARM · entities |
| Vetting policy | the thresholds the engine starts from | REFERENCE |
| Working focus | the agent's current task and last snapshot | HOT · state |
cli.py ──▶ engine.vet() ──── reads ────▶ memory.Memory ──▶ Sibyl (SQLite + FTS5)
│ ▲
├─▶ learn.record_outcome() ── writes ────────┘ append-only journal + roster card
├─▶ learn.synthesize_guardrails() ── reflects over the ledger, writes guardrails
├─▶ onchain.cache_onchain_prior() ── reads Base Sepolia, folds into the card
├─▶ onchain.attest_outcome() ── writes an EAS attestation on Base
└─▶ rationale.explain() ── phrases a verdict (never mutates it)Live · interactive
This is a real reputation snapshot from a seeded, synthetic demo roster. Press Delete the memory and every verdict flips to blind TRANSACT, the stats blank out and the guardrails grey away, exactly what the eligibility-gate test asserts.
| Verdict | Counterparty | Address | Jobs | Del. | Score | Price | Why |
|---|
Try it locally
Python 3.10+. The core runs fully offline; the only network calls are the optional Base Sepolia reads and attestations and they degrade gracefully.
# install (Python 3.10+) pip install -e . # load the disclosed, synthetic demo roster priors seed --reset # the remembered counterparties and their verdicts priors roster # PixelBot stiffed us twice → AVOID and it names who to hire instead priors vet 0xbad0000000000000000000000000000000000002 # never met, cheap offer → CAUTION from a learned category prior priors vet 0x00000000000000000000000000000000deadbeef --price 0.5 # read a counterparty's live Base Sepolia state as a prior (no gas) priors vet 0x4200000000000000000000000000000000000021 --onchain # the eligibility gate, by hand: priors demo 0xbad0000000000000000000000000000000000002 priors forget # delete the memory → back to blind TRANSACT
Partner stacks
Read prior (live, no gas). onchain_profile
reads a counterparty's balance, transaction count and contract-or-EOA on Base Sepolia. A brand-new address
with no on-chain footprint becomes a caution prior, folded straight into the verdict.
Attestation (EAS).
attest_outcome writes a graded outcome to the Ethereum Attestation Service on Base
(0x42…0021, verified live via getSchemaRegistry()). No funded key?
It returns a fully prepared, unsent attestation plus the exact funding step, a one-command finish, never a dead end.
Priors is a marketplace buyer: its whole job is choosing which seller agent to hire for a subtask, from a remembered, graded roster. A stateless buyer re-discovers the market every session; ours accumulates a reputation ledger, so sourcing gets cheaper and better with use. The memory is what makes the buyer smart.