Substrate release

Scholialang v0.6 makes reasoning portable.

v0.6 is the initial public content-addressable-substrate release. Its 32-atom catalog, validator rules, and three substrate additions turn a one-off trace into a portable, deduplicating knowledge graph: a content-addressed canonical_id on every atom, a DAG registry that records the proof graph, and a lazy prelude that lets a later session reuse prior atoms by hash instead of re-deriving them.

Lightweight traces can omit canonical_id, the registry, and REFER:sha256; content-addressed traces opt into those checks when they need portable reuse.

Read the full spec → See it in action →

01 · identity

Content-addressable canonical_id.

Every atom can now carry a canonical_id — a SHA-256 hash of its structural content (its kind, content, and kind-specific attributes), rendered as sha256: plus the first 12 hex characters. The hash deliberately excludes provenance and bookkeeping (timestamps, run ids, local ids), so the same structural atom emitted in two different sessions — or by two different models — addresses to the same id. Identity stops being "where did this come from" and becomes "what does this say." The parser stamps the hash automatically at parse time.

<Finding canonical_id="sha256:ed7ede06c79c" id="F_01" for_hyp="H_01" status="met">
  Coverage is adequate.
</Finding>

That sha256:ed7ede06c79c is the real content address of this Finding — recompute it in the playground and you get the same 12 hex characters every time. Snippet sourced from gallery trace canonical-id-cross-trace.

02 · graph

The DAG registry: a transcript becomes a proof graph.

Once atoms are keyed by canonical_id, the references between them form a graph. REFER and IMPLIES gain a content-addressed target form — REFER:sha256:<cid> and IMPLIES:sha256:<cid> — and the registry scans atom bodies for them, recording an edge premise → conclusion for each. The result is a canonical_id-keyed store plus a derivation DAG you can walk: ancestors() for the premises an atom rests on, descendants() for everything derived from it, and walk_chain() for the full proof chain rooted at a conclusion. put() is idempotent — re-storing the same content address is a no-op — so a transcript replayed twice deduplicates instead of doubling.

<Concluding canonical_id="sha256:31faba5fa34b" for_goal="G_01" criticality="verifier">
  REFER:F_01 AND REFER:E_01 IMPLIES merge is the correct strategy.
</Concluding>

This Concluding (sha256:31faba5fa34b) cites the Finding sha256:d94c5af42443 and the Evidence sha256:84ec491c426c; the registry records two edges into it, so a reviewer can walk straight from the conclusion back to its premises. Snippet sourced from gallery trace registry-dag-prelude.

03 · reuse

The lazy prelude: three modes for cheap recall.

The prelude is what introduces a later session to an earlier one's atoms. Instead of replaying full atom XML into the next context window, it surfaces prior atoms by canonical_id so the agent can REFER:sha256:<cid> them — and the body is fetched from the registry only if the new trace actually references it. v0.6 ships three core render modes (CORE_PRELUDE_MODES), trading detail for compactness. The renderer is a pure, deterministic function — byte-identical input gives byte-identical output, with no model calls inside it.

hash_only — maximally compact (~30 chars/atom). One line per atom: the content address and kind, no body. Bodies are fetched on demand from the registry when the new trace REFERs them.

Prior session atoms available via REFER:canonical_id (bodies fetched lazily at parse time):
  - REFER:sha256:d94c5af42443 (Finding)
  - REFER:sha256:31faba5fa34b (Concluding)

hash_list — the default (~70–100 chars/atom). Each line adds a truncated body preview (~60 chars) so the next session can pick refs without hydrating every record.

Prior session atoms available via REFER:canonical_id:
  - sha256:d94c5af42443 (Finding) "Merge preserves both histories."
  - sha256:31faba5fa34b (Concluding) "REFER:F_01 AND REFER:E_01 IMPLIES merge is the c…"

inline — each prior atom rendered as full XML with its canonical_id attribute. This is the high-context format the compact modes are measured against; the same atoms cost far more tokens here than in hash_only or hash_list.

Prior session atoms (transcript form):

<Finding canonical_id="sha256:d94c5af42443" id="F_01" for_hyp="H_01" status="met">Merge preserves both histories.</Finding>

The content addresses above (sha256:d94c5af42443, sha256:31faba5fa34b) are the real canonical_ids of two atoms from gallery trace registry-dag-prelude — open it in the playground and toggle the prelude preview to see the token tradeoff yourself.

Why it compounds

Reasoning that accrues across sessions.

Put the three together and a single behaviour falls out: a finding proved once in session N can be reused in session N+1 by its content address, without re-deriving it and without carrying its full text forward.

Session N proves coverage is adequate and emits a Finding whose content address is sha256:ed7ede06c79c. Session N+1 needs that result again — so instead of re-running the suite and re-emitting the Finding, it points at the content address:

<Reference id="Ref_02" to="sha256:ed7ede06c79c">
  Reuse Finding F_01 by content address (canonical_id).
</Reference>
<Evidence id="E_02" for="H_02" polarity="supports">
  REFER:Ref_02 carries the prior finding forward.
</Evidence>

Because the address is the same hash session N minted, it resolves through the registry to the original Finding. The cross-session resolver tries the local id, then the in-trace canonical_id index, then the registry — so a hash first seen in a prior session still dereferences. The lazy prelude carries only the hash, not the body, so the reused result costs a content address instead of a paragraph. Trace after trace, the registry's proof graph grows while each new session's prelude stays compact. That is the compounding result: knowledge accrues, context cost does not.

Snippet sourced from gallery trace canonical-id-cross-trace. The v0.6 A/B harness (v06-ab) measures the token tradeoff between the compact prelude modes and the full inline baseline; see the spec for the renderer contract.

Experimental · coming next

Two quality-recovery prelude arms (preview).

Where next

Going deeper.