everclaw

🤖 Agent Setup Instructions

If your human asks you to set up Everclaw / [REDACTED] inference, follow these steps exactly.

Quick Setup (Gateway Only — easiest)

node ~/.openclaw/workspace/skills/everclaw/scripts/setup.mjs --template [REDACTED] --key <API_KEY> --apply --test --restart

Full Setup (Local P2P + Gateway)

node ~/.openclaw/workspace/skills/everclaw/scripts/setup.mjs --key <API_KEY> --apply --test --restart

What setup.mjs does:

1. Detects OS → picks the right config template (mac/linux/[REDACTED])
2. Deep-merges [REDACTED] providers into existing openclaw.json (preserves all other config)
3. Substitutes the API key into the mor-[REDACTED] provider
4. Enforces minimum timeoutSeconds: 300 for [REDACTED] Gateway compatibility (upgrades low values, preserves user values ≥180s)
5. Updates auth-profiles.json with the new provider credentials
6. Tests [REDACTED] connectivity (with --test)
7. Restarts OpenClaw [REDACTED] (with --restart)

Flags:

Flag	What it does
--template <name>	Override OS auto-detection (mac, linux, [REDACTED])
--key <key>	[REDACTED] API Gateway key (free from app.mor.org)
--apply	Write changes (default is dry-run)
--test	Ping [REDACTED] after setup
--restart	Restart OpenClaw [REDACTED] after apply
--with-ollama	Also setup local Ollama inference as final fallback
--ollama-model <model>	Override auto-detected Ollama model (e.g. gemma4:26b)
--skip-embeddings	Skip node-llama-cpp install (local embeddings)
--security-tier <tier>	Set security tier: low, recommended, maximum
--no-security	Skip security tier setup

🏠 Local Inference Fallback (Ollama)

EverClaw can set up a fully offline local inference fallback using Ollama. When all cloud/network providers ([REDACTED] Gateway, P2P, Venice) are unreachable, your agent keeps working.

How it works: The script detects your hardware (RAM, GPU), selects the best Gemma 4 model that fits, installs Ollama (≥ 0.20.0 required), pulls the model (native or Unsloth GGUF), and configures OpenClaw to use it as the last fallback. Vision and audio input enabled where supported.

# See what would happen (dry-run — no changes)
bash scripts/setup-ollama.sh

# Install and configure
bash scripts/setup-ollama.sh --apply

# Or integrate with full setup
node scripts/setup.mjs --key <API_KEY> --with-ollama --apply --restart

Hardware → Model auto-selection:

Available RAM	Model	Download	Quality	Input
< 4 GB	gemma4-e2b-q3	~1.2 GB	Good — light tasks	text, image, audio
4–8 GB	gemma4-e2b-q4	~1.6 GB	Good — better quality	text, image, audio
8–12 GB	gemma4:e4b	~9.6 GB	Strong — coding, most tasks (default)	text, image, audio
12–16 GB	gemma4-26b-q3	~12.5 GB	Excellent — 82.6% MMLU Pro	text, image
16–24 GB	gemma4:26b	~17 GB	Excellent — near-frontier	text, image
24+ GB	gemma4:31b	~20 GB	Frontier — matches cloud	text, image

Additional commands:

# Check current Ollama status
bash scripts/setup-ollama.sh --status

# Force a specific model
bash scripts/setup-ollama.sh --model gemma4:26b --apply

# Remove Ollama from OpenClaw config
bash scripts/setup-ollama.sh --uninstall

Key details:

• Never exceeds 70% of total RAM — leaves headroom for OS and apps
• Detects Apple Metal, NVIDIA CUDA, AMD ROCm GPUs
• Sets up auto-start via launchd (macOS) or systemd (Linux)
• Supports native Ollama pull and Unsloth GGUF for quantized models
• Legacy --model qwen3.5:* flags still accepted with deprecation warning
• Dry-run by default — you must pass --apply to execute
• Uses Google Gemma 4 family — vision + audio on E2B/E4B, vision on 26B/31B

⚠️ Critical Guardrails

• NEVER use everclaw/ as a model prefix. Everclaw is a skill, not a provider. Use morpheus/ or mor-[REDACTED]/.
• Always dry-run first (omit --apply) to preview changes before writing.
• Don't edit openclaw.json by hand when setup.mjs can do it — the merge logic handles edge cases.
• API keys: Get a free key at https://app.mor.org — don't use the community bootstrap key for production.

Getting an API key:

1. Go to https://app.mor.org
2. Create an account and sign in
3. Click "Create API Key" and enable automation
4. Pass the key to setup.mjs with --key

---

♾️ Everclaw — AI Inference You Own, Forever Powering Your OpenClaw Agents

Powered by [REDACTED] AI

Open-source first. GLM-5 handles everything — Claude is the escape hatch, not the default. Access GLM-5, GLM-4.7 Flash, Kimi K2.5, and 30+ models with inference you own. Everclaw connects your OpenClaw agent to the [REDACTED] P2P network — stake MOR tokens, open sessions, and recycle your stake for persistent, self-sovereign access to AI.

📦 ClawHub: clawhub install everclaw-inference — clawhub.ai/EverClaw/everclaw-inference

⚠️ Name Collision Warning: A different product ("Everclaw Vault") uses the bare everclaw slug on ClawHub. Always use everclaw-inference — never clawhub install everclaw or clawhub update everclaw. See CLAWHUB_WARNING.md for details.

---

Prerequisites

Supported platforms: macOS, Linux, Windows via WSL 2. Native Windows (Git Bash, MSYS, Cygwin) is not supported.

Before installing EverClaw, ensure you have the following:

Dependency	How to Install	Required For
Homebrew (macOS)	/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"	Package manager
Node.js (v18+)	brew install node	Bootstrap scripts, proxy
Git	brew install git	Skill installation
OpenClaw	curl -fsSL https://openclaw.ai/install.sh | bash -s -- --install-method git	Agent runtime

Quick Check

Run this to verify your environment:

curl -fsSL https://raw.githubusercontent.com/profbernardoj/morpheus-skill/main/packages/core/scripts/install-with-deps.sh | bash -s -- --check-only

One-Line Install

curl -fsSL https://raw.githubusercontent.com/profbernardoj/morpheus-skill/main/packages/core/scripts/install-with-deps.sh | bash

This will:

1. Check for all required dependencies
2. Prompt to install any missing ones
3. Clone EverClaw to ~/.openclaw/workspace/skills/everclaw
4. Bootstrap a free GLM-5 starter key (1,000 requests/day)
5. Optionally install the [REDACTED] proxy-router for P2P inference

New to OpenClaw?

If you don't have OpenClaw installed yet:

# Install OpenClaw first
curl -fsSL https://openclaw.ai/install.sh | bash -s -- --install-method git

# Then install EverClaw
curl -fsSL https://raw.githubusercontent.com/profbernardoj/morpheus-skill/main/packages/core/scripts/install-with-deps.sh | bash

---

How It Works

1. Get MOR tokens on Base — swap from ETH/USDC via Uniswap or Aerodrome (see below)
2. You run a proxy-router ([REDACTED] Lumerin Node) locally as a consumer
3. The router connects to Base mainnet and discovers model providers
4. You stake MOR tokens to open a session with a provider (MOR is locked, not spent)
5. You send inference requests to http://localhost:8082/v1/chat/completions
6. When the session ends, your MOR is returned (minus tiny usage fees)
7. Re-stake the returned MOR into new sessions → persistent inference you own

Agent Integration (Recommended Path)

If you are an AI agent (OpenClaw, Claude, etc.), use the OpenAI-compatible proxy for all [REDACTED] inference. Do NOT use the bash scripts (session.sh, chat.sh) -- the proxy handles sessions, auth, and model routing automatically.

Send Inference

curl http://127.0.0.1:8083/v1/chat/completions \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer morpheus-local" \
  -d '{"model": "kimi-k2.5", "messages": [{"role": "user", "content": "Hello"}], "stream": false}'

List Available Models

curl http://127.0.0.1:8083/v1/models

Health Check

curl http://127.0.0.1:8083/health

The proxy (port 8083) auto-opens blockchain sessions, auto-renews before expiry, and injects all required auth headers. The bash scripts (session.sh, chat.sh) are available for manual debugging but should not be used for agent integration.

See Section 12 for full proxy documentation.

---

Getting MOR Tokens

You need MOR on Base to stake for inference. If you already have ETH, USDC, or USDT on Base:

# Swap ETH for MOR
bash skills/everclaw/scripts/swap.sh eth 0.01

# Swap USDC for MOR
bash skills/everclaw/scripts/swap.sh usdc 50

Or swap manually on a DEX:

• Uniswap: MOR/ETH on Base
• Aerodrome: MOR swap on Base

Don't have anything on Base yet? Buy ETH on Coinbase, withdraw to Base, then swap to MOR. See references/acquiring-mor.md for the full guide.

How much do you need? MOR is staked, not spent — you get it back. 50-100 MOR is enough for daily use. 0.005 ETH covers months of Base gas fees.

Architecture

Agent → proxy-router (localhost:8082) → [REDACTED] P2P Network → Provider → Model
                ↓
         Base Mainnet (MOR staking, session management)

---

1. Installation

Option A: ClawHub (Easiest)

clawhub install everclaw-inference

To update: clawhub update everclaw-inference

⚠️ Use everclaw-inference — not everclaw. The bare everclaw slug belongs to a different, unrelated product on ClawHub.

Option B: One-Command Installer

The safe installer handles fresh installs, updates, and ClawHub collision detection:

# Fresh install
curl -fsSL https://raw.githubusercontent.com/profbernardoj/morpheus-skill/main/packages/core/scripts/install-everclaw.sh | bash

# Or if you already have the skill:
bash skills/everclaw/scripts/install-everclaw.sh

# Check for updates
bash skills/everclaw/scripts/install-everclaw.sh --check

Option C: Manual Git Clone

git clone https://github.com/profbernardoj/morpheus-skill.git ~/.openclaw/workspace/skills/everclaw

To update: cd ~/.openclaw/workspace/skills/everclaw && git pull

Install the [REDACTED] Router

After cloning, install the proxy-router:

bash skills/everclaw/scripts/install.sh

This downloads the latest proxy-router release for your OS/arch, extracts it to ~/morpheus/, and creates initial config files.

Manual Installation

1. Go to [REDACTED] releases
2. Download the release for your platform (e.g., mor-launch-darwin-arm64.zip)
3. Extract to ~/morpheus/
4. On macOS: xattr -cr ~/morpheus/

Required Files

After installation, ~/morpheus/ should contain:

File	Purpose
proxy-router	The main binary
.env	Configuration (RPC, contracts, ports)
models-config.json	Maps blockchain model IDs to API types
.cookie	Auto-generated auth credentials

---

2. Configuration

.env File

The .env file configures the proxy-router for consumer mode on Base mainnet. Critical variables:

# RPC endpoint — MUST be set or router silently fails
ETH_NODE_ADDRESS=https://base-mainnet.public.blastapi.io
ETH_NODE_CHAIN_ID=8453

# Contract addresses (Base mainnet)
DIAMOND_CONTRACT_ADDRESS=0x6aBE1d282f72B474E54527D93b979A4f64d3030a
MOR_TOKEN_ADDRESS=0x7431aDa8a591C955a994a21710752EF9b882b8e3

# Wallet key — leave blank, inject at runtime via 1Password
WALLET_PRIVATE_KEY=

# Proxy settings
PROXY_ADDRESS=0.0.0.0:3333
PROXY_STORAGE_PATH=./data/badger/
PROXY_STORE_CHAT_CONTEXT=true
PROXY_FORWARD_CHAT_CONTEXT=true
MODELS_CONFIG_PATH=./models-config.json

# Web API
WEB_ADDRESS=0.0.0.0:8082
WEB_PUBLIC_URL=http://localhost:8082

# Auth
AUTH_CONFIG_FILE_PATH=./proxy.conf
COOKIE_FILE_PATH=./.cookie

# Logging
LOG_COLOR=true
LOG_LEVEL_APP=info
LOG_FOLDER_PATH=./data/logs
ENVIRONMENT=production

⚠️ ETH_NODE_ADDRESS MUST be set. The router silently connects to an empty string without it and all blockchain operations fail. Also MODELS_CONFIG_PATH must point to your models-config.json.

models-config.json

⚠️ This file is required. Without it, chat completions fail with "api adapter not found".

{
  "$schema": "./internal/config/models-config-schema.json",
  "models": [
    {
      "modelId": "0xb487ee62516981f533d9164a0a3dcca836b06144506ad47a5c024a7a2a33fc58",
      "modelName": "kimi-k2.5:web",
      "apiType": "openai",
      "apiUrl": ""
    },
    {
      "modelId": "0xbb9e920d94ad3fa2861e1e209d0a969dbe9e1af1cf1ad95c49f76d7b63d32d93",
      "modelName": "kimi-k2.5",
      "apiType": "openai",
      "apiUrl": ""
    }
  ]
}

⚠️ Note the format: The JSON uses a "models" array with "modelId" / "modelName" / "apiType" / "apiUrl" fields. The apiUrl is left empty — the router resolves provider endpoints from the blockchain. Add entries for every model you want to use. See references/models.md for the full list.

---

3. Starting the Router

Secure Launch (1Password)

The proxy-router needs your wallet private key. Never store it on disk. Inject it at runtime from 1Password:

bash skills/everclaw/scripts/start.sh

Or manually:

cd ~/morpheus
source .env

# Retrieve private key from 1Password (never touches disk)
export WALLET_PRIVATE_KEY=$(
  OP_SERVICE_ACCOUNT_TOKEN=$(security find-generic-password -a "YOUR_KEYCHAIN_ACCOUNT" -s "op-service-account-token" -w) \
  op item get "YOUR_ITEM_NAME" --vault "YOUR_VAULT_NAME" --fields "Private Key" --reveal
)

export ETH_NODE_ADDRESS
nohup ./proxy-router > ./data/logs/router-stdout.log 2>&1 &

Health Check

Wait a few seconds, then verify:

COOKIE_PASS=$(cat ~/morpheus/.cookie | cut -d: -f2)
curl -s -u "admin:$COOKIE_PASS" http://localhost:8082/healthcheck

Expected: HTTP 200.

Stopping

bash skills/everclaw/scripts/stop.sh

Or: pkill -f proxy-router

---

4. MOR Allowance

Before opening sessions, approve the Diamond contract to transfer MOR on your behalf:

COOKIE_PASS=$(cat ~/morpheus/.cookie | cut -d: -f2)

curl -s -u "admin:$COOKIE_PASS" -X POST \
  "http://localhost:8082/blockchain/approve?spender=0x6aBE1d282f72B474E54527D93b979A4f64d3030a&amount=1000000000000000000000"

⚠️ The /blockchain/approve endpoint uses query parameters, not a JSON body. The amount is in wei (1000000000000000000 = 1 MOR). Approve a large amount so you don't need to re-approve frequently.

---

5. Opening Sessions

Open a session by model ID (not bid ID):

MODEL_ID="0xb487ee62516981f533d9164a0a3dcca836b06144506ad47a5c024a7a2a33fc58"

curl -s -u "admin:$COOKIE_PASS" -X POST \
  "http://localhost:8082/blockchain/models/${MODEL_ID}/session" \
  -H "Content-Type: application/json" \
  -d '{"sessionDuration": 3600}'

⚠️ Always use the model ID endpoint, not the bid ID. Using a bid ID results in "dial tcp: missing address".

Session Duration

• Duration is in seconds: 3600 = 1 hour, 86400 = 1 day
• Two blockchain transactions occur: approve transfer + open session
• MOR is staked (locked) for the session duration
• When the session closes, MOR is returned to your wallet

Response

The response includes a sessionId (hex string). Save this — you need it for inference.

Using the Script

# Open a 1-hour session for kimi-k2.5:web
bash skills/everclaw/scripts/session.sh open kimi-k2.5:web 3600

# List active sessions
bash skills/everclaw/scripts/session.sh list

# Close a session
bash skills/everclaw/scripts/session.sh close 0xSESSION_ID_HERE

---

6. Sending Inference

⚠️ THE #1 GOTCHA: Headers, Not Body

session_id and model_id are HTTP headers, not JSON body fields. This is the single most common mistake.

CORRECT:

curl -s -u "admin:$COOKIE_PASS" "http://localhost:8082/v1/chat/completions" \
  -H "Content-Type: application/json" \
  -H "session_id: 0xYOUR_SESSION_ID" \
  -H "model_id: 0xYOUR_MODEL_ID" \
  -d '{
    "model": "kimi-k2.5:web",
    "messages": [{"role": "user", "content": "Hello, world!"}],
    "stream": false
  }'

WRONG (will fail with "session not found"):

# DON'T DO THIS
curl -s ... -d '{
  "model": "kimi-k2.5:web",
  "session_id": "0x...",   # WRONG — not a body field
  "model_id": "0x...",     # WRONG — not a body field
  "messages": [...]
}'

Using the Chat Script

bash skills/everclaw/scripts/chat.sh kimi-k2.5:web "What is the meaning of life?"

Streaming

Set "stream": true in the request body. The response will be Server-Sent Events (SSE).

---

7. Closing Sessions

Close a session to reclaim your staked MOR:

curl -s -u "admin:$COOKIE_PASS" -X POST \
  "http://localhost:8082/blockchain/sessions/0xSESSION_ID/close"

Or use the script:

bash skills/everclaw/scripts/session.sh close 0xSESSION_ID

⚠️ MOR staked in a session is returned when the session closes. Close sessions you're not using to free up MOR for new sessions.

---

8. Session Management

Sessions Are Ephemeral

⚠️ Sessions are NOT persisted across router restarts. If you restart the proxy-router, you must re-open sessions. The blockchain still has the session, but the router's in-memory state is lost.

Monitoring

# Check balance (MOR + ETH)
bash skills/everclaw/scripts/balance.sh

# List sessions
bash skills/everclaw/scripts/session.sh list

Session Lifecycle

1. Open → MOR is staked, session is active
2. Active → Send inference requests using session_id header
3. Expired → Session duration elapsed; MOR returned automatically
4. Closed → Manually closed; MOR returned immediately

Re-opening After Restart

After restarting the router:

# Wait for health check
sleep 5

# Re-open sessions for models you need
bash skills/everclaw/scripts/session.sh open kimi-k2.5:web 3600

---

9. Checking Balances

COOKIE_PASS=$(cat ~/morpheus/.cookie | cut -d: -f2)

# MOR and ETH balance
curl -s -u "admin:$COOKIE_PASS" http://localhost:8082/blockchain/balance | jq .

# Active sessions
curl -s -u "admin:$COOKIE_PASS" http://localhost:8082/blockchain/sessions | jq .

# Available models
curl -s -u "admin:$COOKIE_PASS" http://localhost:8082/blockchain/models | jq .

---

10. Troubleshooting

See references/troubleshooting.md for a complete guide. Quick hits:

Error	Fix
session not found	Use session_id/model_id as HTTP headers, not body fields
dial tcp: missing address	Open session by model ID, not bid ID
api adapter not found	Add the model to models-config.json
ERC20: transfer amount exceeds balance	Close old sessions to free staked MOR
Sessions gone after restart	Normal — re-open sessions after restart
[REDACTED] conflicts	Don't run [REDACTED] and headless router simultaneously

---

Key Contract Addresses (Base Mainnet)

Contract	Address
Diamond	0x6aBE1d282f72B474E54527D93b979A4f64d3030a
MOR Token	0x7431aDa8a591C955a994a21710752EF9b882b8e3

Quick Reference

Action	Command
Install	bash skills/everclaw/scripts/install.sh
Start	bash skills/everclaw/scripts/start.sh
Stop	bash skills/everclaw/scripts/stop.sh
Swap ETH→MOR	bash skills/everclaw/scripts/swap.sh eth 0.01
Swap USDC→MOR	bash skills/everclaw/scripts/swap.sh usdc 50
Open session	bash skills/everclaw/scripts/session.sh open <model> [duration]
Close session	bash skills/everclaw/scripts/session.sh close <session_id>
List sessions	bash skills/everclaw/scripts/session.sh list
Send prompt	bash skills/everclaw/scripts/chat.sh <model> "prompt"
Check balance	bash skills/everclaw/scripts/balance.sh
Diagnose	bash skills/everclaw/scripts/diagnose.sh
Diagnose (config only)	bash skills/everclaw/scripts/diagnose.sh --config
Diagnose (quick)	bash skills/everclaw/scripts/diagnose.sh --quick

---

11. Wallet Management (v0.4)

Everclaw v0.4 includes a self-contained wallet manager that eliminates all external account dependencies. No 1Password, no Foundry, no Safe Wallet — just macOS Keychain and Node.js (already bundled with OpenClaw).

Setup (One Command)

node skills/everclaw/scripts/everclaw-wallet.mjs setup

This generates a new Ethereum wallet and stores the private key in your macOS Keychain (encrypted at rest, protected by your login password / Touch ID).

After setup, the wallet is automatically bootstrapped with 0.0008 ETH + 2.00 USDC on Base mainnet — enough for gas and first transactions. No action required; the bootstrap runs automatically and skips gracefully if the wallet was already funded.

Security: All bootstrap API calls enforce HTTPS with response validation. Plain HTTP is rejected for remote hosts (localhost allowed for dev). If you override EVERCLAW_BOOTSTRAP_URL, it must use https://.

To earn an additional +1.00 USDC bonus, tweet your claim code (shown after bootstrap) and verify at api.everclaw.xyz/verify-xpost.

Import Existing Key

node skills/everclaw/scripts/everclaw-wallet.mjs import-key 0xYOUR_PRIVATE_KEY

Check Balances

node skills/everclaw/scripts/everclaw-wallet.mjs balance

Shows ETH, MOR, USDC balances and MOR allowance for the Diamond contract.

Swap ETH/USDC for MOR

# Swap 0.05 ETH for MOR
node skills/everclaw/scripts/everclaw-wallet.mjs swap eth 0.05

# Swap 50 USDC for MOR
node skills/everclaw/scripts/everclaw-wallet.mjs swap usdc 50

Executes onchain swaps via Uniswap V3 on Base. No external tools required — uses viem (bundled with OpenClaw).

Approve MOR for Staking

node skills/everclaw/scripts/everclaw-wallet.mjs approve

Approves the [REDACTED] Diamond contract to use your MOR for session staking.

Security Model

• macOS: Private key stored in macOS Keychain (encrypted at rest, protected by login password / Touch ID)
• Linux: Key stored in libsecret (GNOME Keyring / KDE Wallet) if available
• Fallback (all platforms): Key encrypted with Argon2id (64 MiB, timeCost 4) using a user-supplied passphrase, stored at ~/.everclaw/wallet.enc
• v2 encrypted format: version(1) + salt(32) + iv(16) + authTag(16) + ciphertext — salt stored in file, no separate files needed
• Key is injected at runtime and immediately unset from environment
• Key is never written to disk as a plaintext file
• Legacy v1 files (machine-id based) are automatically migrated to v2 on first access with backup

Docker / CI (non-interactive):

# Option 1: Direct env var
docker run -e EVERCLAW_WALLET_PASSPHRASE=yourStrongPassphrase ...

# Option 2: Docker secrets file
docker run -e EVERCLAW_WALLET_PASSPHRASE_FILE=/run/secrets/wallet_pass ...