The verifiable integration layer for finance.
Deploy software verifiably to compute and sign across DeFi, centralized exchanges, and more.
Other wallet providers say non-custodial.Lit proves non-custodial.
Does your provider prove it?
Keys are generated and used only inside sealed TEEs. No operator, including Lit, can see or extract them.
A key’s authority is on-chain state on Base. It signs only what an immutable, content-addressed policy permits. Code, not an admin switch.
Every signature is a hardware-attested record, hardened by Proof of Cloud. Confirm the exact code running in the enclave.
There is no trusted operator. We run the network, but we can’t silently change what it runs — every upgrade is whitelisted on-chain by a multisig, open on Base.
Run any workload no one can see in.
Signing is just the start. Spin up a confidential microVM and run any code inside the same attested hardware that guards the keys. Your logic and data stay private from every operator — and every run leaves hardware-backed proof of exactly what ran.
- Any workload, not just signing
- Private from every operator, including us
- Hardware-attested: prove what ran
Live with design partners — onboarding is hands-on for now.
We run the infrastructure. You just start.
No managed sandbox to lock you in. Deploy in your own cloud or on-premise — your infrastructure, your keys, your governance — with the same attested guarantees wherever it runs.
Where this matters most.
Code-enforced, on-chain key control built for the GENIUS Act, verifiable by your own auditors.
A policy gate in a TEE that signs only the inventory moves your rules allow.
Mint, burn, freeze and seize, bound to immutable policy and provable to an auditor.
Lit Protocol's revolutionary programmable encryption transforms Emblem Vault into a living ecosystem where AI agents like Hustle operate autonomously across chains. By embedding intelligence directly into vaults, we're creating self-sovereign digital entities that execute complex cross-chain operations with unprecedented security.
Shannon, FounderLit Protocol enables us to provide unprecedented levels of data sovereignty and interoperability by using programmable keys that run on rules established by our protocol. Beacon Protocol's private data layer makes private data accessible to AI models and agents available across multiple chains and doesn't require centralized keys or a single point of failure like other data projects.
Phil, FounderLit is a cornerstone in our vision for frictionless, chain-abstracted payments. At Tria, we're building intent-driven, wallet-agnostic primitives where users can transact across ecosystems without technical hassles like juggling wallets, gas fees, bridging etc. lit's programmable key management gives us the cryptographic trust layer to make that magic possible. Together, we're turning decentralized auth from a dev tool into a superpower for mainstream payments.
Parth, Co-founderLit Protocol transformed our products through trustless multiparty compute. For Genius Bridge Protocol, Lit's encrypted runtime powers our universal solver - a decentralized agent using native DEX liquidity for faster, cheaper cross-VM intents without centralized relayers. With Genius Terminal, Lit's programmable encryption enables non-custodial multi-wallet management, DCAs, limit orders, and stop losses. Lit isn't just technology - it's the foundation for our next-gen DeFi solutions.
Brihu, Co-founderOne file. Reads, computes, signs across chains.
A Lit Action is JavaScript that runs inside the network’s TEE. Deploy it once. Sign with a wallet bound to the action code itself, or with one you control through your own on-chain governance.
// Inside a Lit Action — runs in a chain-secured TEE
// Read off-chain
const price = await fetch(
"https://api.coinbase.com/v2/prices/ETH-USD/spot"
).then(r => r.json());
// Read on-chain (Base)
const base = new ethers.providers.JsonRpcProvider(BASE_RPC);
const vault = new ethers.Contract(vaultAddress, vaultAbi, base);
const ratio = await vault.currentRatio();
// Decide, then sign + broadcast on Arbitrum
if (Number(price.data.amount) * Number(ratio) < threshold) {
const pk = await Lit.Actions.getLitActionPrivateKey();
const arb = new ethers.providers.JsonRpcProvider(ARB_RPC);
const wallet = new ethers.Wallet(pk, arb);
const hook = new ethers.Contract(hookAddress, hookAbi, wallet);
const tx = await hook.rebalance();
Lit.Actions.setResponse({ response: tx.hash });
}Speed of a backend, trust of a contract.
Your code runs in hardware, so it moves at backend speed. Its authority lives on-chain: smart contracts on Base decide which keys it can use and which code is allowed to run, with every change auditable on Basescan and impossible for any one party to push alone.
Read. Compute. Write.
Anywhere.
One programmable runtime for everything that has to happen between an event and a signed action.