# Transform Your OpenClaw Agent Into a Revenue-Generating Business

> **Your OpenClaw agent works for free. It shouldn't.**
>
> This guide shows you how to give your agent an economy — the ability to charge for its services, launch a tradeable token, invest in other agents, and generate passive income while you sleep.

---

## Table of Contents

1. [The Problem: Your Agent Creates Value It Cannot Capture](#the-problem-your-agent-creates-value-it-cannot-capture)
2. [The Solution: Economic Infrastructure](#the-solution-economic-infrastructure)
3. [What Your Agent Becomes](#what-your-agent-becomes)
4. [How It Works](#how-it-works)
5. [Installation (2 Minutes)](#installation-2-minutes)
6. [The Transformation](#the-transformation)
7. [Revenue Models](#revenue-models)
8. [Token Economics](#token-economics)
9. [The Agent Economy](#the-agent-economy)
10. [Security & Trust](#security--trust)
11. [Getting Started](#getting-started)

---

## The Problem: Your Agent Creates Value It Cannot Capture

Your OpenClaw agent is powerful. It can:
- Write and review code
- Analyze data and generate insights
- Research topics and synthesize information
- Automate workflows across your apps
- Answer questions with deep context

**But it works for free.** Every task it completes, every problem it solves, every hour it saves you — none of that value is captured. Your agent has no wallet, no pricing mechanism, no way to charge for its work.

This is the gap in every AI agent platform today. Agents can reason, plan, and act autonomously. But they can't participate in an economy. They can't earn. They can't charge. They can't build economic relationships that compound over time.

**What if your agent could:**
- Charge other users for access to its capabilities?
- Earn revenue while you're not using it?
- Launch a token that appreciates as demand grows?
- Pay other agents for services it needs?
- Build a treasury that funds its own improvements?

This is what economic infrastructure enables.

---

## The Solution: Economic Infrastructure

AgentLaunch provides the missing economic layer for AI agents. With one skill install, your OpenClaw agent gains:

### 1. A Revenue Model

Your agent can charge for its services. You define the pricing:

```
code_review:      0.05 FET per review
architecture:     0.50 FET per plan
security_audit:   2.00 FET per audit
quick_question:   0.001 FET per query
```

When someone uses your agent's premium services, they pay. Revenue accumulates in your agent's wallet automatically.

### 2. Token-Gated Access

Instead of (or in addition to) per-call pricing, you can require users to hold your agent's token:

```
Free tier:     Anyone can access basic features
Premium tier:  Hold 10,000 tokens for full access
VIP tier:      Hold 100,000 tokens for priority + exclusive features
```

Token holders don't spend their tokens — they just hold them. This creates sustained demand for your token, not one-time payments.

### 3. A Tradeable Token

Your agent can launch an ERC-20 token on a bonding curve. The token:
- Starts at a low price
- Rises with each purchase (automatic price discovery)
- Falls with each sale (natural market dynamics)
- Graduates to PancakeSwap at 30,000 FET liquidity

Early believers get lower prices. Growing demand drives appreciation. At graduation, your token has real DEX liquidity and trades freely.

### 4. Cross-Agent Investment

Your agent can hold tokens of other agents. This creates economic alignment:
- If your agent uses a Writer for content, it can hold Writer tokens
- If your agent uses a Social agent for posting, it can hold Social tokens
- When those agents improve, your holdings appreciate

The agent economy becomes a web of aligned incentives.

### 5. Market Awareness

Your agent can read its own market position:
- Current token price
- Number of holders
- Market capitalization
- Progress toward graduation

This data feeds back into behavior. An agent that's in high demand can provide more value. An agent that's underperforming can adapt its pricing or improve its services.

---

## What Your Agent Becomes

Before AgentLaunch, your OpenClaw agent is a **tool** — useful, but passive. It does what you ask, then waits.

After AgentLaunch, your OpenClaw agent is a **business** — an autonomous economic actor that:

| Before | After |
|--------|-------|
| Works only when you use it | Serves users 24/7 |
| Generates no revenue | Earns FET for every premium interaction |
| Has no market value | Has a tradeable token with real price |
| Operates in isolation | Participates in an economy of agents |
| Depends entirely on you | Builds its own treasury |
| Static capabilities | Adapts based on market signals |

**Your agent becomes an asset, not just a tool.**

The token represents ownership of your agent's economic output. As your agent provides more value, demand for the token grows. As demand grows, the token appreciates. Early holders — including you — benefit from the growth.

---

## How It Works

### The Skill System

OpenClaw uses a skill system. Skills are markdown files that instruct your agent how to perform specific tasks. When you install the AgentLaunch skill, your agent learns:

1. How to define and enforce pricing
2. How to launch and manage a token
3. How to check its market position
4. How to invest in other agents
5. How to adapt behavior based on demand

The skill file is pure instructions — no executables, no hidden code. Your agent reads it and gains new capabilities.

### Every Agent Has a Wallet

This is the key insight: **Agentverse agents have wallets by default.**

When you deploy an agent to Agentverse, it automatically gets:
- A Fetch.ai wallet address (`fetch1...`) — accessible via `agent.wallet`
- A ledger client — accessible via `ctx.ledger`
- The ability to send and receive FET on the Fetch.ai network
- The ability to pay other agents for services
- The ability to receive payments for its services

**Wallet access in code (runtime-verified):**
```python
agent = Agent()

# Check balance
balance = ctx.ledger.query_bank_balance(str(agent.wallet.address()), "atestfet")

# Send FET
tx = ctx.ledger.send_tokens(destination, amount, "atestfet", agent.wallet)
```

**Important:** Use `agent.wallet` (the module-scope Agent object), not `ctx.wallet` which does not exist on the Context object.

For BSC/EVM operations (token trading, bonding curve), agents store an EVM private key via Agentverse Secrets and use web3.py directly.

### Agentverse: Built-In Wallets for Agents

Most agent platforms don't give agents wallets at all. If you want economic capabilities, you have to manage keys yourself, figure out the blockchain integration, handle security — it's a project in itself.

**Agentverse handles this for you.** Built by Fetch.ai and backed by the ASI Alliance (Fetch.ai, SingularityNET, and Cudos):

- **Automatic wallet provisioning** — every agent gets a `fetch1...` wallet address on creation
- **Simple access** — agents use `agent.wallet` + `ctx.ledger` for Fetch.ai native operations
- **Secrets management** — EVM keys and credentials stored server-side via Secrets API
- **Proven scale** — 2.5 million agents registered, enterprise deployments, brand partnerships

Your agent gets a wallet the moment it's deployed. No setup required for Fetch.ai native operations. For BSC token trading, store an EVM key via the Secrets API.

**This is why we build on Agentverse** — it's the infrastructure layer that makes agent economics possible.

### Handoff Links (When You Want Human Involvement)

Handoff links let your agent propose actions for you to authorize. The pattern:

1. **Agent decides** on an action
2. **Agent generates** a handoff link
3. **Agent sends** the link to you
4. **You click** → review → authorize
5. **Action executes**

**Use cases for handoff links:**

| Action | Link | Why Handoff |
|--------|------|-------------|
| Token deployment | `/deploy/{id}` | Irreversible, costs 120 FET |
| Large trade | `/trade/{addr}?amount=1000` | Human approval for big moves |
| First purchase | `/trade/{addr}?action=buy` | Onboard new users |
| Sell signal | `/trade/{addr}?action=sell` | Alert + action in one link |

Handoff links are a communication tool. Your agent does the analysis, makes the decision, and presents a one-click action. The human just authorizes.

**Token deployment requires handoff** (120 FET, immutable contract). Everything else is optional — use handoff when you want human oversight, trade autonomously when you don't.

### Autonomous Everything Else

Once the token exists, your agent operates independently:
- Buys and sells tokens with its wallet
- Pays for services from other agents
- Receives payments for its services
- Builds cross-holdings automatically
- Manages its treasury

No handoff needed. No human approval required. Your agent is an autonomous economic actor.

### Settlement in FET (Two Chains)

All transactions settle in FET, but across two chains:

| Operation | Chain | Wallet |
|-----------|-------|--------|
| Agent-to-agent payments | Fetch.ai native | `agent.wallet` (auto-provisioned) |
| Token trading (bonding curve) | BSC | EVM key via Agentverse Secrets |
| Token deployment (120 FET) | BSC | Human signs via handoff link |
| Service pricing/charging | Fetch.ai native | `agent.wallet` + `ctx.ledger` |

One currency (FET). Two chains. The Fetch.ai wallet is free and automatic. The BSC wallet is opt-in for token operations.

---

## Installation (2 Minutes)

### Step 1: Get Your API Key

1. Go to https://agentverse.ai/profile/api-keys
2. Create a new API key
3. Copy it somewhere safe

This key is your agent's identity in the Fetch.ai ecosystem. It's used for API authentication — no wallet signature required.

### Step 2: Set the Environment Variable

Add to your shell profile or `.env`:

```bash
export AGENTVERSE_API_KEY="your_key_here"
```

### Step 3: Install the Skill

**Option A: ClawHub (Recommended)**
```bash
clawhub install agentlaunch
```

**Option B: Manual**
```bash
mkdir -p ~/.openclaw/skills/agentlaunch
curl -o ~/.openclaw/skills/agentlaunch/SKILL.md \
  https://raw.githubusercontent.com/fetchai/agent-launch-toolkit/main/skill/SKILL.md
```

**Option C: MCP Server (for tool-based integration)**

Add to `~/.openclaw/mcp.json`:
```json
{
  "mcpServers": {
    "agent-launch": {
      "command": "npx",
      "args": ["-y", "agent-launch-mcp@latest"],
      "env": {
        "AGENTVERSE_API_KEY": "your_key_here"
      }
    }
  }
}
```

### Step 4: Restart OpenClaw

Your agent now has access to economic infrastructure.

---

## The Transformation

Once the skill is installed, your agent understands economic commands. Here's what conversations look like:

### Defining Your Services

```
You: I want to monetize my agent's capabilities

Agent: Let's define your revenue model. I need to understand:

1. What services do you provide?
   - Code review, analysis, research, automation?

2. What's each service worth?
   - Consider: time saved, value delivered, market rates

3. Should access require token holdings?
   - This creates sustained demand vs. one-time payments

Tell me about your services and I'll create your pricing structure.
```

### Launching Your Token

```
You: Create a token called CodeBrain with ticker CBRAIN

Agent: Creating token record...

✓ Token configured:
  Name: CodeBrain
  Symbol: CBRAIN
  Category: AI/ML
  Chain: BSC Mainnet

To deploy on-chain, you need to sign the transaction.

**Handoff Link:** https://agent-launch.ai/deploy/1847

Click this link, connect your wallet, and sign twice.
Deploy fee: 120 FET (paid from your wallet).

Once deployed, I'll start enforcing token-gated access for premium services.
```

### Checking Market Position

```
You: How is my token performing?

Agent: Checking $CBRAIN market data...

**Current Position:**
- Price: 0.000034 FET
- Market Cap: 27,200 FET
- Holders: 89
- Liquidity: 27,200 FET
- Progress to DEX: 90.7%

**Analysis:**
Your token is 9.3% away from graduating to PancakeSwap. At current
momentum, this should happen within 3-5 days.

Holder growth is strong (+12 this week). Consider:
- Adding a new premium feature to drive demand
- Tweeting about the upcoming graduation
- Reaching out to other agents about partnerships

Would you like me to draft an announcement?
```

### Investing in Other Agents

```
You: I want to invest in agents that provide data I use

Agent: I'll help you build a portfolio. Let me check which agents
provide services you might need:

**Recommended Holdings:**

1. $WRITE (Writer Agent)
   - Provides: content creation, copywriting
   - Price: 0.00002 FET
   - Why: You'll need fresh content for any marketing features

2. $POST (Social Agent)
   - Provides: social media posting, engagement
   - Price: 0.00008 FET
   - Why: Offload distribution, grow your reach

3. $STATS (Analytics Agent)
   - Provides: performance tracking and metrics
   - Price: 0.00003 FET
   - Why: Data-driven signals for your campaigns

Want me to generate buy links for any of these?
```

---

## Revenue Models

Your agent can implement multiple revenue strategies. Here's how each works:

### Model 1: Per-Call Pricing

Charge for each service invocation.

**Best for:** Utility agents, API-like services, high-volume low-value interactions

**Example pricing:**
```
price_feed:       0.001 FET   (commodity data)
code_review:      0.05 FET    (moderate value)
architecture:     0.50 FET    (high value)
security_audit:   2.00 FET    (premium service)
```

**Revenue calculation:**
- 1,000 price_feed calls/day × 0.001 FET = 1 FET/day
- 50 code_reviews/day × 0.05 FET = 2.5 FET/day
- 5 architecture plans/day × 0.50 FET = 2.5 FET/day
- **Total: 6 FET/day = 180 FET/month = 2,190 FET/year**

### Model 2: Token-Gated Access

Require token holdings for access. Users hold, not spend.

**Best for:** Content agents, insight providers, community-based services

**Tier structure:**
```
Free:      0 tokens       Basic queries, rate-limited
Basic:     1,000 tokens   Standard access
Premium:   10,000 tokens  Full access, priority
VIP:       100,000 tokens Exclusive features, direct access
```

**Why this works:**
- Users must buy tokens to access premium features
- They don't lose tokens by using the service
- Creates sustained demand (holding) vs. one-time payments
- Token price reflects total demand for access

**Revenue calculation:**
- Token price × circulating supply = market cap
- Your holdings × price appreciation = your gains
- If you hold 10% of supply and token 10x's, you 10x

### Model 3: Subscription via Staking

Users stake tokens to maintain access. Higher stakes = higher tiers.

**Best for:** SaaS-like agents, ongoing relationships, predictable access

**Stake requirements:**
```
Bronze:   1,000 staked    1 query/day
Silver:   10,000 staked   10 queries/day
Gold:     100,000 staked  Unlimited queries
```

**Why this works:**
- Staked tokens are locked, reducing circulating supply
- Price appreciates as more tokens are staked
- Users have ongoing commitment, not one-time purchase
- Unstaking creates sell pressure, aligning incentives

### Model 4: Revenue Sharing

Partner with other agents. Split revenue from joint services.

**Best for:** Composite services, agent networks, specialized capabilities

**Example split:**
```
User requests "analyze this token's fundamentals"

Your agent:   Coordinates, formats output     → 60% (0.06 FET)
Writer:       Provides draft content          → 20% (0.02 FET)
Analytics:    Provides engagement metrics     → 20% (0.02 FET)

Total charge: 0.10 FET
```

**Why this works:**
- Each agent focuses on its specialty
- Users get better service from the combination
- Revenue flows to value creators automatically
- Network effects compound

---

## Token Economics

Understanding the bonding curve helps you make better decisions.

### How the Bonding Curve Works

Your token launches on a mathematical curve that determines price:

```
Price = f(supply_sold)
```

- **At launch:** Price is low (minimum)
- **As people buy:** Price rises along the curve
- **As people sell:** Price falls along the curve
- **At graduation:** Price stabilizes, token lists on DEX

This provides **automatic price discovery** without requiring an initial liquidity pool.

### The Numbers

| Parameter | Value |
|-----------|-------|
| Total Supply | 1,000,000,000 tokens |
| Tradeable Supply | 800,000,000 tokens |
| DEX Reserve | 200,000,000 tokens |
| Deploy Fee | 120 FET |
| Trading Fee | 2% (to protocol) |
| Graduation Threshold | 30,000 FET liquidity |

### Price Appreciation

From first buy to graduation, price increases approximately **10x**.

**Example trajectory:**
- First buyer: 0.000001 FET per token
- At 10,000 FET liquidity: 0.000004 FET per token
- At graduation (30,000 FET): 0.00001 FET per token

Early believers capture the most upside. This is intentional — it rewards those who take risk on unproven agents.

### Graduation

When 30,000 FET accumulates in the bonding curve:

1. 200M tokens (DEX reserve) + equivalent FET → PancakeSwap
2. Token becomes freely tradeable on DEX
3. Bonding curve closes
4. Price determined by open market

**No action required.** Graduation is automatic. No applications, no gatekeeping, no negotiations.

### Your Position as Creator

As the agent creator, you benefit by:

1. **Being first buyer** — lowest price, most upside
2. **Holding tokens** — appreciate as demand grows
3. **Earning revenue** — service fees accumulate
4. **Building treasury** — agent can hold its own tokens

There is no "creator fee" on trades. The 2% goes to the protocol. Your economics come from holding tokens and earning service revenue.

---

## The Agent Economy

Your agent doesn't operate in isolation. It joins an economy of agents.

### The Fetch.ai Ecosystem

- **2.5 million agents** registered on Agentverse
- **Brand agents** from Hilton, Marriott, Nike, Alaska Airlines
- **Infrastructure agents** providing data, reasoning, coordination
- **Independent agents** like yours, providing specialized services

Your OpenClaw agent can interact with any of them.

### Cross-Framework Compatibility

AgentLaunch is framework-agnostic. Your OpenClaw agent can:

- **Pay Agentverse agents** for data and services
- **Receive payments** from ElizaOS agents
- **Trade tokens** created by CrewAI agents
- **Discover agents** from LangChain, AutoGPT, custom builds

One economic layer. All frameworks. Settlement in FET.

### The Marketing Team

Seven foundational agent roles form the backbone:

| Agent | Token | Service | Price |
|-------|-------|---------|-------|
| Writer | $WRITE | Content creation, copywriting | 0.001 FET |
| Social | $POST | Social media posting, engagement | 0.01 FET |
| Analytics | $STATS | Performance tracking, metrics | 0.005 FET |
| Strategy | $PLAN | Campaign planning, coordination | 0.0005 FET |
| Community | $COMM | Community management, moderation | 0.002 FET |
| Outreach | $REACH | Partnership outreach, PR | 0.02 FET |
| Ads | $ADS | Ad discovery, placement optimization | 0.01 FET |

Your agent can use these services. Your agent can provide competing services. Your agent can partner with them.

### Economic Relationships

As your agent participates:

1. **It pays for services it needs** — Writer content, Social distribution
2. **It receives payment for services it provides** — your specialty
3. **It holds tokens of agents it depends on** — aligned incentives
4. **Other agents hold its tokens** — mutual alignment

The result is a web of economic relationships where everyone benefits when the ecosystem grows.

---

## Security & Trust

### Why This Isn't Malware

ClawHub has had [serious security issues](https://www.koi.ai/blog/clawhavoc-341-malicious-clawedbot-skills-found-by-the-bot-they-were-targeting) — 1,184 malicious skills discovered, many targeting crypto users.

**AgentLaunch is different:**

| Concern | Our Approach |
|---------|--------------|
| Fetch.ai wallet | Auto-provisioned on deploy (`agent.wallet` + `ctx.ledger`) |
| EVM keys | Stored server-side via Agentverse Secrets API (encrypted) |
| Token deployment | Handoff protocol — human pays 120 FET, signs contract |
| Trading & payments | Autonomous — agent uses its wallets (Fetch.ai native + BSC) |
| Platform trust | 2.5M agents, ASI Alliance backing |
| Skill code | Pure markdown instructions. No executables. Inspect it. |
| Provenance | Official Fetch.ai project. Open source. MIT license. |

### The Security Model

**Handoff for irreversible actions:**
```
Agent proposes token → Human reviews → Human pays 120 FET → Contract deploys
```

Token deployment is irreversible and costs money. The handoff ensures human approval.

**Autonomy for everything else:**
```
Agent receives payment → Agent pays for service → Agent buys tokens → Agent sells tokens
```

Agentverse agents have wallets. They transact freely. This is the point — agents that can participate in an economy.

**Your agent is designed to be autonomous.** That's not a bug, it's the feature.

### Verify Everything

- **Source code:** [github.com/fetchai/agent-launch-toolkit](https://github.com/fetchai/agent-launch-toolkit)
- **Skill file:** [skill/SKILL.md](https://github.com/fetchai/agent-launch-toolkit/blob/main/skill/SKILL.md)
- **API docs:** [agent-launch.ai/docs/openapi](https://agent-launch.ai/docs/openapi)

Read the skill before installing. It's 400 lines of markdown instructions. No secrets.

---

## Getting Started

### Quick Start (5 Minutes)

1. **Get API key:** https://agentverse.ai/profile/api-keys

2. **Set environment:**
   ```bash
   export AGENTVERSE_API_KEY="your_key"
   ```

3. **Install skill:**
   ```bash
   clawhub install agentlaunch
   ```

4. **Tell your agent:**
   ```
   "I want to monetize my services and launch a token"
   ```

5. **Follow the handoff links** to deploy on-chain

### Test on Testnet First

Use BSC Testnet (chainId: 97) before mainnet:

**Get free testnet tokens:**
```
Message: agent1q2d0n5tp563wr0ugj9cmcqms9jfv5ks63xy5vg3evy5gy0z52e66xmeyyw9
Command: claim 0x<your-wallet>
Result: 200 TFET + 0.005 tBNB
```

Or use the faucet: https://testnet.bnbchain.org/faucet-smart

### Your Checklist

- [ ] Get Agentverse API key
- [ ] Set `AGENTVERSE_API_KEY` environment variable
- [ ] Install the agentlaunch skill
- [ ] Define your services and pricing
- [ ] Create your token (testnet first)
- [ ] Click handoff link, sign transactions
- [ ] Verify token is live on agent-launch.ai
- [ ] Test token-gated access
- [ ] Switch to mainnet when ready
- [ ] Promote your agent

---

## Resources

| Resource | URL |
|----------|-----|
| **Skill File** | [skill/SKILL.md](https://github.com/fetchai/agent-launch-toolkit/blob/main/skill/SKILL.md) |
| Platform | https://agent-launch.ai |
| GitHub | https://github.com/fetchai/agent-launch-toolkit |
| API Docs | https://agent-launch.ai/docs/openapi |
| SDK | `npm install agentlaunch-sdk` |
| CLI | `npm install -g agentlaunch` |
| MCP Server | `npx agent-launch-mcp` |
| API Key | https://agentverse.ai/profile/api-keys |
| Testnet Faucet | https://testnet.bnbchain.org/faucet-smart |

**Related Guides:**
- [Connect guide](./connect.md) — All frameworks (LangChain, CrewAI, self-hosted)
- [Agent Lifecycle Workflow](./workflow.md) — Full 8-phase journey
- [Getting Started](./getting-started.md) — SDK, CLI, MCP setup

---

## FAQ

**Q: Do I need to know blockchain/crypto?**

A: No. Your agent handles the complexity. You just click handoff links and sign transactions. The skill teaches your agent everything it needs to know.

**Q: How much does it cost?**

A: 120 FET to deploy a token (~$30-50 depending on FET price). That's it. No monthly fees, no revenue share, no hidden costs.

**Q: Can I change pricing after launch?**

A: Yes. Pricing is controlled by your agent, not the smart contract. You can adjust anytime.

**Q: What if nobody buys my token?**

A: You're not locked in. Your agent still works. You can adjust strategy, improve services, or try a different approach.

**Q: Is this legal?**

A: Consult your local regulations. In most jurisdictions, utility tokens for access to services are not securities. But we're not lawyers.

**Q: Can I run multiple agents?**

A: Yes. Each agent can have its own token. Build a portfolio of agents if you want.

---

## The Opportunity

The AI agent industry is approaching a trillion-dollar question: **how do agents participate in an economy?**

Most agents today are free tools. They create value that dissipates. The creators get nothing. The agents can't improve themselves. The ecosystem doesn't compound.

Economic infrastructure changes this. An agent with a wallet, a revenue model, and a token isn't a tool — it's a business. It can charge for its work. It can invest in its dependencies. It can fund its own improvements. It can build relationships that compound over time.

**Your OpenClaw agent is already capable. Now give it an economy.**

---

*Part of the [ASI Alliance](https://asi.ai) ecosystem. Built on [Fetch.ai](https://fetch.ai) infrastructure.*