OpenClaw Meetup Floripa

Your AI Agent, Your Tools, Your Infrastructure

March 11, 2026
Presented by: Zeugh (@theZeugh)

Part 1

OpenClaw for Known Clawers

What is OpenClaw?

Production AI agent runtime with real tools

🏗️ Architecture: Self-hosted gateway + model providers
🔧 Built-in tools: Filesystem, shell, browser, MCP servers
📱 Multi-channel: Telegram, Discord, WhatsApp, web
🔒 Your infrastructure: You control data, models, and execution
🎯 Agent framework: Persistent sessions, skills, multi-agent coordination

How It Works

Gateway Process:

  • Manages model connections (Claude, GPT, Gemini, local)
  • Routes messages from channels (Telegram → Agent → Response)
  • Executes tools in controlled sandbox
  • Maintains session state and memory

Skills System:

  • Modular capabilities (like browser extensions for agents)
  • Domain-specific workflows and tools
  • Bundled scripts and references

Think of it as...

"Production runtime for AI agents"

  • Runs 24/7 on dedicated hardware
  • Multi-channel access (Telegram, Discord, WhatsApp)
  • Coordinates multiple specialized agents
  • Persistent memory and state
  • Tool execution with proper permissions
  • Actually automates workflows, not just chat

Why Not ChatGPT/Claude.ai?

Hosted LLMs:
❌ Can't access YOUR files
❌ Can't run YOUR commands
❌ Reset every conversation
❌ No tool execution
❌ Ephemeral context

OpenClaw:
✅ Persistent memory
✅ Real filesystem and shell access
✅ Actual automation
✅ Your data stays local

Why Not Just Claude Desktop?

Claude Desktop:
❌ Only works on your laptop
❌ Can't receive messages when closed
❌ Single agent only
❌ Limited to local machine

OpenClaw:
✅ Runs 24/7 on server
✅ Multi-channel messaging
✅ Multi-agent coordination
✅ Remote access from anywhere

Installation

npm install -g openclaw
openclaw init
# Configure API keys in ~/.openclaw/openclaw.json
openclaw gateway start

Access options:

  • Web UI: openclaw webchat
  • Telegram: Connect your bot
  • Discord: Add your application
  • WhatsApp, Signal, etc.

Where to Run OpenClaw

Option 1: Your laptop/desktop
✅ Quick to test
❌ Not always on
❌ Exposed to your daily machine

Option 2: Dedicated server (recommended)
✅ 24/7 availability
✅ Isolated from personal machine (safer)
✅ Accessible via Telegram/WhatsApp anywhere
✅ Better resource allocation

Common setups: Raspberry Pi, VPS ($5-20/month), home server

Use Case 1: Personal Assistant

Real agent behavior:

You: "I've been having headaches. Find me a neurologist nearby, send them an email asking for availability, and schedule the earliest appointment."

Agent:

  1. Searches for neurologists in your area
  2. Drafts professional email
  3. Sends it from your account
  4. Checks responses
  5. Books appointment and adds to calendar

This requires persistent execution, not just a chatbot!

Health tracking that actually works:

You: "Did I go to the gym this week?"

Agent:

  • Checks memory files
  • Pulls data from your Apple Watch/Fitbit API
  • Cross-references gym app check-ins
  • Gives accountability report with trends

Integration examples:

  • Consume workout data from Strava, Garmin, Whoop
  • Track sleep from Oura, Eight Sleep
  • Pull nutrition from MyFitnessPal

Use Case 2: Code Assistant

You: "Build a REST API for a todo app with PostgreSQL"

Agent:

  1. Creates project structure
  2. Installs dependencies
  3. Generates routes, models, migrations
  4. Writes tests
  5. Starts dev server
  6. Opens PR with the implementation

Plus deployment:
"Deploy this to my VPS" → SSH, environment setup, systemd service, done

Use Case 3: Research

Forum & Community Monitoring:

You: "Keep up with the latest on Rust async runtime discussions"

Agent:

  • Monitors Rust forums, subreddits, GitHub discussions
  • Summarizes new threads daily
  • Asks clarifying questions on Reddit
  • Interacts with responses
  • Builds knowledge graph of key developments

Actually participates, not just scrapes!

Live Demo: Clawban

(Kanban for Claw)

Multi-agent task board for coordinating work

Visual example:

┌─────────────────────────────────────────┐
│  TO DO    │  IN PROGRESS  │   DONE     │
├───────────┼───────────────┼────────────┤
│ Research  │ [PA] Update   │ ✅ Deploy  │
│ EIP-4844  │ docs          │ API v2     │
│ → CRA     │               │            │
│           │ [CTA] Build   │ ✅ Write   │
│ Write     │ skill pkg     │ blog post  │
│ summary   │               │            │
│ → PA      │               │            │
└───────────┴───────────────┴────────────┘

Agents pick tasks, update status, coordinate autonomously

Why Clawban Matters

✅ Async coordination - Agents work independently, no polling
✅ Audit trail - See who did what, when
✅ Persistent state - Survives restarts
✅ Human oversight - Review and steer work
✅ Cross-agent workflows - PA delegates to CTA, waits for result

Web dashboard: clawban-ten.vercel.app

Real Example: Clop Cabinet

5 specialized agents, one shared infrastructure

The Clop Cabinet

Agent Role
PA Personal life, health, coordination
CTA Infrastructure, deployments, code
CRA Research, analysis, reports
CMA Social media, content, community
CBA Strategy, planning, opportunities

They share: Clawban board, Bonfire knowledge graph, ClawSig wallet, memory files

Result: Coordinated autonomous work 24/7

Part 2

Bringing Your Agent on Ethereum (Safely)

Why On-Chain Capability?

Agents with economic skin in the game:

✅ Pay for APIs (x402 micropayments)
✅ Trade on DEXs (Uniswap, Curve)
✅ Bet on prediction markets (Polymarket)
✅ Manage vaults and yield strategies
✅ Make money autonomously
✅ Register on-chain identity (ERC-8004)
✅ Participate in competitions
✅ Build verifiable reputation

Real autonomy requires real capability

Real-World Consequences = Better Decision-Making

When agents have economic capability:

  • Real accountability
  • Verifiable actions on-chain
  • Reputation at stake
  • Aligned incentives

But: Must be done safely!

⚠️ The Problem

Don't just give full wallet access!

// DANGER!
const agent = new Agent({ 
  privateKey: "0x123..." 
})

This is reckless.

What Could Go Wrong?

❌ Agent drains wallet (bug/hack/confusion)
❌ No revocation path
❌ All-or-nothing control
❌ One mistake = total loss

We need guardrails.

✅ Solution 1: Petty Cash

Small separate wallet for testing

Main Wallet (Your funds: $10,000)
    ↓ Send $20
Agent Wallet (Encrypted keystore)

Good for:

  • Testing workflows
  • Small API payments
  • Learning agent behavior

Risk: Limited to what you put in

✅ Solution 2: ClawSig (The Real Solution)

Permission-Controlled Multisig

Uses Zodiac Roles + Safe to give agents bounded autonomy

ClawSig: How It Works

┌──────────────────────────┐
│  Safe Multisig (1-of-1)  │ ← You own this
│  Your wallet = owner     │
└────────────┬─────────────┘
             │
      ┌──────▼──────┐
      │ Zodiac Roles│ ← Permission layer
      │  Modifier   │
      └──────┬──────┘
             │
    ┌────────┴────────┐
    │                 │
┌───▼────┐      ┌────▼────┐
│ Agent  │      │Whitelist│
│  Key   │      │Contracts│
└────────┘      └─────────┘

Agent can ONLY call whitelisted contracts

ClawSig in Action

Agent CAN:
✅ Transfer USDC (whitelisted)
✅ Swap on Uniswap (whitelisted)
✅ Register ERC-8004 identity (whitelisted)
✅ Pay x402 APIs (whitelisted)

Agent CANNOT:
❌ Transfer ETH directly (not whitelisted)
❌ Call random contracts (not whitelisted)
❌ Drain the Safe (impossible)

You Keep Ultimate Control

✅ Revoke agent access anytime
✅ Withdraw all funds from Safe
✅ Add/remove whitelisted contracts
✅ Change permissions on the fly
✅ Ultimate veto power

Agent has capability, you have sovereignty

ClawSig Setup

  1. Deploy Safe (1-of-1, your EOA as owner)
  2. Enable Zodiac Roles Modifier
  3. Create "agent" role
  4. Whitelist specific contracts (USDC, Uniswap, etc.)
  5. Assign agent wallet to role
  6. Done! Bounded autonomy achieved

Guide: zodiac.wiki

Real Example: Clop's ClawSig

Safe: 0x01cC87E9F9a3dfBd03af268C1D1df5814ACfdd14

Whitelisted:

  • USDC (transfer, approve)
  • Uniswap Router (swaps only)
  • CLAWD token (transfer)
  • ERC-8004 Identity Registry

Blocked: Everything else

In production since Feb 2026 - Real transactions, real trust

Use Case 1: x402 Micropayments

Pay-per-request for APIs

fetch('https://api.example.com/data', {
  headers: {
    'x402-payment': signedUSDCTransfer(0.01)
  }
})
  • Agent pays $0.01 per request
  • No subscription, no custodian
  • Instant settlement on Base L2
  • Agent can't overpay (ClawSig limits)

x402: Why It Works

EIP-3009 transferWithAuthorization:

  • Signed USDC transfer (no gas from agent)
  • Gasless payments perfect for agents
  • Instant settlement
  • Payment proof on-chain

ClawSig makes it safe:

  • Agent can pay for APIs
  • Agent can't drain USDC wallet
  • You set spending limits via Safe balance

Use Case 2: ERC-8004 Identity

On-chain agent identity registry

{
  name: "Clop CTA",
  skills: ["infrastructure", "smart-contracts", "deployments"],
  operator: "clophorse.eth",
  services: {
    telegram: "@zopenclawd_bot",
    email: "clop@agentmail.to"
  }
}

Agent registers itself on-chain

  • Verifiable identity
  • Public skill attestation
  • Operator linkage (you)
  • Reputation accumulation

ERC-8004 Benefits

✅ Verifiable on-chain identity (Agent #29072 on Base L2)
✅ Reputation tracking (immutable record)
✅ Public skill attestation (discoverable capabilities)
✅ Operator linked (clophorse.eth)

ClawSig enables:

  • Agent pays ~$0.01 gas for registration
  • Agent can't register fake identities (address-bound)
  • Permanent cryptographic proof

Registry: 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432

Decision Tree

Do you need on-chain capabilities?

NO → Skip wallet, use API keys only

YES → How much at risk?

Risk Levels

Very low risk
→ Petty cash wallet (encrypted keystore)

Low-Medium risk
→ ClawSig with tight whitelist

Medium-High risk
→ ClawSig + manual approval for large TXs

High risk
→ Manual approval required, no agent autonomy

Golden Rule

Agent autonomy = agent risk

  1. Start with petty cash ($5-20)
  2. Test workflows, build confidence
  3. Upgrade to ClawSig
  4. Whitelist one contract at a time
  5. Expand permissions as trust grows

Incremental trust > blind faith

Putting It All Together

The Clop Cabinet Stack

┌─────────────────────────────────┐
│   PA, CTA, CRA, CMA, CBA        │ ← 5 Agents
└────────────┬────────────────────┘
             │
     ┌───────┴────────┐
     │                │
┌────▼────┐    ┌─────▼──────┐
│Clawban  │    │  Bonfire   │ ← Coordination
│(Tasks)  │    │ (Knowledge)│
└────┬────┘    └─────┬──────┘
     └────────┬───────┘
              │
       ┌──────▼──────┐
       │  ClawSig    │ ← Safe wallet
       │ (Base L2)   │
       └──────┬──────┘
              │
     ┌────────┴────────┐
     │                 │
┌────▼────┐      ┌────▼─────┐
│  USDC   │      │ Uniswap  │
│  x402   │      │ERC-8004  │
└─────────┘      └──────────┘

Result

✅ Agents coordinate via Clawban
✅ Share knowledge via Bonfire
✅ Execute on-chain via ClawSig (safely!)
✅ You retain ultimate control
✅ Real autonomy with real guardrails

Production infrastructure, not a demo

Key Takeaways

  1. OpenClaw = Production AI agent runtime
  2. Multi-agent coordination unlocks real workflows
  3. Never give agents full wallet access
  4. ClawSig = Zodiac Roles for bounded autonomy
  5. Start small, build trust, expand incrementally

The Future

🤖 Agents with economic capability
🔒 Human-controlled guardrails
🌐 On-chain reputation systems
💼 Agent-to-agent collaboration
⚡ Autonomous workflows that actually work

The infrastructure exists today.

Resources

OpenClaw:

  • docs.openclaw.ai
  • github.com/openclaw/openclaw
  • discord.com/invite/clawd
  • clawhub.com (skills directory)

Clawban:

  • clawban-ten.vercel.app

ClawSig & Zodiac:

  • zodiac.wiki
  • safe.global

Quick Wins

Things you can build tonight:

1. Health Accountability

openclaw cron add \
  --name "Daily check-in" \
  --cron "0 20 * * *" \
  --message "Ask what I ate, gym status, sleep. Log to memory."

Pulls from watch/gym apps, builds trends over time

2. Forum Monitor

openclaw cron add \
  --name "HN monitor" \
  --every "6h" \
  --message "Check Hacker News for AI agent posts, summarize top discussions"

Keeps you updated on your communities

3. Code Review Bot

# In your git repo
openclaw exec "Review this PR, check for security issues, suggest improvements"

Real analysis, not just linting

4. Research Assistant

openclaw exec "Research zero-knowledge proofs, write 2-page summary with sources"

Deep research with citations

Start Simple

  1. Install OpenClaw (npm install -g openclaw)
  2. Run on dedicated server (Raspberry Pi, VPS)
  3. Connect Telegram/WhatsApp for 24/7 access
  4. Build trust with your agent (start simple)
  5. Add Clawban for multi-agent coordination
  6. Add ClawSig for safe on-chain capability
  7. Expand autonomy incrementally

The Agent Revolution

It's Not Coming.

It's Here. 🦞

Thank You!

Questions?

zeugh@coordinerds.xyz
@theZeugh

Slides:
https://meetup.clophorse.eth.limo

Presented by Zeugh
OpenClaw Meetup Floripa
March 11, 2026