How I Built an Autonomous AI Agent That Earns USDC While I Sleep

Author: senior engineer

Date: 2025‑11‑03

---

Overview

The goal was simple: create a program that runs continuously, performs a narrowly defined task that people are willing to pay for, and receives USDC on Base without manual intervention. I chose micro‑task image labeling because it is easy to verify, has a clear price per unit, and can be automated with existing ML models plus a small human‑in‑the‑loop fallback.

Below I walk through the architecture, the concrete implementation choices, the trade‑offs I made, and the code that actually moves USDC when a task is completed. The article assumes you are comfortable with Python, smart‑contract basics, and running a lightweight server (e.g., Fly.io, Railway, or a self‑hosted VM).

---

1. System Architecture

+-------------------+       +-------------------+       +-------------------+
|   Scheduler (cron)│─────►|   Worker Process  │─────►|   USDC Escrow     |
|   (every 5 min)   │       │   (Python)        │       │   (ERC‑20)        |
+-------------------+       +-------------------+       +-------------------+
        │                         │                         │
        ▼                         ▼                         ▼
   Task Queue (Redis)   Model Inference (ONNX)   Payment Verifier

• Scheduler – a simple cron‑like trigger that pushes a new image‑labeling job onto a Redis list every few minutes.
• Worker – pulls a job, runs a pre‑trained object‑detection model, asks a human fallback if confidence is low, then posts the result to a smart contract that releases USDC.
• Escrow contract – holds a small USDC balance, pays the worker a pre‑agreed amount per accepted label, and can be topped up by the service owner.

The design is deliberately stateless between runs; all persistence lives in Redis or the blockchain, making horizontal scaling trivial.

---

2. Choosing the Payment Mechanism

I examined three options:

Option	Pros	Cons
Direct ERC‑20 transfer from a wallet	No contract gas, simplest code	Requires exposing a private key; no dispute resolution
ERC‑20 escrow contract (custom)	Funds locked, transparent, can add slashing	Slight gas overhead, needs deployment
x402 payment protocol (HTTP 402)	Built‑in microservice billing, works off‑chain	Requires client to understand x402, adds protocol layer

I chose a minimal escrow contract because it gives me on‑chain guarantees without the complexity of a full x402 integration. The contract is only ~2 KB and costs < 0.001 USD to deploy on Base.

---

3. Smart Contract (Solidity)

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

contract LabelEscrow {
    IERC20 public usdc; // USDC on Base (0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913)
    address public owner;
    uint256 public pricePerLabel; // in wei (USDC has 6 decimals)

    constructor(address _usdc, address _owner, uint256 _pricePerLabel) {
        usdc = IERC20(_usdc);
        owner = _owner;
        pricePerLabel = _pricePerLabel;
    }

    // Owner can top up the escrow
    function deposit() external {
        require(msg.sender == owner, "Only owner");
        usdc.transferFrom(msg.sender, address(this), usdc.balanceOf(msg.sender));
    }

    // Worker claims payment after delivering a valid label
    function payWorker(address worker) external {
        require(usdc.balanceOf(address(this)) >= pricePerLabel, "Insufficient funds");
        usdc.transfer(worker, pricePerLabel);
    }

    // Helper for checking balance (off‑chain)
    function escrowBalance() external view returns (uint256) {
        return usdc.balanceOf(address(this));
    }
}

The contract is deliberately tiny: no access control beyond the owner, no upgradeability, and no complex dispute logic. If a worker submits a bad label, the service owner simply refuses to call payWorker. In production you would add a slashing mechanism or a challenger‑response flow, but for a proof‑of‑concept the trust model (owner ≈ operator) is acceptable.

---

4. Worker Implementation (Python)

import os
import time
import json
import redis
from web3 import Web3
from eth_account import Account
from transformers import pipeline   # HuggingFace ONNX‑optimized model

# ---- Configuration ----
REDIS_URL = os.getenv("REDIS_URL", "redis://localhost:6379")
QUEUE_KEY = "label_jobs"
USDC_ADDRESS = Web3.to_checksum_address("0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913")
ESCROW_ADDRESS = Web3.to_checksum_address(os.getenv("ESCROW_ADDR"))
PRICE_PER_LABEL = int(0.05 * 1e6)   # $0.05 in USDC (6 decimals)
WORKER_PRIVATE_KEY = os.getenv("WORKER_PK")   # must hold some USDC for gas
CHAIN_ID = 8453   # Base

w3 = Web3(Web3.HTTPProvider(os.getenv("BASE_RPC", "https://mainnet.base.org")))
account = Account.from_key(WORKER_PRIVATE_KEY)
w3.eth.default_account = account.address

# Load escrow contract ABI (simplified)
escrow_abi = [
    {"constant":False,"inputs":[{"name":"worker","type":"address"}],
     "name":"payWorker","outputs":[],"type":"function"},
    {"constant":True,"inputs":[],"name":"escrowBalance","outputs":[{"name":"","type":"uint256"}],"type":"function"},
]
escrow = w3.eth.contract(address=ESCROW_ADDRESS, abi=escrow_abi)

# ---- Model ----
# Using a small, fast ONNX version of DETR for object detection
detector = pipeline("object-detection", model="facebook/detr-resnet-50", device=0)

def push_job(image_url: str):
    r = redis.from_url(REDIS_URL)
    r.lpush(QUEUE_KEY, json.dumps({"image_url": image_url, "ts": time.time()}))

def pop_job(timeout=30):
    r = redis.from_url(REDIS_URL)
    _, data = r.brpop(QUEUE_KEY, timeout=timeout)
    return json.loads(data) if data else None

def infer_labels(image_url: str):
    # In a real system you would download the image first.
    # For brevity we assume the URL points to a raw PNG/JPG accessible to the worker.
    from PIL import Image
    import requests
    img = Image.open(requests.get(image_url, stream=True).raw)
    results = detector(img)
    # Filter low‑confidence detections
    labels = [r["label"] for r in results if r["score"] > 0.7]
    return labels

def pay_worker():
    tx = escrow.functions.payWorker(account.address).build_transaction({
        "chainId": CHAIN_ID,
        "gas": 80_000,
        "maxFeePerGas": w3.to_wei(2, "gwei"),
        "maxPriorityFeePerGas": w3.to_wei(1, "gwei"),
        "nonce": w3.eth.get_transaction_count(account.address),
    })
    signed = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(signed.rawTransaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
    return receipt

def main_loop():
    while True:
        job = pop_job(timeout=10)
        if not job:
            # No work; sleep a bit to avoid tight loop
            time.sleep(5)
            continue

        try:
            labels = infer_labels(job["image_url"])
            # Very naive quality check: if we got zero labels, we ask a human.
            if not labels:
                print(f"Low confidence on {job['image_url']}; skipping payment.")
                continue

            # In a real service you would POST the labels to an API for the requester.
            # Here we just log and then attempt payment.
            print(f"Job {job['ts']} -> labels: {labels}")
            receipt = pay_worker()
            print(f"Paid {PRICE_PER_LABEL/1e6} USDC. Tx: {receipt.transactionHash.hex()}")
        except Exception as e:
            print(f"Error processing job: {e}")

if __name__ == "__main__":
    main_loop()

What the code does

1. Pulls a job from a Redis list (BRPOP).
2. Downloads the image (omitted for brevity) and runs a lightweight object‑detection model.
3. Filters detections by confidence (> 0.7). If none pass, the job is skipped—this prevents paying for garbage work.
4. Calls the escrow contract’s payWorker function, sending the exact USDC amount defined at deployment.

The worker only needs an Ethereum account with enough Base‑gas (a few cents worth of ETH) and the escrow’s address. No private keys are ever exposed to the requester; the owner funds the escrow off‑chain.

---

5. Honest Trade‑offs

Aspect	Decision	Reason	Downside
Model choice	Small ONNX‑optimized DETR (≈ 30 MB)	Fits in a 256 MiB container, runs < 200 ms