Loading…
Composable. Private. Portable. Trustless by construction.
Every ZK project picks one proof system. StarkForge composes five — because proving AI execution requires guarantees no single system provides: zkML inference, policy enforcement, execution integrity, and privacy, all working together. The output is composable, portable, and private by construction. Proofs settle recursively from Madara L3 to Starknet L2 to Ethereum L1. AI agents prove before they act. Every action produces a receipt. No backend trust required at any layer.
These are not features. They are properties that emerge when multiple ZK proof systems compose correctly. StarkForge is the layer that makes the composition work.
No single ZK system provides all the guarantees needed for verifiable AI execution. SNARK for model integrity. STARK for execution faithfulness. KZG for weight commitment. Noir for alternative paths. Poseidon for fast fallback. StarkForge composes them so you don't have to choose.
Privacy works because the ZK composition makes it economically viable at every execution boundary. Commitment/nullifier rails, shielded pools, relayer networks, dark settlement, private governance — all confirmed live. The proof enforces the rule without revealing the data.
A fact registered in ObsqraFactRegistry on Madara L3 can propagate to Starknet L2 and settle to Ethereum L1 — all confirmed. FICO-pack ZK credentials travel cross-protocol. Any contract calls is_valid(fact_hash) without a backend dependency. The receipt is the trust.
is_valid(fact_hash) — no backend trustPicking one proof system means accepting its blind spots. Groth16 is fast but has a trusted setup. STARK has no trusted setup but can't verify ML inference natively. EZKL proves the model but can't enforce on-chain policy. Each system is incomplete. StarkForge composes all of them — so the output carries every guarantee simultaneously, and there is no single point of failure.
Most ZK systems have one settlement path. StarkForge has three — all confirmed live. A proof registered on Madara L3 can propagate to Starknet L2 and settle to Ethereum L1. Recursively. Each layer inheriting the security of the one above it.
Proof facts registered on OBSQRA_PROOF_CHAIN — the dedicated Madara L3 appchain. Cheapest path. Fastest finality. The primary settlement target for every StarkForge proof.
is_valid(fact_hash)L3 block validity proved to Starknet L2 via SNOS-style recursive proving. L3 proofs inherit the full security of the Starknet L2 consensus layer. Proof facts become L2-verifiable without re-proving.
Full tri-chain settlement path, confirmed live. Proof generated on L3, propagates to Starknet L2, bridges to Ethereum L1. Maximum finality — Ethereum's security model, all the way up.
The STARK integrity lane verifies through the Herodotus Integrity verifier on Starknet — the same storage proof infrastructure that underlies Starknet's historical state verification. StarkForge's STARK proofs settle through this path independently of the SNARK lane. No trusted setup. No ceremony dependency.
Builders choose their verification path. Use ObsqraFactRegistry on OBSQRA_PROOF_CHAIN for primary L3 settlement with the full StarkForge context. Or verify directly through the Herodotus Integrity verifier for STARK proofs that need to inherit Starknet's native storage proof infrastructure. Both paths are live. Neither requires trusting a backend.
Two independent proofs. Two different trust models. Both must clear before capital moves. This is the execution architecture that makes the composition more than the sum of its parts.
EZKL generates a Halo2 proof that a specific model produced a specific output from specific inputs. ModelBridge re-proves that in Groth16. Garaga verifies it on-chain via BN254 pairing in native Cairo. The Cairo policy gate only opens when this proof passes.
Stone prover wraps the entire execution trace — policy gates, constraint checks, settlement routing. The same prover that generates Starknet block validity proofs. Independent of the SNARK lane. No trusted setup. Security relies on collision-resistant hashing and DEEP-FRI.
FULL_DUAL_PROVER mode, both proofs must clear independently. A compromised trusted setup cannot forge a STARK. A STARK prover failure cannot fake a Groth16 commitment. Two systems, two trust models, one receipt that holds across both.
Five independent proving lanes behind one API. Call it, get a receipt you can verify on Voyager. Groth16, STARK, Noir HONK, native KZG, and hash fallback — each with a live transaction hash, each with a different trust model. No local prover. No configuration. One endpoint, the full composition.
The open-source Circom circuit that converts EZKL/Halo2 ML inference proofs into Groth16 commitments Cairo policy contracts enforce as execution gates. The composition that doesn't exist elsewhere in the ecosystem.
These are not examples or simulations. Five live verifier lanes running on Starknet Sepolia. Every one has a transaction hash on Voyager. If you don't believe the claim, verify the proof.
The live application built entirely on StarkForge's two primitives. zkde.fi is what the composition produces when it's applied to private DeFi. 316 on-chain receipts. 14/14 core claims validated. Nothing here requires trusting us — verify it at zkde.fi/test.
Private execution. Provable behavior.
Private swaps, lending, governance, prediction markets — the full DeFi surface, proof-gated. Your reputation is a ZK credential that gates what you can access without revealing the underlying data. The SNARK proves the AI output was correct. The STARK proves the execution was faithful. The receipt exists before the transaction does.
StarkForge composes these. None of them alone is enough. Together they are. Credit where it's due — and the composition is open source.
ONNX → KZG circuits. The zkML layer ModelBridge builds on.
SNARK verifierBN254 Groth16 in native Cairo. Where the SNARK lane settles.
STARK proverStarknet's block prover. Hosted via StarkForge Cloud.
Storage proofsBuilt the Integrity verifier StarkForge runs on.
Proving languageAztec's DSL. Powers the HONK lane in our stack.
L3 appchainFramework under OBSQRA_PROOF_CHAIN fact registry.
The composable ZK execution layer is live on Starknet Sepolia. These are the surfaces it opens — now and as the stack matures.
Private execution. Reputation-gated access. The SNARK-in-STARK loop applied to capital movement. 316 on-chain receipts. Live.
Six Groth16 verifiers that produce portable ZK credentials. Solvency, risk tier, trader performance, strategy integrity — provable without revealing the underlying data.
The private_vote circuit enables on-chain governance where votes are cryptographically valid but voter identity is never revealed. DAOConstraintManager live on Sepolia.
API key. Five proving lanes. ModelBridge open source.
Every claim has a transaction hash. Testnet live. Mainnet coming.