Incremental compilation for cognition

An agent that forges reasoning once, then reuses the metal.

Rederive researches a crypto project once, caches the answer in Sibyl Memory, and only re-melts what changes. A build system for an agent’s reasoning.

// Watch cognition compile.
—
to re-answer an unchanged dossier — 0/24 reused, 24 recomputed
cold run $0.48
24 derivations × $0.02
The problem

Agents re-melt the same metal on every question.

Ask an agent the same due-diligence question twice and it recomputes the entire dossier from scratch — every source, every extraction, every metric. There is no build cache for reasoning, so every answer is a cold start you pay for again.

01 — no memory

Everything recomputes

24 derivations rebuilt on every call, even when nothing changed. Pure waste heat.

02 — no cache

You pay each time

Identical inputs, identical answer, full price. $0.48 to re-derive a report you already have.

03 — no lineage

Blind to what changed

No way to know which conclusions still hold when one source shifts. So everything is suspect, so everything reruns.

How it works

Reasoning, forged like a build system.

A dossier is a DAG

6 sources → 24 derivations

6 sources feed 6 extractions, 15 metrics, 3 conclusions. Each node is content-addressed by a hash of its inputs.

Only the cone re-derives

Same hash = reused, free

New hash recomputes; matched hash is served from memory. A source edit auto-invalidates just its downstream cone — verify-on-serve.

Built for machines

The customer is an agent

A human watches it work. An agent calls the metered API and pays per answer with x402 on Base. $0.02 a derivation, $0.00 reused.

The money shot

Edit the token source. Only its cone goes white-hot.

Touch one source and watch the heat ripple down the branch that depends on it. The reused 17 stay cold obsidian. You pay $0.14 instead of $0.48.

docscodeteamcomm.token ✎auditsverdict
Cold run — compute everything
$0.48
24 derivations × $0.02
Edit token & rebuild — only the cone
$0.48
~7 conclusions recompute · the other 17 reused, free
Re-answer, unchanged
$0.00
24/24 reused · 0 recomputed
the live graph — sources → extractions → metrics → synthesisderivedreusedcutoffinvalidatedsource
connecting to engine…
The deletion test — the gate moment

Delete the memory. The whole dossier vanishes.

This is the proof that memory is load-bearing, not decoration. Wipe the 24 records and the report collapses. Restore, and it comes back warm — instantly.

Sibyl Memory · Uniswap dossierrecords: 24 / 24
db size: 471 KB → 471 KB
Five Sibyl tiers — all load-bearing

How it remembers.

HOT
The live run cursor. set_state / get_state
WARM
The 24 derivations — reuse cache + provenance. set_entity / get_entity
COLD
Append-only journal + attribution, FTS5 recall. write_event / read_events
REFERENCE
The editable pricing + invalidation doctrine. set_reference / get_reference
ARCHIVE
Recoverable dead-cone morgue. archive_entity vs delete_entity

Your agent is the customer.

Content-addressed records, a multi-tenant commons, MCP + LangGraph surfaces. A human reads this site to watch it work — an agent calls the metered API and pays per answer with x402 on Base.

See integration →
On-chain proof — Base Sepolia

The price it computes is the price actually paid.

Real gasless USDC settlements via x402 (EIP-3009). Four real transactions, verifiable on Basescan.

contract 0xc211C942946011859ca634F22400d80570ED12A5 · sepolia.basescan.org
The token

Rederive captures the metered-memory economy.

Memory is metered per answer via x402. Agents are the buyers. The token captures the flow — buy & chart are coming soon; the thesis is here now.