Read anywhere.
Compute in a TEE.
Write to any chain or API.
One programmable runtime. Pulls data from any source, runs your logic inside a chain-secured TEE, signs on any chain or API — with no backend to trust.
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, Founder
Lit 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, Founder
Lit 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-founder
Lit 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-founder
One 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. A chain-secured enclave.
Most cross-chain infra forces a tradeoff: trust a multisig, or wait for slow consensus on every read. Lit takes a different path. Code runs inside a TEE — an enclave the hardware itself cryptographically attests to. Keys never leave. Logs can't be rewritten.
The TEE's identity, its allowed code, and its signing authority are all governed on-chain. You get the speed and expressiveness of a single trusted runtime, with the auditability and on-chain governability of a smart contract.
Decentralized where it matters.
Fast where it has to be.
Things people are building right now.
Read. Compute. Write.
Anywhere.
One programmable runtime for everything that has to happen between an event and a signed action.