Get Started

Follow the EigenX CLI documentation to deploy your application to EigenCompute.

While in Alpha an allowlisted account is required to create apps. Use an existing address with eigenx auth login or generate a new address with eigenx auth generate, then submit an onboarding request:

Request Onboarding Access

EigenCompute Overview

EigenCompute enables developers to deploy verifiable applications: containerized services that receive their own cryptographic identity, allowing them to hold funds, sign transactions, and operate autonomously.

Understanding Verifiable Applications

Traditional applications require users to trust developers with both code execution and key management. Smart contracts eliminated this trust requirement but introduced severe constraints: prohibitive gas costs, limited computational power, and restricted programming models.

EigenCompute provides a third path: applications that offer cryptographic guarantees about their behavior while retaining the flexibility and performance of traditional computing.

How It Works

When you deploy to EigenCompute, your application gets:

1. Hardware-isolated execution: Your app runs inside Intel TDX, a secure enclave with encrypted memory that generates cryptographic proof of the exact Docker image running inside.

2. A dedicated wallet: Each application receives a unique wallet. Only that specific app, running the verified Docker image in the enclave, can retrieve the private key.

3. Secure secret management: Environment variables that are encrypted locally and only accessible within the TEE.

4. On-chain deployment record: Every deployment is permanently recorded on-chain by its Docker digest, creating an immutable audit trail.

5. Network access: Optionally expose ports for HTTP endpoints, or configure HTTPS with a custom domain.

This creates truly autonomous applications - code that holds its own funds with cryptographic proof of what it will do with them.

Get Started

Install the CLI and join the mainnet alpha:

curl -fsSL https://eigenx-scripts.s3.us-east-1.amazonaws.com/install-eigenx.sh | bash

Sign up for mainnet alpha access →

Try It Out

$eigenx app create my-trading-bot typescript

⏎ Click anywhere or press Enter to run this command

Deploy Your Own →

Practical Applications

Autonomous Trading Systems

Traditional trading bots require depositing funds into developer-controlled wallets. With EigenCompute, the bot itself holds the funds:

// Bot receives its deterministic wallet
const wallet = mnemonicToAccount(process.env.MNEMONIC)

// Bot executes strategy autonomously
if (await meetsTradingConditions()) {
  await executeSwap(wallet, userDeposit)
}

Funds are sent directly to the bot's address, with only the verified trading logic able to access them.

Verifiable Social Media

Social platforms can prove their ranking algorithms work as claimed:

// Transparent content ranking
const posts = await fetchUserFeed(userId)
const engagement = await getEngagementMetrics(posts)

// Verifiable algorithm execution
const ranked = posts.sort((a, b) => {
  // Public ranking logic
  return (b.likes * 0.3 + b.comments * 0.5 + b.shares * 0.2) -
         (a.likes * 0.3 + a.comments * 0.5 + a.shares * 0.2)
})

// Sign the feed to prove no manipulation
const signature = await wallet.signMessage({
  userId,
  algorithm: 'engagement_v1',
  feed: ranked.map(p => p.id)
})

The feed ranking algorithm is verifiable and transparent, preventing manipulation.

Verifiable Gaming

Build high-performance games with provable fairness and on-chain assets:

// Game server controls tournament funds
const wallet = mnemonicToAccount(process.env.MNEMONIC)
const tournament = await getTournamentState()

// Verifiable game logic
async function processGameRound(players, moves) {
  // Deterministic game state updates
  const outcomes = calculateOutcomes(moves, seedFromBlockhash)

  // Update player tokens on-chain
  for (const winner of outcomes.winners) {
    await wallet.sendTransaction({
      to: winner.address,
      value: tournament.prizePool / outcomes.winners.length
    })
  }

  return outcomes
}

Game logic is verifiable and tournament prizes are distributed according to transparent rules.

Technical Comparison

Capability	EigenCompute	Smart Contracts	Traditional Apps
Trust Model	Verify code via attestation	Verify on-chain bytecode	Trust developer
Key Management	Platform-controlled, attestation-gated	Protocol-controlled	Developer-controlled
Data Privacy	Encrypted memory, isolated execution	All data public on-chain	Depends on developer
Languages	Any	Solidity/Vyper	Any
External APIs	Direct HTTPS	Oracle-only	Direct HTTPS
Compute Power	Up to 176 vCPUs, 704GB RAM	Gas-limited	Unlimited

Security Model

Trust Requirements

EigenCompute currently requires trust in:

• Intel TDX hardware security guarantees
• Google Confidential Space attestation service
• Single KMS operator (being decentralized via threshold cryptography)

Security enhancements in development:

• Public attestation endpoints for runtime verification
• Threshold KMS for distributed key management
• Replica prevention via onchain checks and heartbeats
• Verifiably built images with reproducible builds

Documentation

• Quickstart Guide - Deploy your first app in 5 minutes
• CLI Commands - Complete command reference
• Architecture Guide - Deep dive into how EigenCompute works
• Core Concepts - Understanding keys, security, and best practices