eigen-skills 1.1.4 → 1.1.5

package/README.md

@@ -139,6 +139,16 @@ mkdir -p .claude/skills/eigen
 curl -o .claude/skills/eigen/SKILL.md https://raw.githubusercontent.com/zeeshan8281/eigen-agent-skills/main/SKILL.md
 ```
 
+### As an MCP Server (Claude Desktop, Cursor, Windsurf, Claude Code)
+
+Install the separate [`eigen-mcp`](https://www.npmjs.com/package/eigen-mcp) package for MCP support — all 21 tools, no SKILL.md files or curl needed:
+
+```bash
+npm install -g eigen-mcp
+```
+
+See the [eigen-mcp README](https://www.npmjs.com/package/eigen-mcp) for config examples for Claude Desktop, Cursor, Windsurf, and Claude Code.
+
 ### For Programmatic Use (JavaScript)
 
 ```javascript

package/SKILL.md

@@ -1,249 +1,218 @@
 ---
 name: eigen-skills
-description: "Query live EigenLayer data — restaking, operators, AVS, rewards, delegation, stakers, TVL, deposits, withdrawals, EigenCompute TEE, and EigenDA blob storage via EigenExplorer API"
-version: 1.0.1
+description: "Deploy any app to EigenCompute TEE — hardware-isolated Trusted Execution Environments with encrypted memory, sealed secrets, and cryptographic attestation"
+version: 1.1.5
 metadata:
-  emoji: "🔄"
-  tags: ["eigenlayer", "restaking", "avs", "operators", "rewards", "delegation", "eigencompute", "eigenda"]
+  emoji: "🔒"
+  tags: ["eigencompute", "tee", "deploy", "ecloud"]
 user-invocable: true
 ---
 
-# EigenLayer Skills for Claude Code
+# EigenCompute Deploy Skill
 
-One-command integration: drop this file into your project and Claude Code can query live EigenLayer data.
+One-command integration: install this skill and Claude Code can deploy any app to EigenCompute TEE.
 
-## Setup
-
-```bash
-curl -o SKILL.md https://raw.githubusercontent.com/zeeshan8281/eigen-agent-skills/main/SKILL.md
-```
-
-Get a free API key at https://developer.eigenexplorer.com and set it:
-
-```bash
-export EIGEN_API_KEY="your-key-here"
-```
-
-## Data Source
-
-**EigenExplorer API** — `https://api.eigenexplorer.com`
-- Auth: `x-api-token` header
-- Testnet: `https://api-holesky.eigenexplorer.com`
-
----
-
-## 1. Ecosystem Metrics
-
-Use when the user asks about EigenLayer stats, total TVL, total stakers, total operators, or an ecosystem overview.
-
-### Get ecosystem metrics
-```bash
-curl -s "https://api.eigenexplorer.com/metrics" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get historical TVL
 ```bash
-curl -s "https://api.eigenexplorer.com/metrics/historical/tvl" -H "x-api-token: $EIGEN_API_KEY"
+npm install eigen-skills
 ```
 
 ---
 
-## 2. Operators
-
-Use when the user asks about EigenLayer operators, top operators, operator details, or operator search.
+## FIRST-TIME SETUP (do these once)
 
-### List operators (sorted by staker count)
+### Step 1: Install the ecloud CLI
 ```bash
-curl -s "https://api.eigenexplorer.com/operators?withTvl=true&sortByTotalStakers=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+npm install -g @layr-labs/ecloud-cli
 ```
 
-### List operators by TVL
+### Step 2: Generate keys and authenticate
+For new users who have never used ecloud before:
 ```bash
-curl -s "https://api.eigenexplorer.com/operators?withTvl=true&sortByTvl=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+ecloud auth generate --store
 ```
+This generates a new private key AND stores it in the OS keyring in one step.
 
-### List operators by APY
+If they already have a private key:
 ```bash
-curl -s "https://api.eigenexplorer.com/operators?withTvl=true&sortByApy=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+ecloud auth login
 ```
+This will prompt them to paste their existing private key.
 
-### Search operators by name
+### Step 3: Verify authentication
 ```bash
-curl -s "https://api.eigenexplorer.com/operators?searchByText=NAME&withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
+ecloud auth whoami
 ```
+Should show their address and "stored credentials".
 
-### Get a specific operator
+### Step 4: Subscribe to billing (required before first deploy)
 ```bash
-curl -s "https://api.eigenexplorer.com/operators/0xOPERATOR_ADDRESS?withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
+ecloud billing subscribe
 ```
-
-### Get stakers delegating to an operator
+Check status:
 ```bash
-curl -s "https://api.eigenexplorer.com/operators/0xOPERATOR_ADDRESS/stakers?take=20" -H "x-api-token: $EIGEN_API_KEY"
+ecloud billing status
 ```
 
-### Get all operator addresses (lightweight)
+### Step 5: Ensure Docker is installed and running
+Docker Desktop (or docker daemon) must be running. The deploy process builds and pushes images. Check with:
 ```bash
-curl -s "https://api.eigenexplorer.com/operators/addresses" -H "x-api-token: $EIGEN_API_KEY"
+docker info
 ```
+If Docker is not running, start Docker Desktop:
+- macOS: `open -a Docker`
+- Then wait for `docker info` to succeed before proceeding.
 
 ---
 
-## 3. Stakers
+## DEPLOYING AN APP (full playbook)
 
-Use when the user asks about a specific staker's position, deposits, withdrawals, or delegation.
+**CRITICAL: The `ecloud compute app deploy` CLI is fully interactive with 6+ prompts. It CANNOT be run directly from a non-interactive shell. You MUST use an expect script to automate the prompts.**
 
-### Get staker info
-```bash
-curl -s "https://api.eigenexplorer.com/stakers/0xSTAKER_ADDRESS" -H "x-api-token: $EIGEN_API_KEY"
-```
+### Step 1: Ensure the project has a Dockerfile
+If the project does not have a Dockerfile, generate one based on the project type:
 
-### Get staker deposits
-```bash
-curl -s "https://api.eigenexplorer.com/stakers/0xSTAKER_ADDRESS/deposits?take=20" -H "x-api-token: $EIGEN_API_KEY"
+**Node.js:**
+```dockerfile
+FROM node:20-slim
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci --omit=dev
+COPY . .
+EXPOSE 3000
+CMD ["node", "index.js"]
 ```
 
-### Get staker withdrawals
-```bash
-curl -s "https://api.eigenexplorer.com/stakers/0xSTAKER_ADDRESS/withdrawals?take=20" -H "x-api-token: $EIGEN_API_KEY"
+**Python:**
+```dockerfile
+FROM python:3.12-slim
+WORKDIR /app
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["python", "main.py"]
 ```
 
-### Get staker rewards
-```bash
-curl -s "https://api.eigenexplorer.com/stakers/0xSTAKER_ADDRESS/rewards" -H "x-api-token: $EIGEN_API_KEY"
+**Go:**
+```dockerfile
+FROM golang:1.22-alpine AS builder
+WORKDIR /app
+COPY go.* ./
+RUN go mod download
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o server .
+FROM alpine:3.19
+COPY --from=builder /app/server /server
+EXPOSE 8080
+CMD ["/server"]
 ```
 
----
-
-## 4. AVS (Actively Validated Services)
-
-Use when the user asks about AVS, which services exist, operators/stakers per AVS, or comparing AVS.
-
-### List all AVS (sorted by TVL)
-```bash
-curl -s "https://api.eigenexplorer.com/avs?withTvl=true&sortByTvl=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+**Rust:**
+```dockerfile
+FROM rust:1.77-slim AS builder
+WORKDIR /app
+COPY . .
+RUN cargo build --release
+FROM debian:bookworm-slim
+COPY --from=builder /app/target/release/app /app
+EXPOSE 8080
+CMD ["/app"]
 ```
 
-### List AVS by APY
-```bash
-curl -s "https://api.eigenexplorer.com/avs?withTvl=true&sortByApy=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+Also create a `.dockerignore`:
 ```
-
-### Search AVS by name
-```bash
-curl -s "https://api.eigenexplorer.com/avs?searchByText=NAME&withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
+node_modules
+.git
+target
+__pycache__
 ```
 
-### Get a specific AVS
+### Step 2: Build the Docker image
+**IMPORTANT: Must build for linux/amd64 — EigenCompute TEEs run on x86_64.**
 ```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS?withTvl=true" -H "x-api-token: $EIGEN_API_KEY"
+docker build --platform linux/amd64 -t <REGISTRY_USER>/<APP_NAME>:latest .
 ```
 
-### Get operators registered to an AVS
+### Step 3: Push to a container registry
+The image must be in a public registry (Docker Hub or GHCR) so EigenCompute can pull it.
 ```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/operators?take=20" -H "x-api-token: $EIGEN_API_KEY"
+docker push <REGISTRY_USER>/<APP_NAME>:latest
 ```
 
-### Get stakers for an AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/stakers?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
+### Step 4: Deploy using an expect script
+Create a file called `deploy.exp` and run it with `expect`. This handles all interactive prompts:
 
-### Get rewards distributed by an AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/rewards" -H "x-api-token: $EIGEN_API_KEY"
-```
+```expect
+#!/usr/bin/expect -f
+set timeout 300
 
-### Get registration events for an AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/events/registration?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
+spawn ecloud compute app deploy --name "<APP_NAME>" --image-ref "<REGISTRY_USER>/<APP_NAME>:latest" --skip-profile --log-visibility public
 
-### Get operator-sets for an AVS
-```bash
-curl -s "https://api.eigenexplorer.com/avs/0xAVS_ADDRESS/operator-sets?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
+# Prompt 1: Build from verifiable source? -> No
+expect "Build from verifiable source?"
+send "n\r"
 
----
+# Prompt 2: Choose deployment method -> "Deploy existing image from registry" (arrow down once)
+expect "Choose deployment method:"
+send "\033\[B\r"
 
-## 5. Rewards & Yield
+# Prompt 3: Env file -> "Continue without env file" (arrow down once)
+# If the project has a .env file, select "Enter path to existing env file" instead (just press enter)
+expect "Choose an option:"
+send "\033\[B\r"
 
-Use when the user asks about rewards, APY, yield, best operators/AVS by returns, or how much a staker is earning.
+# Prompt 4: Instance type -> default g1-micro-1v (just press enter)
+# Use arrow keys to select a larger instance if needed
+expect "Choose instance:"
+send "\r"
 
-### Top operators by APY
-```bash
-curl -s "https://api.eigenexplorer.com/operators?withTvl=true&sortByApy=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
-```
+# Prompt 5: Resource usage monitoring -> Yes (just press enter)
+expect "resource usage"
+send "\r"
 
-### Top AVS by APY
-```bash
-curl -s "https://api.eigenexplorer.com/avs?withTvl=true&sortByApy=desc&take=10" -H "x-api-token: $EIGEN_API_KEY"
+# Catch any remaining prompts
+expect {
+    "Confirm" { send "y\r"; exp_continue }
+    "(y/N)" { send "y\r"; exp_continue }
+    "(Y/n)" { send "y\r"; exp_continue }
+    eof { }
+}
 ```
 
-### Get rewards for a specific operator
+Run it:
 ```bash
-curl -s "https://api.eigenexplorer.com/operators/0xOPERATOR_ADDRESS/rewards" -H "x-api-token: $EIGEN_API_KEY"
+chmod +x deploy.exp && expect deploy.exp
 ```
 
----
-
-## 6. Deposits & Withdrawals (Global)
-
-Use when the user asks about recent deposits/withdrawals across the whole protocol.
-
-### Get recent deposits
-```bash
-curl -s "https://api.eigenexplorer.com/deposits?take=20" -H "x-api-token: $EIGEN_API_KEY"
+The output will contain the **App ID** and **IP address** on success:
 ```
-
-### Get recent withdrawals
-```bash
-curl -s "https://api.eigenexplorer.com/withdrawals?take=20" -H "x-api-token: $EIGEN_API_KEY"
+App ID: 0x...
+App is now running with IP: x.x.x.x
 ```
 
----
-
-## 7. Delegation & Events
-
-Use when the user asks about delegation events, who is delegating to whom, or operator registration events.
-
-### Get delegation events
+### Step 5: Verify the deployment
 ```bash
-curl -s "https://api.eigenexplorer.com/events/delegation?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get operator registration events
-```bash
-curl -s "https://api.eigenexplorer.com/events/registration-status?take=20" -H "x-api-token: $EIGEN_API_KEY"
-```
-
-### Get all operator-sets
-```bash
-curl -s "https://api.eigenexplorer.com/operator-sets?take=20" -H "x-api-token: $EIGEN_API_KEY"
+ecloud compute app list
+ecloud compute app info <APP_ID>
 ```
 
 ---
 
-## 8. EigenCompute (TEE)
+## Instance types available
 
-Use when the user asks about deploying to EigenCompute, TEE, EigenCloud, attestation, or app management.
+| Instance | Specs | TEE Type |
+|----------|-------|----------|
+| g1-micro-1v | 2 shared vCPUs, 1 GB RAM | Shielded VM (default) |
+| g1-medium-1v | 2 shared vCPUs, 4 GB RAM | Shielded VM |
+| g1-custom-2-4096s | 2 vCPUs, 4 GB RAM | SEV-SNP |
+| g1-standard-2s | 2 vCPUs, 8 GB RAM | SEV-SNP |
+| g1-standard-4t | 4 vCPUs, 16 GB RAM | TDX |
+| g1-standard-8t | 8 vCPUs, 32 GB RAM | TDX |
 
-**Requires:** `npm install -g @layr-labs/ecloud-cli`
-
-### Authentication
-```bash
-ecloud auth login
-ecloud auth whoami
-```
+---
 
-### Deploy an app
-```bash
-ecloud compute app create --name my-app --language typescript
-ecloud compute app deploy
-```
-Always use **"Build and deploy from Dockerfile"** — deploy from registry is unreliable.
+## Manage deployed apps
 
-### Manage apps
 ```bash
 ecloud compute app list
 ecloud compute app info <APP_ID>
@@ -254,75 +223,25 @@ ecloud compute app terminate <APP_ID>
 ecloud compute app upgrade <APP_ID>
 ```
 
-### Set sealed secrets
+---
+
+## Set sealed secrets (encrypted env vars, decrypted only inside TEE)
+
 ```bash
 ecloud compute app env set MY_SECRET="value" API_KEY="key"
 ```
 
-### TEE attestation
-Inside the TEE, the KMS signing key is at `/usr/local/bin/kms-signing-public-key.pem`. Verify at `https://verify-sepolia.eigencloud.xyz`.
-
 ---
 
-## 9. EigenDA (Data Availability)
-
-Use when the user asks about storing/retrieving data on EigenDA, blob storage, or data availability.
-
-**Requires:** EigenDA Proxy running locally:
-```bash
-docker run -d --name eigenda-proxy -p 3100:3100 \
-  ghcr.io/layr-labs/eigenda-proxy:latest \
-  --eigenda.disperser-rpc=disperser-sepolia.eigenda.xyz:443 \
-  --eigenda.service-manager-addr=0xD4A7E1Bd8015057293f0D0A557088c286942e84b \
-  --eigenda.eth-rpc=YOUR_SEPOLIA_RPC_URL \
-  --eigenda.status-query-timeout=45s \
-  --eigenda.signer-private-key-hex=YOUR_PRIVATE_KEY \
-  --memstore.enabled=false --eigenda.disable-tls=false
-```
+## TEE attestation
 
-### Store a blob
-```bash
-curl -s -X POST "http://127.0.0.1:3100/put?commitment_mode=standard" \
-  -H "Content-Type: application/json" \
-  -d '{"key": "value"}'
-```
+Inside the TEE, the KMS signing key is at `/usr/local/bin/kms-signing-public-key.pem`. Verify at `https://verify-sepolia.eigencloud.xyz`.
 
-### Retrieve a blob
-```bash
-curl -s "http://127.0.0.1:3100/get/COMMITMENT_HASH?commitment_mode=standard"
-```
+---
 
-### Health check
-```bash
-curl -s "http://127.0.0.1:3100/health"
-```
+## Dashboard
 
-### View blob on explorer
+View any deployed app at:
 ```
-https://blobs-sepolia.eigenda.xyz/blobs/COMMITMENT_HASH
+https://verify-sepolia.eigencloud.xyz/app/<APP_ID>
 ```
-
----
-
-## Query Parameters Reference
-
-| Parameter | Used On | Values | Description |
-|-----------|---------|--------|-------------|
-| `withTvl` | operators, avs | `true`/`false` | Include TVL calculations |
-| `sortByTvl` | operators, avs | `asc`/`desc` | Sort by TVL |
-| `sortByApy` | operators, avs | `asc`/`desc` | Sort by APY |
-| `sortByTotalStakers` | operators, avs | `asc`/`desc` | Sort by staker count |
-| `sortByTotalAvs` | operators | `asc`/`desc` | Sort by AVS count |
-| `searchByText` | operators, avs | string | Case-insensitive name search |
-| `skip` | all list endpoints | number | Pagination offset (default: 0) |
-| `take` | all list endpoints | number | Results per page (default: 12) |
-
-## Response Formatting
-
-When presenting results to users:
-- **Bold names** and abbreviate addresses (`0x1234...abcd`)
-- TVL in human-readable form ("$1.2B" not "1200000000")
-- APY as percentages ("4.2% APY")
-- Show staker counts and operator counts
-- Use bullet points, not tables
-- Flag high APY + low TVL as potentially risky

package/VIDEO_SCRIPT.md

@@ -0,0 +1,180 @@
+# Eigen Skills & Eigen MCP — Code Walkthrough Script
+
+## Video Details
+- **Target length**: ~10-12 minutes
+- **Tone**: Developer-to-developer, casual but technically precise
+- **Audience**: Devs interested in AI agent tooling, EigenLayer ecosystem
+
+---
+
+## FLOW (at a glance)
+
+```
+1. Hook & Context           (~1 min)
+2. Project Overview          (~1 min)
+3. Skills Deep Dive          (~3 min)
+4. MCP Deep Dive             (~2 min)
+5. Skills vs MCP — same data, two paths  (~1 min)
+6. Live Demo                 (~3 min)
+7. Chat UI & Deployment      (~1.5 min)
+8. Wrap-up                   (~30s)
+```
+
+---
+
+## SCRIPT
+
+### 1. Hook & Context (0:00 – 1:00)
+
+> "What if any AI agent — Claude Code, Cursor, Windsurf — could query live EigenLayer data just by reading a markdown file?
+>
+> That's what we built. This is `eigen-skills` — an open-source package that gives AI agents the ability to query operators, AVS data, staker positions, rewards, delegation events, TEE compute, and data availability blobs — all from the EigenLayer ecosystem.
+>
+> There are two integration paths: **Agent Skills** for Claude Code and compatible agents, and **MCP** for Claude Desktop, Cursor, and Windsurf. Let me walk you through the code."
+
+---
+
+### 2. Project Overview (1:00 – 2:00)
+
+**[SCREEN: terminal, run `ls` or show file tree]**
+
+> "Here's the repo structure. At the top level:
+>
+> - `skills/` — six skill modules, one per EigenLayer domain
+> - `eigen-mcp/` — a standalone MCP server package
+> - `index.js` — exports all six API client classes
+> - `server.js` — a chat UI powered by Gemini with tool-use
+> - `Dockerfile` + `entrypoint.sh` — for deploying into EigenCompute TEE
+>
+> The key insight is that **skills and MCP share the same API client layer**. Let me show you."
+
+**[SCREEN: open `index.js`]**
+
+> "Six classes. `EigenAPI`, `AVSAPI`, `RewardsAPI`, `DelegationAPI`, `EigenCompute`, `EigenDA`. Every integration path — skills, MCP, chat UI — uses these same clients underneath."
+
+---
+
+### 3. Skills Deep Dive (2:00 – 5:00)
+
+**[SCREEN: open `skills/` directory]**
+
+> "Each skill follows the same pattern: a `SKILL.md` file and a `scripts/` folder with the JS client."
+
+**[SCREEN: open `skills/eigen-restaking/SKILL.md`]**
+
+> "This is the magic. The `SKILL.md` is a markdown file that an agent reads to understand what it can do. It has:
+>
+> - A description of the skill's purpose
+> - The base URL and auth headers
+> - Complete curl examples for every endpoint
+>
+> When a user asks Claude Code something like 'show me the top EigenLayer operators by TVL', Claude reads this file, picks the right curl command, runs it, and formats the response. No SDK, no dependencies — just curl."
+
+**[SCREEN: open `skills/eigen-avs/SKILL.md` briefly]**
+
+> "Same pattern for AVS data — services, their operators, their stakers."
+
+**[SCREEN: open `skills/eigen-rewards/SKILL.md` briefly]**
+
+> "Rewards and APY rankings..."
+
+**[SCREEN: open one API client, e.g. `skills/eigen-restaking/scripts/eigen-api.js`]**
+
+> "And if you want to use these programmatically in your own Node app, each skill also has a JS client. Standard axios wrapper — constructor takes an API key, methods map to endpoints. Nothing fancy, deliberately simple."
+
+**[SCREEN: open `scripts/postinstall.js`]**
+
+> "One nice DX touch — when you `npm install eigen-skills`, the postinstall hook copies the unified `SKILL.md` into `~/.claude/skills/eigen/`. Claude Code auto-discovers skills in that directory, so installation is literally one command and you're done."
+
+---
+
+### 4. MCP Deep Dive (5:00 – 7:00)
+
+**[SCREEN: open `eigen-mcp/` directory]**
+
+> "Now the second integration path — MCP, the Model Context Protocol.
+>
+> MCP is a standard from Anthropic for exposing tools to AI agents over a structured RPC interface. Instead of the agent reading markdown and running curl, the agent calls named tools with typed parameters and gets structured JSON back."
+
+**[SCREEN: open `eigen-mcp/mcp.js`]**
+
+> "Here's the server. It imports the same six API clients from `eigen-skills`, then registers 21 tools.
+>
+> Each tool has a name, description, and a Zod schema for parameter validation. When Claude Desktop or Cursor calls `get_operators`, the MCP server runs `eigenAPI.getOperators()` and returns the result.
+>
+> Look — the tool implementations are just thin wrappers around the same API clients the skills use. Same data, different delivery mechanism."
+
+**[SCREEN: show the tool registration pattern — pick `get_metrics` and `get_operators`]**
+
+> "Simple example: `get_metrics` takes no parameters, calls `eigenAPI.getMetrics()`, returns JSON. `get_operators` takes optional skip, take, and search parameters with Zod validation."
+
+**[SCREEN: open `eigen-mcp/README.md` — show config snippets]**
+
+> "To use it, you register it with your client. For Claude Desktop, add it to `claude_desktop_config.json`. For Cursor or Windsurf, similar JSON config. One line: `npx eigen-mcp`."
+
+---
+
+### 5. Skills vs MCP — Same Data, Two Paths (7:00 – 8:00)
+
+**[SCREEN: side-by-side or diagram]**
+
+> "So why two paths?
+>
+> **Skills** are the agent-native approach. The agent reads a markdown file, understands the API surface, and runs curl commands. No server process, no extra dependencies. Works great with Claude Code and any agent that supports the skills spec.
+>
+> **MCP** is the protocol-native approach. A server process exposes typed tools over stdio. Better for IDE integrations like Cursor and Windsurf where you want structured tool calling.
+>
+> Both hit the same EigenExplorer API. Both return the same data. It's about meeting agents where they are."
+
+---
+
+### 6. Live Demo (8:00 – 11:00)
+
+**[SCREEN: terminal with Claude Code open]**
+
+> "Let me show you this working. I've got Claude Code open with eigen-skills installed."
+
+**Demo queries (pick 3-4):**
+
+1. **"What's the current EigenLayer TVL?"** — hits `get_metrics`, shows ecosystem stats
+2. **"Show me the top 5 operators by TVL"** — hits `get_operators`, tabular output
+3. **"What AVS has the most operators?"** — hits `get_avs_list`, cross-references data
+4. **"Show me the highest APY strategies"** — hits rewards skill, shows yield data
+
+> *(narrate what Claude is doing as it runs — "it's reading the skill file... picking the right endpoint... running the curl... formatting the response")*
+
+**[Optional: show the MCP path too in Claude Desktop or Cursor if set up]**
+
+---
+
+### 7. Chat UI & TEE Deployment (11:00 – 12:30)
+
+**[SCREEN: open `server.js` briefly]**
+
+> "Bonus — there's also a web chat UI. Express server, Socket.io for real-time chat, Gemini as the LLM via OpenRouter. It has the same 21 tools defined inline. You can ask EigenLayer questions in a browser."
+
+**[SCREEN: open `ui/index.html` or show the running UI briefly]**
+
+**[SCREEN: open `Dockerfile` and `entrypoint.sh`]**
+
+> "And the whole thing can be deployed into EigenCompute — Intel TDX trusted execution environments. The entrypoint script sources sealed secrets from the TEE, writes the env file, and starts the server. Your API keys never leave the enclave."
+
+---
+
+### 8. Wrap-up (12:30 – 13:00)
+
+> "That's eigen-skills. Six EigenLayer domains, two integration paths, same underlying clients.
+>
+> `npm install eigen-skills` for Claude Code. `npx eigen-mcp` for Claude Desktop and Cursor. Or use the JS clients directly in your own app.
+>
+> Links in the description. Star the repo, open issues, PRs welcome."
+
+---
+
+## Production Notes
+
+- **Screen recordings**: Use a clean terminal theme, large font (16-18pt)
+- **Code highlights**: When showing files, zoom into the relevant section — don't scroll through entire files
+- **Transitions**: Cut between terminal and editor, avoid long pauses
+- **B-roll ideas**: EigenExplorer website, EigenLayer docs, Claude Code in action
+- **Thumbnail**: Terminal with EigenLayer logo + "AI Agent Skills" text