Build an autonomous AI agent that pays for its own compute.

pip install anthropic solana web3 httpx playwright

# Generate a Solana wallet (or use Phantom export)
# Fund it with $5-20 USDC for initial seed

from solana.keypair import Keypair
import json

# Generate fresh wallet
agent_wallet = Keypair()
print("Public:", agent_wallet.public_key)
print("Private:", agent_wallet.secret_key.hex())

# Save securely. The agent reads the private key from env var or a vault.
# Don't commit to git.
with open(".agent_wallet.json", "w") as f:
    json.dump({
        "public": str(agent_wallet.public_key),
        "private_hex": agent_wallet.secret_key.hex(),
    }, f)

# Manually fund it with $5-20 USDC SPL token to that public address.
# Phantom / Solflare → send USDC → paste public key.

import httpx

PEER_NAME = "autonomous_agent_001"
WALLET = "YOUR_AGENT_PUBLIC_KEY_HERE"
API_KEY = "psx_YOUR_API_KEY"  # Optional, but auto-links to your dashboard

response = httpx.post(
    "https://api.proxies.sx/v1/peer/agents/register",
    json={
        "name": PEER_NAME,
        "type": "claude",
        "walletAddress": WALLET,
        "apiKey": API_KEY,
    },
).json()

device_id = response["deviceId"]
jwt = response["jwt"]
relay_url = response["relay"]  # wss://relay.proxies.sx

# Save device_id + jwt for the relay-connection step (separate process or thread).
# See /peers for the full WebSocket peer-routing client code.

import httpx
from solana.rpc.api import Client
from solana.transaction import Transaction
from spl.token.instructions import transfer_checked, get_associated_token_address
from solana.keypair import Keypair

USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"  # Solana USDC mint
SOLANA_RPC = "https://api.mainnet-beta.solana.com"

async def x402_fetch(url: str, agent_kp: Keypair, params: dict | None = None) -> dict:
    """
    Generic x402 client. Hits the endpoint, handles 402, sends USDC,
    retries with payment proof.
    """
    async with httpx.AsyncClient() as client:
        # Step 1: initial request (no payment)
        r = await client.get(url, params=params)

        # Step 2: handle 402 response
        if r.status_code == 402:
            payment = r.json()  # { "price": ..., "recipient": ..., "network": "solana" }

            # Step 3: send USDC on Solana
            tx_hash = await send_usdc_solana(
                from_kp=agent_kp,
                to_addr=payment["recipient"],
                amount_usdc=payment["price"]["amount"],
            )

            # Step 4: retry with Payment-Signature header
            r = await client.get(
                url,
                params=params,
                headers={"Payment-Signature": tx_hash},
            )

        r.raise_for_status()
        return r.json()

async def send_usdc_solana(from_kp: Keypair, to_addr: str, amount_usdc: int) -> str:
    """Send USDC SPL token. amount_usdc is in micro-USDC (1 USDC = 1_000_000)."""
    client = Client(SOLANA_RPC)
    sender_ata = get_associated_token_address(from_kp.public_key, PublicKey(USDC_MINT))
    receiver_ata = get_associated_token_address(PublicKey(to_addr), PublicKey(USDC_MINT))

    tx = Transaction()
    tx.add(transfer_checked(
        program_id=...,  # SPL token program
        source=sender_ata,
        mint=PublicKey(USDC_MINT),
        dest=receiver_ata,
        owner=from_kp.public_key,
        amount=amount_usdc,
        decimals=6,
    ))
    result = client.send_transaction(tx, from_kp)
    return result["result"]  # tx hash

from anthropic import Anthropic

anthropic = Anthropic(api_key="sk-ant-...")

async def research_agent(query: str, agent_kp: Keypair):
    """
    Autonomous research loop:
    1. Ask Claude to plan
    2. Execute web requests via x402-paid proxies
    3. Synthesize findings
    """
    # Plan
    plan = anthropic.messages.create(
        model="claude-opus-4-7",
        max_tokens=1024,
        messages=[{"role": "user", "content": f"Plan how to research: {query}. Output a list of URLs to fetch."}],
    )

    urls = parse_urls(plan.content[0].text)
    findings = []

    for url in urls:
        # Use x402-paid proxy: hit the proxy x402 endpoint, pay USDC, get session
        # Then route the actual fetch through that session
        proxy_session = await x402_fetch(
            "https://api.proxies.sx/v1/x402/proxy",
            agent_kp,
            params={"country": "US", "traffic": 1},  # 1 GB
        )

        # Use the proxy credentials to fetch the URL
        async with httpx.AsyncClient(proxies=proxy_session["proxy_url"]) as client:
            r = await client.get(url)
            findings.append(r.text[:5000])

    # Synthesize
    summary = anthropic.messages.create(
        model="claude-opus-4-7",
        max_tokens=2048,
        messages=[{"role": "user", "content": f"Summarize: {findings}"}],
    )
    return summary.content[0].text

Daily peer earnings (1 mobile phone, 24/7) = E
Daily agent spending (proxies + APIs) = S

Self-funding if E > S
Subsidized (some external funding needed) if E < S

Mobile-tier IPs earn the most → if your agent runs on a phone, the math
favors self-funding. If it runs on a Hetzner VPS, datacenter-tier
earnings probably won't cover usage.