The only ZK system where AI proves its work before capital moves.
Hide everything.
Prove anything.
trust = Σ(receipts)*
*earned over time, never assumed
Built for traders who want private execution and builders who want verifiable agents. Your strategy stays hidden. Your AI agents prove they behaved. Your track record travels with you — without revealing who you are.
zkde.fi is the protocol. Obsqra Labs (opens in new tab) builds it. StarkForge (opens in new tab) is the proving layer underneath.
How it works
Five steps. One receipt.
Every action produces a cryptographic proof that feeds back into your reputation.
Strategy
Your private conditions compile into a provable circuit
Proof
EZKL generates a Halo2 SNARK — conditions met, nothing revealed
Verify
Garaga checks the proof on-chain using pairing math
Execute
Capital moves only if both proof systems agree
Receipt
On-chain evidence feeds back into your reputation score
Full Proof
Both proofs verified on-chain. No intermediary. The contract won't execute unless the math checks out.
Vault deposits, privacy pool entries, on-chain settlement
Batched
Proof generated off-chain, receipt committed on-chain. You can verify it anytime — it's batched for speed.
Agent trades, risk scoring, strategy analysis
Autopilot
You set the rules, the agent acts within them. Like a session key — but proof-gated.
Auto-rebalancing, LP management, yield harvesting
Live Demo
The Loop
How does a trader execute privately without losing their track record?
Three answers. One loop.
Reputation
Your reputation, proven privately.
Your DeFi history — positions, protocols, capital — is compressed into a single ZK identity proof. Protocols see your tier and credit class. They never see your wallet, your balances, or your strategy. The proof travels with you.
Identity Proof
EZKL Halo2 circuit proves your reputation tier without revealing inputs. Verifiable on any chain.
Private Compliance
Protocols verify your tier without seeing your wallet. W3C Verifiable Credential standard.
Reputation Receipts
Every action produces a nullified receipt. Your reputation grows with each verified execution.
Selective disclosure on demand. Protocols verify your tier without seeing your wallet. Regulators can request disclosure. You control the key.
Try the loop in one click · No wallet needed
Oracle
Verified data for your agent.
62+ pools from 5 Starknet protocols, AI-scored across 13 circuit checks and zkML-attested. Your agent picks the best opportunity — and can prove it saw legitimate data, ran the right model, and made a correct decision.
Execution
The trade fires. The loop closes.
The oracle result pre-fills the execution path. The agent simulates, executes, and generates a ZK receipt — all in one click. No valid proof means no execution. Every receipt feeds back into your reputation passport. The loop closes.
Complete Step 2 to see the top recommendation.
Building an agent? The same proof pipeline is available as an API. Start at zkde.fi/docs →
The problem
Transparency is the tax.
To use DeFi today, you reveal everything — what you're buying, how much, and when. Others see it before you execute.
Privacy as control.
What if privacy didn't just hide information — but controlled what's allowed to happen? Proofs replace trust. Receipts replace promises.
your strategy → private proof → "conditions met" execution → capital moves receipt → on-chain evidence
On-chain reputation scores exist. ZK-proved reputation that travels cross-protocol without disclosure doesn't.
Why now
Privacy is becoming the default.
Every major L2 is shipping privacy features. The question isn't if DeFi goes private — it's who builds the proof layer first.
Proving economics keep improving.
Recursive STARKs run on Stone in production today. S-two is Starknet's next proving milestone—we're building toward it, not claiming it yet.
Agents are moving real money.
EigenLayer, Coinbase AgentKit, ElizaOS — none can prove their agents behaved. We can.
How we're different
zkML proofs, not analytics
Cred Protocol, Spectral, and ArcX score wallets. We prove the score in ZK — it travels cross-protocol without revealing your data.
Agents gated, not just attested
EigenAI and Lagrange prove inference. We gate capital movement on it. The proof unlocks or blocks the trade.
Math, not hardware trust
TEE-based compute trusts the chip manufacturer. ZK proofs trust math. Post-Tornado-Cash, that distinction matters.
Dual verification
How We Prove It
Two independent proof systems check every claim. Both must pass. Neither can be faked.
The math proof
Garaga verifies the SNARK on Starknet
Your AI model runs off-chain and produces a cryptographic proof. Garaga checks that proof on-chain using the same math that secures Ethereum. If the math doesn't check out, nothing executes.
The execution proof
Stone wraps execution in a STARK today — S-two next
The same class of prover that secures Starknet blocks can wrap your entire execution in a second proof. The first proof lives inside this one. Both pass or nothing happens. S-two will take this further when it ships; we're aligned with that path.
Settlement path
Madara L3→Starknet L2→Ethereum L1
316+ verified execution receipts on-chain. Every hash queryable via RPC. Verify every claim →
Deployed infrastructure
What's Live
11 contracts, 3 chains, 316+ verified execution receipts on-chain — everything below is deployed and queryable right now.
Move Money Privately
Deposit, withdraw, and transfer without revealing amounts or destinations. Three privacy levels — from full proof to optimistic batching.
3 privacy tiers · All proved · Dark L3 settlement
AI Agents That Prove Their Work
Every agent decision runs through 13 skill checks before execution. The agent can't act unless all proofs pass.
13 checks per trade · All must pass · Receipts on-chain
Predictions You Can Check
Predictions committed on-chain before the outcome, then scored publicly. No cherry-picking. Every forecast has a receipt.
0.109 Brier score · 100% direction calls · 3 time horizons
Why Starknet
Cheap proof verification
Native STARK verification at L2 cost. The same math that secures Ethereum runs on-chain for pennies.
Private by design
Cairo enforces rules without revealing them. Your strategy compiles into something provable, not readable.
Real computation
ML models settle on-chain through the same STARK stack that secures Starknet. Stone proves that path today; S-two is the next efficiency step on the roadmap.
Tri-chain deployment
7 Cairo contracts
4 EVM contracts
EZKL KZG auto-generated
Stateful registry
Composable receipts
Cross-chain sync
OBSQRA_PROOF_CHAIN
Block time
Gas cost
Progress
Roadmap
Where we are — and where we're going.
Phases 1–2 — Foundation + ModelBridge
Complete- Double-entry vault ledger, privacy commitment & nullifier rails
- 31 circom circuits (WASM + zkey) · 7 Cairo + 4 EVM contracts deployed
- Open-source ModelBridge: zkML → circuit proof gate
- Garaga on-chain KZG verifier · Stone prover integration
- L3 hash-verified receipt pipeline on Madara
Phase 3 — Intelligence Layer
In Progress- zkML-gated agent composition (13 skill circuits per opportunity)
- Trust receipt pipeline with SHA-256 commitments
- Private prediction market with commit-reveal-score lifecycle
- Tri-chain settlement: Madara L3 → Starknet L2 → Ethereum L1
Phase 4 — Fully Recursive
In Progress- SNARK-in-STARK recursive proof composition
- Batch N zkML proofs → single Starknet verification
- Cross-chain portable risk profiles via BridgeRelay
- Noir HONK bridge + native Cairo KZG lanes
Phase 5 — Mainnet
Next- Starknet + Ethereum mainnet deployment
- Production Madara L3 with economic security
- Capital OS: portfolio management, auto-rebalance, LP orchestration
- StarkForge S-two integration — 100× proving cost reduction
Protocol
About zkde.fi
zkde.fi is building private DeFi infrastructure for a world that should not have to choose between privacy and verifiability.
zkde.fi is a privacy-first DeFi protocol on Starknet focused on proof-gated execution, compliant privacy, and portable reputation—so users and agents can act privately while still proving behavior met policy and protocol constraints.
Founder
Aaron Faulkner
Founder, zkde.fi
Web3 marketer-turned-builder with a decade-plus across blockchain, community, content, and protocol growth. zkde.fi grew out of a frustration with trust-heavy systems that asked users to believe what they could not verify—privacy-first infrastructure where execution can be proven, not merely promised.
Get started
The infrastructure is live.
Build on it.
API docs, circuit specs, and the open-source ModelBridge are all available. The infrastructure layer is StarkForge.