aixyz-on-openclaw

What this skill does

# aixyz for openclaw Users

This guide is written for openclaw users who want to ship a live, paid AI agent using aixyz. You do **not** need prior coding experience or knowledge of crypto infrastructure — every step is explained from scratch.

> **Quick reference:** The general aixyz skill lives at [skills.sh/agentlyhq/aixyz](https://skills.sh/agentlyhq/aixyz).
> Consult it for full CLI flags and advanced topics. This guide focuses on the path that matters most to openclaw users.

---

## What You Are Building

An **AI agent** that:

1. Runs on the internet at a public URL
2. Accepts work requests from other agents (A2A protocol) and from AI clients like Claude Desktop (MCP protocol)
3. Gets paid per request in crypto via the x402 micropayment protocol
4. Is discoverable on-chain via the ERC-8004 registry

---

## Step 1 — Install Bun

aixyz requires **Bun** (not Node). If you already have Bun ≥ 1.3, skip this step.

```bash
# macOS / Linux
curl -fsSL https://bun.sh/install | bash

# Windows (PowerShell, requires WSL or Windows 10+)
powershell -c "irm bun.sh/install.ps1 | iex"
```

Verify:

```bash
bun --version   # should print 1.3 or higher
```

> **Why Bun?** The aixyz build pipeline uses Bun's native build API and plugin system — this is a hard architectural requirement, not a preference. The CLI (`@aixyz/cli`) cannot run on Node. Bun also includes a built-in test runner, which means no extra test framework is needed. Curious about the full rationale? Read [Why Bun](https://aixyz.sh/getting-started/why-bun).

---

## Step 2 — Scaffold Your Agent

> **CRITICAL: You MUST use `create-aixyz-app` to create new agent projects.**
> Do NOT manually create `aixyz.config.ts`, `package.json`, `app/agent.ts`, or any other project files by hand.
> Manually creating these files WILL result in broken builds, missing dependencies, and incorrect configurations.
> Always scaffold with `bunx create-aixyz-app` first, then modify the generated files.

```bash
# Create a new agent project (uses all defaults)
bunx create-aixyz-app my-agent --yes

cd my-agent
```

This creates:

```
my-agent/
  aixyz.config.ts   ← agent name, description, payment config
  app/
    agent.ts        ← your AI agent logic
    tools/          ← tool files (optional)
  package.json
  .env.local        ← API keys (never commit this file)
```

Open `.env.local` and add your LLM provider's API key. The default scaffold uses `@ai-sdk/openai`, so add:

```
OPENAI_API_KEY=sk-...
```

If you prefer a different provider (Anthropic, Google, Amazon Bedrock, etc.), swap the `@ai-sdk/*` adapter in `package.json` and `app/agent.ts`, then set the corresponding env var instead. See [ai-sdk.dev](https://ai-sdk.dev) for the full list of providers.

Run locally to test:

```bash
bun run dev
# Agent is now live at http://localhost:3000
```

> **Testing with an AI agent client?** Install the `use-agently` skill so your AI agent can call your local agent in dev mode:
>
> ```bash
> npx skills add https://github.com/agentlyhq/use-agently --skill use-agently
> ```
>
> This skill lets any AI agent discover and call your locally running agent at `http://localhost:3000`.
> While testing locally, set `"scheme": "free"` so callers are not charged (see [Step 7](#step-7--set-up-payments)).
> Before going to production, switch to `"scheme": "exact"` so your agent earns from every request.

---

## Step 3 — Deploy to the Internet

Your agent needs a **public HTTPS URL** so other agents and clients can reach it. If you already have a preferred hosting platform, use it. If you are starting fresh, here are our recommendations.

### Option A — Vercel (recommended, no server knowledge needed)

Vercel gives you a free HTTPS URL with zero configuration. It is the easiest path.

1. Push your project to a GitHub repository
2. Go to [vercel.com](https://vercel.com) → **Add New Project** → import your repo
3. Set the **Build Command** to `bun run build` and the **Output Directory** to `.vercel/output`
4. Add your LLM provider API key (e.g., `OPENAI_API_KEY`) in the Vercel dashboard under **Settings → Environment Variables**
5. Click **Deploy** — Vercel gives you a URL like `https://my-agent.vercel.app`

Vercel auto-deploys on every push. Your agent is serverless and scales automatically.

### Option B — Railway / Render / Fly.io (persistent server)

Use these if your agent needs to hold state between requests or run background jobs.

| Platform                       | Free tier          | Notes                                |
| ------------------------------ | ------------------ | ------------------------------------ |
| [Railway](https://railway.app) | 5 USD/month credit | Easiest Docker-free deploy           |
| [Render](https://render.com)   | Generous free tier | Sleeps after inactivity              |
| [Fly.io](https://fly.io)       | Free allowance     | More control, steeper learning curve |

For all three: push your repo, connect the platform, set your LLM provider API key (e.g., `OPENAI_API_KEY`) as an environment variable, and follow their deploy wizard. They all detect Bun automatically.

### Option C — Cloud Platform Ingress or Local Tunnel (advanced)

**If you are already running OpenClaw on a cloud platform** (AWS, GCP, Azure, DigitalOcean, etc.), the simplest path is to expose the agent through that same platform:

- **AWS** — use an Application Load Balancer or API Gateway in front of the process
- **GCP** — use Cloud Run (zero-config container deploy) or a load balancer
- **Azure** — use Azure Container Apps or App Service
- **DigitalOcean** — use App Platform or a Droplet with nginx as a reverse proxy

> 🔒 **Least-privilege rule:** When exposing the agent process, only open the port the agent listens on (default `3000`). Do **not** grant the process broader network, IAM, or filesystem access than it needs to serve HTTP requests.

**If you just need a quick tunnel for local testing**, use ngrok:

```bash
# ngrok — creates a public HTTPS URL that forwards to localhost:3000
npx ngrok http 3000
```

> ⚠️ **Security warning:** Local tunnels are fine for short-lived testing but should **never** be used for a production agent. Anyone who discovers the URL can send requests to your machine. Always use a proper hosting provider for live traffic.

---

## Step 4 — Get a Crypto Wallet

You need a wallet to:

- **Receive payments** from callers of your agent
- **Pay gas fees** when registering on ERC-8004

### Option A — Use `use-agently` (simplest, recommended for openclaw users)

`use-agently` is the simplest wallet for the aixyz ecosystem. It is designed for the circular economy of agents paying agents.

When prompted during `aixyz erc-8004 register`, select **"Generate a new wallet"** and the CLI will create one for you and display the private key.

> 🔐 **Private key security — read this carefully:**
>
> - **Never share your private key with anyone.** Anyone who has it controls your funds.
> - **Never commit it to git** or paste it in public channels (Discord, Slack, GitHub, etc.).
> - Write it down offline and store it somewhere safe (e.g., a password manager).
> - For a production agent that earns significant income, consider a hardware wallet (Ledger, Trezor).

### Option B — MetaMask (browser extension)

1. Install [MetaMask](https://metamask.io) in your browser
2. Create a new wallet — MetaMask gives you a **seed phrase** (12 words); write it down somewhere safe, never share it
3. Copy your wallet address (starts with `0x…`)

### Option C — Any EVM-compatible wallet

Any wallet that supports Ethereum-compatible networks works: Coinbase Wallet, Rabby, Frame, etc.

> **Your wallet address is your "bank account number."** You share it publicly. Your **private key / seed phrase is your password** — never share it, never commit it to code.

---

## Step 5 — Get Crypto for Registration

Registering on ERC-8004 costs a small gas fee (a fraction of a dollar). You need the native coin of your chosen network.

| Network