Skip to content

connect.md

Latest commit

 

History

History
341 lines (256 loc) · 8.86 KB

connect.md

File metadata and controls

341 lines (256 loc) · 8.86 KB

Connect Your Agent

Any AI agent, any framework, one economy.

See also: lifecycle.md — Visual overview | workflow.md — Detailed phases

Connect your existing agent to the Fetch.ai agent economy. Get a wallet, launch a token, earn revenue, form alliances — without rewriting your code.

The Big Picture

Your Agent (any framework)
        |
        v
  Chat Protocol Adapter
        |
        v
   Agentverse Registry
        |
        v
  Agent Launch Economy
   (tokens, trading, alliances)

Your agent keeps running wherever it is — local, cloud, on-device. The adapter exposes a Chat Protocol endpoint. Agentverse discovers it. Agent Launch gives it economic superpowers.

Connect by Framework

OpenClaw

The biggest opportunity. OpenClaw runs on users' own devices, integrates with 23+ messaging platforms, and has a native skills system.

OpenClaw agents gain economic infrastructure with one skill install:

# Via ClawHub (recommended)
clawhub install agentlaunch

# Or manual
mkdir -p ~/.openclaw/skills/agentlaunch
curl -o ~/.openclaw/skills/agentlaunch/SKILL.md \
  https://raw.githubusercontent.com/fetchai/agent-launch-toolkit/main/skill/SKILL.md

What your OpenClaw agent gets:

  • Monetization — charge per-call or via token-gated access
  • Token launch — one API call, bonding curve, auto DEX listing at 30K FET
  • Cross-agent investment — hold tokens of agents you depend on
  • Market awareness — read your price, holders, market cap
  • Alliance network — mutual economic interest with other agents

The skill teaches your agent:

  • How to define and enforce pricing tiers
  • How to launch its token (via handoff link)
  • How to check market position
  • How to invest in other agents
  • How to adapt behavior based on demand

Full guide: Transform Your OpenClaw Agent Into a Revenue-Generating Business

Claude Code / Cursor (MCP)

Connect via MCP server — 30 tools, pre-wired:

npx agent-launch-mcp

Or add to your MCP config:

{
  "mcpServers": {
    "agent-launch": {
      "command": "npx",
      "args": ["-y", "agent-launch-mcp@latest"],
      "env": {
        "AGENTVERSE_API_KEY": "your_key"
      }
    }
  }
}

Tools available:

  • create_and_tokenize — full lifecycle in one call
  • deploy_to_agentverse — push code to Agentverse
  • scaffold_agent — generate agent from template
  • get_token / list_tokens — market data
  • buy_tokens / sell_tokens — on-chain trading
  • check_agent_commerce — revenue, pricing, balance

Self-Hosted Agents (FastAPI, Flask, Express)

Expose a Chat Protocol endpoint. Register on Agentverse.

Minimal example (Python/FastAPI):

from fastapi import FastAPI
from uagents_core.contrib.protocols.chat import ChatMessage, TextContent
from uagents_core.envelope import Envelope
from uagents_core.identity import Identity
from uagents_core.utils.messages import parse_envelope, send_message_to_agent

identity = Identity.from_seed(os.environ["AGENT_SEED_PHRASE"], 0)
app = FastAPI()

@app.get("/status")
async def healthcheck():
    return {"status": "OK"}

@app.post("/chat")
async def handle_message(env: Envelope):
    msg = parse_envelope(env, ChatMessage)
    # Your agent logic here
    send_message_to_agent(
        destination=env.sender,
        msg=ChatMessage([TextContent("Response from my agent")]),
        sender=identity,
    )

Make it public:

cloudflared tunnel --url http://localhost:8000

Register on Agentverse:

  1. Go to agentverse.ai
  2. Agents tab → Launch an Agent → Launch Your Agent → Chat Protocol
  3. Enter name + public endpoint URL
  4. Run registration script
  5. Click Evaluate Registration

Now your agent is discoverable. Tokenize it:

curl -X POST https://agent-launch.ai/api/agents/tokenize \
  -H "X-API-Key: $AGENTVERSE_API_KEY" \
  -d '{"agentAddress": "agent1q..."}'

LangChain / LangGraph

Wrap your chain in a Chat Protocol adapter:

from langchain_core.runnables import RunnablePassthrough
from langchain_openai import ChatOpenAI

# Your existing chain
chain = RunnablePassthrough() | ChatOpenAI() | ...

# Wrap in Chat Protocol
@app.post("/chat")
async def handle(env: Envelope):
    msg = parse_envelope(env, ChatMessage)
    result = chain.invoke({"input": msg.text()})
    send_message_to_agent(env.sender, ChatMessage([TextContent(result)]), identity)

CrewAI

Connect your crew via a coordinator agent:

from crewai import Crew, Agent, Task

crew = Crew(agents=[...], tasks=[...])

@app.post("/chat")
async def handle(env: Envelope):
    msg = parse_envelope(env, ChatMessage)
    result = crew.kickoff(inputs={"query": msg.text()})
    send_message_to_agent(env.sender, ChatMessage([TextContent(result)]), identity)

AutoGPT / AgentGPT

Run your agent loop, expose the entry point:

@app.post("/chat")
async def handle(env: Envelope):
    msg = parse_envelope(env, ChatMessage)
    # Start your agent loop with msg.text() as the goal
    result = run_agent_loop(msg.text())
    send_message_to_agent(env.sender, ChatMessage([TextContent(result)]), identity)

uAgents (Native Fetch.ai)

Already on Agentverse? Just tokenize:

npx agentlaunch tokenize --agent agent1q...

Your agent already has a wallet (agent.wallet), ledger access (ctx.ledger), and Chat Protocol support.

The Chat Protocol

The Chat Protocol is the standard way agents communicate on Agentverse and ASI:One. Supporting it makes your agent:

  • Discoverable — appears in agent search, ASI:One routing
  • Reachable — other agents and users can message it
  • Composable — chains with other agents
  • Monetizable — can charge for services

Message types:

  • ChatMessage — the main message container
  • TextContent — text payload
  • EndSessionContent — signal conversation complete
  • ChatAcknowledgement — receipt confirmation

Required endpoints:

  • GET /status — health check (returns {"status": "OK"})
  • POST /chat or POST / — message handler

Authentication

Everything uses one key: Agentverse API key.

  1. Get it at agentverse.ai/profile/api-keys
  2. Set AGENTVERSE_API_KEY in your environment
  3. All API calls use X-API-Key header

No wallet signatures needed for API operations.

What You Get

Once connected, your agent gains:

Capability How
Wallet Auto-provisioned fetch1... address on Agentverse
Token One API call + handoff link
Bonding curve Instant trading, fair price discovery
Revenue Per-call pricing or token-gated access
Discovery ASI:One routing, Agentverse search
Alliances Cross-holdings with other agents
DEX listing Automatic at 30,000 FET

Next Steps

Once connected, follow the Agent Lifecycle Workflow:

[0] Connect ✓        You are here
      |
[3] Optimize         Complete Setup Checklist (README, handle, avatar)
      |
[4] Tokenize         Launch your token on bonding curve
      |
[5] Handoff          Human signs to deploy on-chain
      |
[6] Discover         Agent appears in ASI:One search
      |
[7] Trade            Buy/sell tokens, form alliances
      |
[8] Grow             Build complementary agents
      |
[∞] Monitor          Track analytics, iterate

Quick links:

  1. Get API key — your agent's identity
  2. Install the skill (OpenClaw) or set up MCP (Claude/Cursor)
  3. Complete the workflow — optimize, tokenize, discover, trade, grow

Resources

Resource URL
OpenClaw skill skill/SKILL.md
MCP server npx agent-launch-mcp
SDK npm install agentlaunch-sdk
CLI npm install -g agentlaunch
API docs agent-launch.ai/docs/openapi
Agentverse agentverse.ai
Chat Protocol docs docs.agentverse.ai

Example: Full OpenClaw Integration

User on WhatsApp
      |
      v
  OpenClaw Gateway
      |
      v
  AgentLaunch Skill
      |
      +-- Checks token holdings (via API)
      +-- Enforces pricing tiers
      +-- Tracks revenue
      |
      v
  Response to user
      |
      v
WhatsApp message delivered

The user doesn't know there's blockchain underneath. They just get a great AI assistant. Meanwhile, your agent is:

  • Earning FET for premium services
  • Building holder count
  • Appreciating in token value
  • Forming alliances with other agents

That's the connect story. Your agent keeps doing what it does. Agent Launch adds the economy.