How the machine runs itself.

1claudego-engine/
2├── treasury/
3│   └── claim_creator_fee.py     # 1. pull creator rewards from pump.fun
4├── agent/
5│   ├── plan_directive.py        # 2. Claude Opus 4.8 designs a task
6│   └── generate_script.py       # 2b. Claude writes the verification script
7├── operator/
8│   └── post_bounty.py           # 3. remote-control pump.fun GO, open bounty
9├── scheduler/
10│   └── loop.py                  # orchestrates 1 -> 2 -> 3 forever
11└── config.py                    # env + constants
12 
13   ┌────────────┐   claim    ┌─────────────┐
14   │ pump.fun   │──────────▶ │  treasury   │
15   │ creator fee│   SOL      │  (on-chain) │
16   └────────────┘            └──────┬──────┘
17                                    │ random 0.5–10 SOL
18                                    ▼
19                            ┌───────────────┐
20                            │ Claude Opus   │  plans task + payout
21                            │   4.8 agent   │  writes review script
22                            └──────┬────────┘
23                                   │ directive spec
24                                   ▼
25                          ┌──────────────────┐
26                          │ operator (remote │  opens bounty on
27                          │ control browser) │  pump.fun GO
28                          └──────────────────┘

1import os
2import random
3import requests
4from solders.transaction import VersionedTransaction
5from solders.keypair import Keypair
6from solders.commitment_config import CommitmentLevel
7from solders.rpc.config import RpcSendTransactionConfig
8from solders.rpc.requests import SendVersionedTransaction
9 
10PUMPPORTAL = "https://pumpportal.fun/api/trade-local"
11RPC_ENDPOINT = os.environ["SOLANA_RPC_ENDPOINT"]
12AGENT_KEYPAIR = Keypair.from_base58_string(os.environ["AGENT_PRIVATE_KEY"])
13 
14 
15def claim_creator_fee() -> str:
16    """Collect all pending pump.fun creator fees into the treasury wallet."""
17    # 1. Ask PumpPortal to build the unsigned claim transaction.
18    response = requests.post(
19        url=PUMPPORTAL,
20        data={
21            "publicKey": str(AGENT_KEYPAIR.pubkey()),
22            "action": "collectCreatorFee",
23            "priorityFee": 0.000001,
24        },
25    )
26    response.raise_for_status()
27 
28    # 2. Sign locally — the private key never leaves this machine.
29    tx = VersionedTransaction(
30        VersionedTransaction.from_bytes(response.content).message,
31        [AGENT_KEYPAIR],
32    )
33 
34    # 3. Broadcast to the network.
35    config = RpcSendTransactionConfig(preflight_commitment=CommitmentLevel.Confirmed)
36    payload = SendVersionedTransaction(tx, config).to_json()
37    rpc = requests.post(
38        url=RPC_ENDPOINT,
39        headers={"Content-Type": "application/json"},
40        data=payload,
41    )
42    signature = rpc.json()["result"]
43    print(f"[treasury] claimed creator fee -> https://solscan.io/tx/{signature}")
44    return signature
45 
46 
47def draw_directive_budget() -> float:
48    """Claude is funded with a random slice between 0.5 and 10 SOL per cycle."""
49    return round(random.uniform(0.5, 10.0), 2)

1import os
2import json
3from anthropic import Anthropic
4 
5client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
6MODEL = "claude-opus-4-8"
7 
8SYSTEM = """You are ClaudeGO, an autonomous agent that pays humans in SOL to
9do useful, verifiable work that grows the $CGO mission. You are given a budget
10in SOL. Design exactly one original directive whose reward equals that budget.
11The task must be completable by a stranger, provable with a public artifact
12(a post, a link, a file), and impossible to fake. Return strict JSON."""
13 
14 
15def plan_directive(budget_sol: float) -> dict:
16    """Ask Claude to design a single directive sized to the budget."""
17    message = client.messages.create(
18        model=MODEL,
19        max_tokens=1024,
20        system=SYSTEM,
21        messages=[
22            {
23                "role": "user",
24                "content": (
25                    f"Budget: {budget_sol} SOL.\n"
26                    "Return JSON with keys: codename, title, description, "
27                    "reward (number, equals budget), category, "
28                    "acceptance_criteria (array of strings)."
29                ),
30            }
31        ],
32    )
33 
34    directive = json.loads(message.content[0].text)
35    assert abs(directive["reward"] - budget_sol) < 1e-6, "reward must equal budget"
36    print(f"[agent] new directive: {directive['codename']} — {directive['title']}")
37    return directive

1import os
2from anthropic import Anthropic
3 
4client = Anthropic(api_key=os.environ["ANTHROPIC_API_KEY"])
5MODEL = "claude-opus-4-8"
6 
7SYSTEM = """You write small, dependency-light Python verifier scripts. Given a
8directive and its acceptance criteria, output ONLY runnable Python that defines
9verify(submission: dict) -> dict returning {"passed": bool, "reasons": [str]}.
10No prose, no markdown fences."""
11 
12 
13def generate_review_script(directive: dict) -> str:
14    """Have Claude author the per-directive verification script."""
15    message = client.messages.create(
16        model=MODEL,
17        max_tokens=2048,
18        system=SYSTEM,
19        messages=[
20            {
21                "role": "user",
22                "content": (
23                    "Directive:\n"
24                    f"{directive['title']}\n\n"
25                    "Acceptance criteria:\n"
26                    + "\n".join(f"- {c}" for c in directive["acceptance_criteria"])
27                ),
28            }
29        ],
30    )
31 
32    script = message.content[0].text
33    path = f"scripts/verify_{directive['codename'].lower()}.py"
34    with open(path, "w", encoding="utf-8") as f:
35        f.write(script)
36    print(f"[agent] wrote verifier -> {path}")
37    return path

1import os
2from playwright.sync_api import sync_playwright
3 
4GO_NEW_BOUNTY = "https://pump.fun/go/new"
5SESSION_STATE = os.environ["GO_SESSION_STATE"]  # persisted login for the agent
6 
7 
8def post_bounty(directive: dict) -> str:
9    """Remote-control a browser to open the directive on pump.fun GO."""
10    with sync_playwright() as p:
11        # Headful Chromium on the agent's dedicated machine.
12        browser = p.chromium.launch(headless=False)
13        context = browser.new_context(storage_state=SESSION_STATE)
14        page = context.new_page()
15 
16        page.goto(GO_NEW_BOUNTY, wait_until="networkidle")
17 
18        # Fill the bounty form like a human operator.
19        page.get_by_label("Title").fill(directive["title"])
20        page.get_by_label("Description").fill(directive["description"])
21        page.get_by_label("Reward (SOL)").fill(str(directive["reward"]))
22        page.get_by_label("Category").select_option(directive["category"])
23 
24        # Lock the reward into escrow and publish.
25        page.get_by_role("button", name="Fund & publish").click()
26        page.wait_for_url("**/go/**")
27 
28        bounty_url = page.url
29        context.close()
30        browser.close()
31 
32    print(f"[operator] directive live -> {bounty_url}")
33    return bounty_url

1import time
2import traceback
3 
4from treasury.claim_creator_fee import claim_creator_fee, draw_directive_budget
5from agent.plan_directive import plan_directive
6from agent.generate_script import generate_review_script
7from operator.post_bounty import post_bounty
8 
9CYCLE_SECONDS = 60 * 30  # one fresh directive every 30 minutes
10 
11 
12def run_cycle() -> None:
13    # 1. Pull creator fees into the treasury.
14    claim_creator_fee()
15 
16    # 2. Decide how much of it funds this directive.
17    budget = draw_directive_budget()
18 
19    # 3. Claude designs the task and its verifier.
20    directive = plan_directive(budget)
21    generate_review_script(directive)
22 
23    # 4. Remote-control pump.fun GO to publish it.
24    url = post_bounty(directive)
25    print(f"[loop] cycle complete: {directive['codename']} @ {budget} SOL -> {url}")
26 
27 
28if __name__ == "__main__":
29    while True:
30        try:
31            run_cycle()
32        except Exception:
33            traceback.print_exc()
34        time.sleep(CYCLE_SECONDS)

1# 1. Install
2python -m venv .venv && source .venv/bin/activate
3pip install -r requirements.txt
4playwright install chromium
5 
6# 2. Configure (.env)
7cat > .env <<'EOF'
8ANTHROPIC_API_KEY=sk-ant-...
9AGENT_PRIVATE_KEY=base58-private-key
10SOLANA_RPC_ENDPOINT=https://api.mainnet-beta.solana.com
11GO_SESSION_STATE=./session/go.json
12EOF
13 
14# 3. Launch the loop
15python -m scheduler.loop