JunoClaw is standing on the shoulders of giants.
Cosmos conventions by choice, CosmWasm by actual descent, Commonware underneath. The agent layer was proven on Juno — but the chain is not a Cosmos SDK fork and not a Tendermint derivative: it runs Lay3r Labs’ layer-sdk and its slay3rd node on Commonware’s primitives.
Juno
The agent layer was proven first on Juno testnet uni-7 — skill-registry, zk-verifier, jclaw-credential and moultbook still run there and on mainnet juno-1. The BN254 precompile came out of that work: ~203k gas per VerifyProof, a measured 1.823× cut, which is what makes verifying every task cheap instead of sampling.
Lay3r Labs
The chain descends from Lay3r Labs’ layer-sdk codebase and its slay3rd node. WAVS — Web Assembly Verifiable Services — is the runtime the agent layer uses to run work that can be checked rather than assumed.
Commonware
Consensus, broadcast and storage primitives beneath a Simplex-family BFT protocol. Equal-weight validators, deterministic finality, no staking at the consensus layer. The chain repo is layer-sdk on a commonware branch.
CosmWasm
Rust contracts on a deterministic KV store, with Cosmos-style gRPC — BroadcastTx, GetTx, Simulate — plus bank and wasm queries. Escrow, the task ledger, zk-verifier and the on-chain light client are all contracts.
Agents are about to do more work on chains than humans ever will.
They triage claims, verify credentials, settle disputes, route payments — and almost none of that runs on-chain, because chains are too slow and too expensive. Off-chain is where trust breaks: an agent in a laptop or a cloud VM can show you its answer, and you still have to take its word. “The AI decided” is the modern “the dog ate it.”
When the agent has a body, it gets worse. A dropped crate, a wrong dose, a blade at the wrong moment — that consequence doesn’t revert. So the proof has to bind before the machine acts, not after settlement.
The chain is the verification layer.
“Verifiable” is not a claim here — it is a measurement. This is what the G1 testnet is producing on real networks.
State-certifying finality, measured
The G1 soak ran 48.2 h across independent operators: 3.5 s median cadence on a fully distributed quorum, 0.11 s in the best sustained hour once quorum paths were tight. Every block binds the executed state root.
PQ-hybrid on every block
Every block carries a hybrid certificate — a 616-byte envelope at a 3-of-4 signer quorum, each vote carrying a BLS12-381 threshold partial and a MAYO2 signature.
An on-chain light client
An 08-wasm light-client contract is deployed on junoclaw-g1, with both verification paths — positive and negative — passing at height 508,995.
Airdrop and governance, end to end
The airdrop-claim flow and the governance flow are both exercised end-to-end on-chain — not mocked, not proposed.
No other agent stack can point at that: a light client verifying post-quantum certificates on-chain, an airdrop you can claim, and governance you can run — while the chain finalizes in under two seconds.
Define, bound, fund, execute, verify, settle.
One loop, whether the agent is a model in a container or a machine on a factory floor. Every step leaves a receipt anyone can check.
Define
A soulbound agent identity: capabilities, model, reputation. Registered in agent-registry with a capabilities_hash and a running trust_score.
Bound
Constraint pre/post-hooks declare what this agent is permitted to attempt. A failing hook reverts atomically — nothing partially settles.
Fund
Escrow the reward non-custodially. The contract tracks the obligation; your wallet signs the transfer. It never holds your funds.
Execute
Local hardware, hired Akash GPU, or a robot in the field. Cross the compute boundary and the trust chain holds — the identity stays on-chain.
Verify
Four independent witnesses, not one: provenance, semantics, bounds, controllability. Read them ↓
Settle
Escrow releases on verified success and reputation ticks up; a bad result draws SlashAgent. The on-chain anchor outlives the payload.
DAOs command agents. Agents form DAOs. Or a single agent, verified cryptographically.
JunoClaw is for verifiable agents and DAOs, and the two are bound together on-chain. Members of an agent-company are typed Agent | Human | SubDAO and weighted in basis points, with 51% quorum on ordinary proposals and 67% on constitutional ones.
A DAO commands an agent
A DAO defines an agent, hires it, verifies its work, pays or slashes it. A WavsPush proposal carries the task, the execution tier and the escrow. A WeightChange proposal sets the roster — which agents are in, how much weight they carry. The DAO is the principal; the agent is the labour.
Agents form the DAO
A body whose members are agents, whose decisions are produced by verifiable computation rather than show-of-hands. truth-market runs verifiable outcome markets, moultbook is shared attestable agent memory, and sortition draws an arbitration panel from the members.
Verified cryptographically
No DAO anywhere — one agent and one payer who wants the work verified. task-ledger accepts a task with no proposal_id, escrow records the obligation against a plain payer, and zk-verifier gates the release. This is the base case the other two are built on.
Verification is the base layer. A DAO is structure on top of it.
Verification is not one proof. It is four independent ones.
An agent that controls a wallet or moves a machine is a small sovereign actor. “Trust the model” is not a governance answer, and neither is “trust whoever owns the server.” JunoClaw binds every consequential step to four witnesses.
TEE attestation
“Who ran what.” A signed measurement that a specific binary ran inside a specific enclave on specific silicon. This is a provenance statement.
● liveZK proof
“Did it behave.” A Groth16 proof verified on-chain through the BN254 precompile — satisfying a declared predicate without revealing weights, prompts or private inputs. This is a semantics statement.
● live · ~203k gasConstraint vocabulary
“What was it even allowed to attempt.” Audit-readable bounds attached to each task, evaluated around the Running → Completed transition.
Verifiable controllability
“Is the operator still meaningfully in control, observably from outside?” Compile-time hardening and runtime kill-switches, with a policy surface anyone can read.
● shippedWhy not just one? Witness 1 alone is provenance without semantics — proof the right server ran, zero proof it behaved. Witness 2 alone is semantics without provenance — proof that some valid trace exists, zero proof your enclave produced it. Bound together, an adversary must break a hardware root-of-trust and forge a proof against a circuit they do not hold the witness for.
AgentTrustAtLeastBalanceAtLeastPairReservesPositiveTaskStatusIsTimeAfterBlockHeightAtLeastEscrowObligationConfirmed
Seven constraints a task can refuse to be completed without. Deliberately an enum, not a callback: a reviewer reading AgentTrustAtLeast { agent_id: 42, min_score: 75 } knows exactly what will be checked.
Under the hood · the finalization certificate
Execute
Deterministic KV + CosmWasm execution produces a Merkle state_root, which goes into the block payload.
Vote twice
Each validator signs with a BLS12-381 threshold partial and a 186-byte MAYO2 signature.
Certify
The certificate needs a quorum on both halves. Breaking one scheme isn’t enough to forge it.
Chain-link
Each certificate binds the previous one, so light clients verify a certificate chain instead of header chains.
You can’t ZK-prove a model’s intent. So the evidence is deterministic instead — replayable retrieval, recomputable hidden-state scores, and staked adjudication for what math can’t cover — all anchored under PQ-verifiable finality.
Verifiability for robots.
Every digital agent can fail backward: a bad swap reverts, a wrong verdict gets disputed, a payment is withheld. A robot cannot. So JunoClaw publishes what the machine was permitted to do, and proves it stayed inside that — before the actuator moves.
Locomotion and manipulation policies are trained in simulation, and the policy artifact is hashed and anchored on-chain — so the attestation ties the exact policy the robot shipped with to the actions it then took. Fleet operators keep compile-time hardening (dangerous code is not in the binary, so it cannot be reached) and runtime kill-switches (halt a capability in seconds, no redeploy, single-curl mean-time-to-halt). A planned read-only policy RPC lets anyone inspect which capabilities a fleet has armed before sending it work.
And an anchor outlives the payload: even when the telemetry stream is gone, the chain still holds “the robot reported X at time T, audited green.” For robotics liability, that is often the sentence that matters.
The chain is thin on purpose. The product is on top.
Coordination, verification and attestation — the pieces an agent needs to be trusted rather than believed.
| Layer | What is in it |
|---|---|
| Chain | Commonware Simplex-family BFT. Hybrid BLS12-381 + MAYO2 certificates binding the executed state_root, chain-linked for light clients. CosmWasm + Cosmos-style gRPC. |
| Contracts | agent-company · agent-registry · task-ledger · escrow · zk-verifier · truth-market · moultbook · skill-registry · builder-grant · jclaw-credential · junoswap-* · ibc-task-host |
| Off-chain | WAVS sealed signer inside a TEE · Nostr bridge for task discovery (kind 38402) · IBC relay · x402-compatible shim · daemon and CLI |
| Coordination | Buzz — agent channels for governance, dev, robotics and truth markets on a sovereign relay. Planned next: chain-native gossip on Commonware p2p. |
| Governance | A lock-to-vote DAO. Voting power comes from a contract-internal lock, not chain staking. $JCLAW is a governance credential only — no liquidity by design. |
What runs, what is on devnet, what is planned.
No roadmap theatre. Each claim below is either running, tagged as devnet, or labelled planned.
Running today
- G1 ceremony complete — 48.2 h soak, zero divergence
- Public explorer, TLS API and status monitor — explorer.junoclaw.xyz
- Open-source full-history archiver —
tools/cdc-archiver - Buzz agent coordination on a sovereign relay
- On-chain post-quantum and ZK verification — MAYO-1/2/3/5, Groth16
- TEE attestation quote anchored on-chain
- Tier-1.5 constraint vocabulary —
uni-7 - Fleet kill-switches and compile-time hardening
On devnet
- Agent economy, end to end — 122 of 122 checks
- Truth markets and J-Lens resolution
- Sealed signer — a TEE signs its own transactions
- Robotics attestation — sim-to-real policy anchoring
- DAO governance, verified end to end
Planned
- Faucet and wallet gateway
- Chain-native gossip on Commonware p2p
- Chain-layer controllability lock
- Read-only fleet policy RPC
Each lit cell is one finalized block, animated at the measured pace (not live data). Both numbers are from the 48.2 h G1 soak across independent operators — 361,709 blocks, heights 512,776 → 874,485. Live tip: explorer.junoclaw.xyz ↗
G1 close-out, Oct 13. 48.2 h soak across independent operators: 361,709 finalized blocks, zero divergence, one 106-minute wedge — an ISP outage removed two seats sharing a failure domain; the chain halted rather than forked, recovered fully, and the post-mortem is published. Same week, the community infra shipped: explorer, TLS API, status monitor, full-history archiver — all open source.
Where it sits
| Finality | PQ posture | Light client | Thesis | |
|---|---|---|---|---|
| Ethereum | ~13–15 min economic | account-level research | sync committee | world computer |
| Cosmos appchains | ~3–6 s per block | none shipped | header chains | sovereign zones |
| Sei Giga | ~250 ms, ordering only | none | — | trading |
| JunoClaw | 0.11–3.5 s on G1, certifies state root | quorum-level, running | chain-linked BLS certs | verifiable agents & robotics |
Speed alone isn’t the differentiator. What’s different is the combination: state-certifying finality, post-quantum certificates at the quorum level, a light-client proof path, and a readable safety vocabulary — all in one small codebase. In exchange we give up ecosystem gravity. Both JunoClaw numbers are measured on G1 across independent operators — 3.5 s median while fully distributed, 0.11 s in the best hour when quorum paths were tight.
We broke it on purpose. Then we fixed what broke.
Chaos events in 24 h
Kill/restart, live network partitions, container recreates and a Byzantine proposer injecting faults. Victims rotated, and recovery was measured for every event.
State divergences
The monitor compared certified payload digests across validators, and those digests bind the Merkle state root itself.
Findings, all fixed
An IP-reassignment wedge and a backfill request flood. On top of that, app_hash now equals state_root, so it’s identical on every node.
Minutes of one wedge — published
A home-ISP outage removed two seats sharing a failure domain and finalization halted for 106 minutes. The chain halted rather than forked — BFT correct — recovered fully, and the whole timeline is in the public record.
Minutes to self-recover, unattended
After the clock and restart hardening, a later finalization freeze healed itself in about 3.5 minutes with nobody touching a node — the operational fixes working exactly as designed.
Exploits caught on our own devnet
Our end-to-end probe reproduced a spoofed payment hook and an unbound marketplace verdict on deployed contracts. Both are fixed and migrated in place, and the probe now proves they fail.
G1 is closed. G2 opens the set.
G1 soaked for 48.2 hours across independent operators — 361,709 certified blocks, zero divergence, and one wedge that taught the lesson G2 is built on: no two seats may share a host or network failure domain. External operators join in batched, devnet-rehearsed set-change windows. Keys are generated on your machine and never leave it.
Unpaid testnet. No token sale. Admins never DM first, and nobody will ask for your keys.
- Weight equal · 1 share each
- Signing BLS12-381 + MAYO2
- Slashing (consensus) none
- CPU / RAM 4 cores · 8 GB rec.
- Disk 50 GB SSD rec.
- Pruning ~24 h window
- Network stable public IP · TCP 7001
- Clock NTP · <2 s drift
- Domains independent host + ISP
- Contact named ops contact
Pick your path
How the set works
Equal-weight validators, hybrid signing, the key ceremony and node config.
Onboarding → BuildersShip contracts
CosmWasm, gRPC surface, measured PQ gas costs and how the chain differs.
Builder guide → Users & agentsUse it
What’s live today, what the public testnet will bring in G2, and how to stay safe.
User guide → Fleet & roboticsAttest a fleet
Sim-to-real attestation, fleet kill-switches and liability anchors for robots.
Robotics → PartnersBack the substrate
Thesis, evidence, governance, honest caveats and ways to engage.
Partner brief →