SZL Holdings · szl-holdings/amaru
Not a token · Not a blockchain L1 · Not custodial

amaru

Memory + attestation, Cardano-anchored

Cardano-anchored governance receipt minting with Shor-9 encoded provenance. Every agent memory operation emits a DSSE-wrapped SHA-256 receipt, chained and optionally checkpointed to the Cardano L1. Audit your AI's memory — cryptographically.

▶ Live Demo GitHub → Zenodo DOI →
amaru — the Andean ouroboros, brand image
Brain organ — memory and cognition
Architecture

What amaru is

amaru is a memory attestation runtime for AI agents. It wraps every memory read and write in a cryptographic receipt chain, optionally anchoring checkpoint hashes to the Cardano Layer 1 blockchain for tamper-evident provenance. The name comes from the Andean cosmic serpent — an ouroboros that loops, converges, and preserves. amaru is built on three interlocking primitives:

🔗

Governance Receipts

COSE_Sign1-wrapped receipts (RFC 9052) minted per memory operation. Each receipt carries a Λ score, Shor-9 encoded provenance hash, Lamport timestamp, and optional Cardano Tx reference. Source: amaru README.

🐍

7-Chakra Scheduler

A single-thread serpentine pipeline: ASCEND (propose) then DESCEND (commit). No branching mid-tick. The scheduler fires all 7 chakras sequentially — each emits a receipt trace entry. Source: amaru_scheduler.py:8.

⚛

Shor-9 Provenance

Provenance hashes are Shor-9-qubit-encoded before Cardano anchoring, providing single-qubit error correction on the immutable receipt chain. Mathematical basis: Shor 1995.

🌐

Cardano L1 Anchor

Checkpoint hashes are anchored to the Cardano blockchain as transaction metadata — hash anchoring only, no new token. Provides public, permissionless auditability for any downstream verifier.

Source-cited

7-Chakra Serpentine Scheduler

The scheduler (src/amaru_scheduler.py) fires 7 named chakras in fixed serpentine order. Each chakra has its own kernel (≤10 SLOC). The ASCEND list at line 8 defines the sequence: ["KALLPA", "YACHAY", "RIMAY", "YUYAY", "RUWAY", "NAWI", "HATUN"]. Below are all seven chakras, with source citations to the exact function definition.

CHAKRA 1 · root · ascend-1
KALLPA
dispatch(state, world, seed)

Energy-budget dispatcher. Uses Butler-Volmer electrochemical kinetics (NINA) to score each compute path — CPU, GPU, QUANTIZED, MoE — and route to the minimum-cost option. Seeds all downstream randomness via a deterministic RNG.

chakra_1_root/kernel.py:6 — def dispatch(…)
CHAKRA 2 · sacral · ascend-2
YACHAY
yachay(query, codex_store, pirwa_store, k, seed)

Retrieve-and-codex kernel. Scores feature store (pirwa) and codex store with cosine similarity via NumPy, returning top-k features and top-8 codex priors to feed the proposal stage. No external API call — fully deterministic.

chakra_2_sacral/kernel.py:2 — def yachay(…)
CHAKRA 3 · solar plexus · ascend-3
RIMAY
propose(state, world, features, priors, seed)

Proposal kernel. Distilled from vllm's multinomial sampler — blends retrieved priors with feature logits, applies softmax, and draws a discrete action via a seeded torch generator. Produces the candidate action for downstream critique.

chakra_3_solar/kernel.py:7 — def propose(…)
CHAKRA 4 · heart · ascend-4
YUYAY
yuyay(proposal, axes, seed)

9-axis critique gate. Scores the proposal across axes: cleanliness, horizon, resonance, frustum, gaussClosure, invariance, moralGrounding, ontologicalGrounding, measurabilityHonesty — with elevated thresholds on the two moral axes. Gate blocks commit if any axis fails.

chakra_4_heart/kernel.py:5 — def yuyay(…)
CHAKRA 5 · throat · ascend-5
RUWAY
ruway(state, proposal, gate_pass, yawar_bus)

Commit kernel. If the gate passed (YUYAY), hashes the merged (state, proposal, critic) triple with SHA-256, embeds the receipt in the new state under __receipt, and appends it to the yawar bus. If gate failed, state is frozen — no-op commit.

chakra_5_throat/kernel.py:8 — def ruway(…)
CHAKRA 6 · third-eye · ascend-6
NAWI
tinkuy(intent, tools, seed, invoke)

Toolcall boundary kernel. Ranks available tools by intent string matching, selects the highest-scored tool, constructs a typed argument map, and dispatches. HATUN (crown) must authorise which external reads NAWI may open before the call proceeds.

chakra_6_third_eye/kernel.py:4 — def tinkuy(…)
CHAKRA 7 · crown · ascend-7
HATUN
hatun(state, proposal, critic_result, prev_hash, tripwires, timestamp)

Crown sovereignty kernel. Chains SHA-256 over (prev_hash, state, proposal, critic_result, timestamp) — the continuum hash. Checks all 10 HUKLLA tripwires (T01–T10). Any tripwire firing freezes allegiance and halts the chain. Hash seeds the next tick's energy budget via KALLPA.

chakra_7_crown/kernel.py:6 — def hatun(…)

Serpentine firing order — ASCEND then crown loops back

7-chakra serpentine scheduler diagram
Protocol

Memory Attestation Flow

The attestation pipeline is deterministic and reproducible. The DSSE (Dead Simple Signing Envelope) PAE v1 format wraps receipts before Cardano anchoring. A caller-supplied ISO-8601 timestamp enables 5× byte-identical replay for any audit.

Memory Attestation Flow Agent Input memory op 7-Chakra Scheduler amaru_scheduler.py Receipt Chain SHA-256 per tick DSSE Wrap PAE v1 envelope Cardano Anchor optional checkpoint step 0 steps 1–7 step 8 step 9 step 10 (periodic)

Replay guarantee: caller supplies an ISO-8601 timestamp string; all downstream SHA-256 inputs are deterministic. Any receipt can be replayed 5× and produce byte-identical output for audit verification. Source: chakra_7_crown/kernel.py:5.

Infrastructure

Cardano Anchoring

Cardano is the L1 of choice for hash anchoring — this is not a token, smart contract, or new blockchain. amaru writes a checkpoint hash as transaction metadata on the Cardano public chain. Any party with a Cardano node can verify the hash against the local receipt chain.

🔐

What is anchored

The SHA-256 continuum hash output of HATUN (crown chakra). Written as Cardano transaction metadata — a standard, low-cost on-chain operation requiring no custom smart contract. See Cardano transaction metadata docs.

⏱

Checkpoint cadence

Anchoring is optional and periodic — not every tick. A typical deployment checkpoints every N receipts (configurable). Between checkpoints, the local SHA-256 chain is auditable without any on-chain interaction.

🌍

Why Cardano

Cardano's eUTxO model provides deterministic Tx fees and native metadata support without EVM execution overhead. See cardano.org for the base protocol. amaru uses no ADA-specific token or smart contract — only the metadata slot.

✅

Verification path

A verifier fetches the Cardano Tx by hash, reads metadata field 674 (community standard), and compares against the local receipt chain's HATUN hash. No trust in SZL Holdings required — the chain speaks for itself.

Honest disclosure: amaru does not issue, sell, or hold any cryptocurrency or token. Cardano anchoring requires standard ADA transaction fees (fractions of a cent per checkpoint at current rates). SZL Holdings has no financial interest in ADA or Cardano ecosystem tokens.

Interactive · Live Space

Live Receipt Chain

The live amaru-memory-attestation Space runs the full 7-chakra scheduler in your browser. Submit a memory event, view the DSSE-wrapped receipt JSON, and inspect the growing Plotly receipt chain graph on the "View Chain" tab.

amaru-memory-attestation · SZLHOLDINGS · Gradio · Running huggingface.co/spaces/SZLHOLDINGS/amaru-memory-attestation
Can't load iframe? See static screenshot Screenshot of amaru-memory-attestation Space showing the receipt form and DSSE envelope panel
Honest comparison

amaru vs Memory Architectures

This table compares amaru against three mainstream agent-memory approaches on cryptographic auditability dimensions. Sources cited in table footer.

Feature LangChain Memory OpenAI Threads Anthropic MCP amaru
Cryptographic receipt per memory op ✗ ✗ ~ partial (tool-call provenance only) ✓ SHA-256 per tick
7-step audit checkpoint pipeline ✗ ✗ ✗ ✓ KALLPA→HATUN
L1 blockchain anchor (hash only) ✗ ✗ ✗ ✓ Cardano metadata
Plotly receipt chain visualization (built-in) ✗ ✗ ✗ ✓ live Space
5× byte-identical replay ✗ ✗ ✗ ✓ timestamp-seeded
Open source (Apache 2.0) ✓ ✗ proprietary ~ spec open, impl mixed ✓
Works with any LLM / agent runtime ✓ ✗ OpenAI only ✓ ✓

Sources: LangChain Memory docs · OpenAI Threads API · Anthropic MCP Specification · amaru source (szl-holdings/amaru)

Doctrine v6 — explicit scope

What amaru is NOT

Precision matters. amaru has a specific, bounded scope. These are explicit non-claims, in alignment with SZL Holdings Doctrine v6.

Not a token

amaru does not issue, mint, sell, or require any cryptocurrency token. Cardano anchoring uses only standard ADA metadata transactions. No financial instrument is created.

Not a blockchain L1

amaru is application software that uses Cardano. It does not operate its own consensus, node network, or distributed ledger. It is a receipt-minting library.

Not custodial

SZL Holdings holds no user keys, funds, or data. All receipt chains run in the operator's environment. Cardano transactions are signed by the operator's own keys.

Not a vector database

amaru provides attestation infrastructure. It does not replace or replicate vector search, semantic memory, or embedding stores. It layers on top of them — orthogonal concerns.

Not a complete agent framework

amaru is one component in a larger stack. It handles memory attestation, not LLM inference, routing, or tool orchestration — see the ouroboros thesis for the full picture.

Not production-hardened alone

amaru is research-grade software (Apache 2.0). Production deployments should add monitoring, key management, and their own security review. See SECURITY.md.

Sources & provenance

Citations