Psy · an independent ZK-native public blockchain
The chain that validates proofs, not plaintext.
Psy is its own public blockchain — its own consensus, its own state, its own proofs. It is not built on top of any other network. Users prove their own transactions, so privacy is the default and throughput grows by adding provers. It is a foundation for private payments, confidential finance, and autonomous AI agents.
The inversion
Most chains that offer privacy bolt a shielded pool onto an otherwise transparent, single-file ledger. Psy inverts the design: state is partitioned per account, and the network accepts client-generated zero-knowledge proofs instead of replaying everyone's transactions in public. The result is a chain that is private by construction and parallel by construction — the same property makes confidentiality the default and lets capacity scale horizontally.
Why the architecture is different
Six advantages, one root
Conflict-free parallelism (PARTH)
State is a forest of per-account, per-contract trees. You write only to your own branches and read the last finalized snapshot of everyone else's. Because no two users contend for the same state, their execution and proving are independent — so capacity grows by adding stateless provers, not by raising limits on a single shared machine.
You prove your own transactions
Each user (or a prover they delegate to) builds a compact proof of their own activity. The network only verifies and aggregates — it never needs to see your plaintext to accept your transaction. This single fact is the root of both Psy's privacy and its scalability.
Confidentiality, not a bolt-on pool
Every account already holds private per-contract state, so confidentiality composes with application logic rather than being limited to transfers. Balances, transfers, and an application's internal state can all be shielded — programmable privacy, not just a private send.
Recursive zero-knowledge proofs
Psy uses recursive proofs (Plonky2 over the Goldilocks field, with Poseidon hashing) to compress the activity of an entire block — potentially millions of transactions — into one short proof of the whole chain's validity. Verifying the chain means verifying a single proof.
Smart contracts compile to circuits
Contracts are written in Psy's own language and compiled into zero-knowledge circuits. Every state change a contract makes is provable, and only verified, whitelisted code can touch state at all — a strong base for computation you can trust without re-running it.
Scoped, provable authority
Accounts, zero-knowledge signatures, and software-defined keys let you grant scoped, revocable, provable authority — to a service, or to an autonomous agent — without ever handing over your underlying key. The agent acts on your behalf and proves it stayed within the bounds you set.
How it works
Prove. Aggregate. Finalize.
Validity flows from the edge inward — millions of self-generated proofs, recursively compressed into one.
Prove locally
Your wallet — or a prover you choose — builds a compact proof of your transactions against the last finalized state. Your plaintext never leaves your control.
Aggregate in parallel
The network recursively combines proofs from many users at once, sharded across independent provers. Adding provers adds capacity; there is no single sequencer everyone must wait behind.
Finalize succinctly
All of that activity collapses into one succinct proof of the new state, anchored to the previous one. The chain advances as an unbroken sequence of verified snapshots.
State itself is private by partition: each account holds its own per-contract trees, so two users never touch the same data — the same property that keeps the chain confidential is what lets it run in parallel.
What you can build
Three frontiers
Money that moves quietly
Private payments
Settlement you can prove without an audience. Counterparties and amounts stay between the parties; validity and the absence of double-spends stay public.
Confidential transfers
Send value while hiding counterparties and amounts, with validity and no-double-spend still proven on-chain.
Familiar assets, made private
Bring assets across the bridge from external chains and hold them in a shielded form — a familiar unit of account that moves confidentially.
Payroll & B2B settlement
Keep salaries and invoices confidential between parties, while remaining disclosable to an authorized auditor through selectively shared keys.
Streaming & recurring flows
Run many small, private, recurring payments at once — per-account partitioning means they never queue behind a global bottleneck.
Markets without the leak
Confidential finance
Prove solvency, not positions. Because reads see only the previous finalized state, there is far less room to front-run what others are about to do.
Dark pools & private order flow
Match and settle trades with size and identity hidden; the settlement is proven correct without broadcasting intent to the mempool.
Private lending & credit
Prove solvency or creditworthiness in zero knowledge — enabling reputation- or proof-based credit without exposing a borrower's full position.
Tokenized real-world assets
Hold private cap tables and coupon flows for tokenized funds and bonds, with disclosure available to regulators and auditors only.
Parallel settlement at scale
No shared pool to contend over means many independent positions settle in parallel rather than serially.
Autonomy you can verify
Autonomous AI agents
Agents need autonomous keys, micro-payment throughput, private strategy, and verifiable behavior. Psy provides all four from one model — the network checks proofs, not the agent's secrets.
Agents that prove their own actions
An agent acts under a scoped, revocable delegation from its principal — transacting and updating state autonomously without ever holding the principal's key.
Machine-scale private micropayments
Parallel per-account execution suits high-frequency, low-value, agent-to-agent settlement — with amounts and counterparties shielded.
Provable policy compliance
Because each contract function is a circuit, an agent can prove it stayed within a budget, a risk limit, or a whitelist — without revealing its inputs or strategy.
Private agent memory
An agent's on-chain state lives in its own account trees, confidential by default — its competitive strategy is never leaked to the mempool or to rivals.
Psy connects to external networks like Ethereum through a bridge: assets cross in and out, and Psy's own proofs can be checked there. Psy is not built on top of any of them — it stands on its own.
Psy is its own chain — sovereign, private, and built to be verified rather than trusted.