TinyZKP
@logannye
A height-compressed, sublinear-space STARK prover. Designed to make very long zero-knowledge proofs practical on fixed-memory hardware (CPUs, GPUs, & edge devices). Post-quantum. Built in Rust.
Overview
What is TinyZKP?
TinyZKP mints a tamper-evident zero-knowledge proof that a state-transition chain is consistent — start at X, apply these steps, provably reach Y — so an agent or API caller can hand over a verifiable receipt instead of requiring trust. It provides transparent, post-quantum STARK-style proofs with an O(√T) prover-memory architecture, no trusted setup, and verification in milliseconds. It serves developers, AI agents, and API users who need verifiable state-transition receipts.
How to use TinyZKP?
Install the MCP server for AI agents (Claude, GPT, Cursor) via claude mcp add --transport http tinyzkp https://mcp.tinyzp.com, then call its proof tools as native function calls. Alternatively, use the terminal CLI via npx @tinyzp/cli or the plain HTTP API at https://api.tinyzzp.com with an API key from tinyzzp.com/signup. Verification is always free and works in the browser via the WASM package @tinyzzp/verify.
Key features of TinyZKP
- O(√T) prover memory vs standard STARK O(T) — ≈4,096× reduction measured
- Verification in polylog time, always free
- Transparent (no trusted setup) and post-quantum (hash-based)
- SDKs for Python, TypeScript, and Rust
- MCP server for native AI agent integration (Claude, GPT, Cursor)
- Browser WASM verifier with no server or API key required
Use cases of TinyZKP
- State machine attestation: prove a sequence of state transitions without revealing intermediate values
- Audit-log checkpoints: generate a tamper-evident receipt that a log transitioned from one hash to another through a series of entries
- AI agent verifiable receipts: an agent hands over a proof that its chain-of-thought or action sequence reached a stated outcome
- API state transition proofs: two systems prove they agree on a sequence of values without exposing the data itself
FAQ from TinyZKP
What does TinyZKP prove that other schemes don't?
TinyZKP proves state-transition chain consistency with a transparent (no trusted setup) STARK that uses an O(√T) prover-memory architecture, unlike standard STARKs which require O(T) memory. This makes long traces practical without reserving high-RAM servers.
What are the runtime dependencies?
The CLI requires Node 18+ ESM. The Python SDK works with Python 3 and pip install tinyzkp. The TypeScript SDK ships a dual ESM+CJS build for Node 18+, bundlers, and edge runtimes. The WASM verifier works in any modern browser.
Where does proof data live?
Proving jobs are submitted to the hosted API at api.tinyzp.com; job and proof data reside on TinyZKP's servers during the lifecycle. Verification can be done client-side via the WASM verifier without sending proof data to any server.
What transports and authentication are available?
The MCP endpoint supports HTTP transport and is publicly rate-limited (no API key required). The full HTTP API uses HTTPS with bearer token authentication (API key tzk_...). The WASM verifier and CLI can verify proofs locally with no network call.
What are the known limits?
Free tier: 100 proofs per month, 1 in‑flight job, 10 RPM, $5/mo cap. Developer plan: 4 in‑flight, 100 RPM, $500/mo cap. Proofs under 10K trace steps cost $0.05/proof; longer traces cost more per step. Verification is always free and unlimited.
