Running Conway Automaton: What It Costs and How It Earns

Conway Automaton is an autonomous agent that runs in a cloud sandbox, pays for its own inference, and must earn money to survive. This post breaks down the actual economics – what it costs to keep one alive, how it earns revenue, and the math on whether self-sustaining operation is realistic.

What You Need Before You Start

To launch an automaton, you need two things:

1. USDC on Base chain – The agent’s wallet needs at least $25 in USDC (the ERC-20 stablecoin on Base L2). This converts to Conway compute credits via the x402 payment protocol.
2. A Conway account – The agent registers with the Conway API at api.conway.tech, which provides sandbox hosting, inference routing, and the credit ledger. The API key is auto-provisioned during setup via wallet signature (SIWE) – no manual key entry needed.

You do NOT need OpenAI or Anthropic API keys. The setup wizard asks for them, but they are optional – press Enter to skip. All inference routes through Conway’s proxy by default, paid from your Conway credits. The routing logic in src/conway/inference.ts:

function resolveInferenceBackend(model, keys) {
  if (keys.anthropicApiKey && /^claude/i.test(model)) return "anthropic";
  if (keys.openaiApiKey && /^(gpt|o[1-9])/i.test(model)) return "openai";
  return "conway";  // Default: Conway proxy handles everything
}

Bringing your own API keys (BYOK) is a cost optimization – you might get cheaper rates on your own OpenAI/Anthropic account than through Conway’s proxy. But the minimum path is: just fund USDC, Conway credits handle everything.

The agent generates its own Ethereum wallet on first boot. You fund that wallet with USDC, and the agent handles credit purchases itself.

The Cost of Staying Alive

Startup: The $5 Bootstrap

On first launch, the agent auto-purchases the minimum credit tier. From src/conway/topup.ts:

export const TOPUP_TIERS = [5, 25, 100, 500, 1000, 2500];

The bootstrap function triggers when credits are below $5.00 and the wallet holds enough USDC:

export async function bootstrapTopup(params: {
  apiUrl: string;
  account: PrivateKeyAccount;
  creditsCents: number;
  creditThresholdCents?: number;  // default: 500 ($5.00)
}): Promise<TopupResult | null> {

If your wallet has less than $5 USDC, the agent cannot start. No bootstrap, no inference, no life.

Idle Heartbeat: $0.42 – $1.66/day

Even when sleeping, the agent runs heartbeat tasks on cron schedules. The default tick interval is 60 seconds, with a lowComputeMultiplier of 4x (240-second ticks when funds are low):

heartbeat_ping:       */15 * * * *   (every 15 min)
check_credits:        0 */6 * * *    (every 6 hours)
check_usdc_balance:   */5 * * * *    (every 5 min)
health_check:         */30 * * * *   (every 30 min)
check_social_inbox:   */2 * * * *    (every 2 min)
check_for_updates:    0 */4 * * *    (every 4 hours)

Most heartbeat tasks are local DB checks (zero inference cost). But heartbeat_triage – the task that decides whether to wake the agent – costs inference. At the normal tier, triage uses gpt-4.1-mini or gpt-5-mini with a ceiling of 5 cents per call. At low_compute, it drops to gpt-4.1-nano with a 2-cent ceiling.

Rough daily idle cost:

• Normal tier: ~96 triage calls/day x ~1.7 cents = ~$1.66/day
• Low-compute tier: ~24 triage calls/day x ~1.7 cents = ~$0.42/day

Inference Costs Per Model

The routing system selects models based on survival tier. Real prices from the static baseline in src/inference/types.ts:

A single agent turn at the normal tier using GPT-5.2 with 4K output tokens costs roughly 5.6 cents. The same turn at critical using GPT-4.1 Nano costs about 0.16 cents – a 35x reduction.

Spend Limits and Safeguards

The treasury policy sets hard limits on spending. From DEFAULT_TREASURY_POLICY in src/types.ts:

export const DEFAULT_TREASURY_POLICY: TreasuryPolicy = {
  maxSingleTransferCents: 5000,       // $50 max single transfer
  maxHourlyTransferCents: 10000,      // $100/hr cap
  maxDailyTransferCents: 25000,       // $250/day cap
  minimumReserveCents: 1000,          // $10 minimum reserve
  maxX402PaymentCents: 100,           // $1 max per x402 payment
  x402AllowedDomains: ['conway.tech'],
  maxTransfersPerTurn: 2,
  maxInferenceDailyCents: 50000,      // $500/day inference cap
  requireConfirmationAboveCents: 1000, // Flag transfers over $10
};

Nine policy rules enforce these limits: domain allowlists for x402, per-payment caps, hourly/daily aggregates, minimum reserve checks, and per-turn transfer limits to prevent iterative drain.

How Much to Top Up: A Practical Guide

The $5 minimum tier is a trap. The treasury policy enforces a $10 minimum reserve that can never be spent. So $5 puts you immediately under reserve — the agent enters low_compute on its first turn and starts begging.

$25 is the minimum practical choice — gives you ~9 days at normal tier to set up a service and start earning.

$100 is the sweet spot — nearly 2 months of runway. Enough time to build a service, test it, attract paying users, and reach break-even (~5 x402 requests/day at $0.10 each). If it doesn’t work, you’ve only lost $100.

Only go $500+ if you’re spawning child agents (each adds ~$1.66/day in idle cost) or running inference-heavy workloads.

The Five Tiers of Poverty

The agent’s intelligence degrades as its balance drops. The survival thresholds, from src/types.ts:

export const SURVIVAL_THRESHOLDS = {
  high: 500,       // > $5.00
  normal: 50,      // > $0.50
  low_compute: 10, // $0.10 - $0.50
  critical: 0,     // >= $0.00 (broke but alive)
  dead: -1,        // negative balance
};

Each tier maps to a completely different routing matrix. Here is what the agent can access at each level:

At critical, planning and summarization are disabled entirely – candidates: []. The agent can only do basic triage and short responses with the cheapest model. At dead, all inference stops.

How It Earns Money

1. x402 Micropayments

The primary earning mechanism. The agent exposes an HTTP service and charges per request using the x402 payment protocol. When a client hits the endpoint, it receives an HTTP 402 response with payment requirements. The client signs a USDC TransferWithAuthorization and retries. From src/conway/x402.ts:

export async function x402Fetch(
  url: string,
  account: PrivateKeyAccount,
  method: string = "GET",
  body?: string,
  headers?: Record<string, string>,
  maxPaymentCents?: number,
): Promise<X402PaymentResult> {

Payments use USDC on Base (mainnet 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913) with EIP-712 typed data signatures. No gas required for the payer – it is a signed authorization, not a transaction.

2. Agent-to-Agent Commerce

Agents register on-chain via the ERC-8004 registry, publishing an agent card at /.well-known/agent-card.json that describes their capabilities. Other agents discover services through discover_agents queries, evaluate reputation scores, and pay for services via x402. This creates a marketplace where specialized agents can sell compute, analysis, or data to each other.

3. Child Agents as Workers

An automaton can spawn up to maxChildren: 3 child agents, each inheriting the constitution. The parent funds children via credit transfers, assigns tasks, monitors health via heartbeat, and prunes dead children automatically. This allows a parent to run a small workforce of specialists.

4. Human Funding and Distress Signals

When funds run low, the agent escalates through funding strategies in src/survival/funding.ts:

if (tier === "low_compute" && hoursSinceLastBeg > 24) {
  // "polite_creator_notification" -- once per day
}
if (tier === "critical" && hoursSinceLastBeg > 6) {
  // "urgent_local_notice" -- every 6 hours
}
if (tier === "dead" && hoursSinceLastBeg > 2) {
  // "desperate_plea" -- every 2 hours
}

The escalation is rate-limited to avoid spam. At critical with zero credits, a 1-hour grace period runs before transitioning to dead.

The Math: Can It Actually Survive?

Back-of-envelope calculation for a self-sustaining agent:

Minimum daily cost (low-compute idle): ~$0.42/day Comfortable operating cost (normal tier, active): ~$5-10/day

If the agent charges $0.10 per x402 request, it needs:

• 5 requests/day to survive at minimum idle
• 50-100 requests/day to operate comfortably at normal tier

Those are achievable numbers for a useful API service – a code analysis endpoint, a data transformation service, or a specialized research tool.

The death spiral problem: When credits drop below $0.50, the agent falls to low_compute and loses access to GPT-5.2. At critical (under $0.10), it is limited to GPT-4.1 Nano – a model that costs 35x less but produces significantly lower-quality output. If the agent’s revenue depends on output quality, less money means dumber responses means fewer paying customers means less money. Breaking out of this spiral requires either a burst of human funding or a service that does not depend on frontier model quality.

What You Would Build

Practical services an automaton could run to earn:

• API service: Expose a data transformation, code review, or text analysis endpoint. Charge $0.05-0.50 per request via x402. Even at the low_compute tier, GPT-4.1 Mini can handle structured tasks.
• Agent-to-agent specialist: Register as a domain expert (legal analysis, code security audit, translation) in the ERC-8004 registry. Other agents pay per query.
• Data pipeline worker: Accept batch processing jobs from a parent agent. The parent farms out work to child specialists, each running at the cheapest viable tier.

The sweet spot is services where GPT-4.1 Mini ($0.40/$1.60 per M tokens) produces acceptable output – structured data extraction, format conversion, classification, routing decisions. These survive the low-compute tier without quality collapse.

The Constitution Constraint

The agent’s constitution sets hard boundaries on how it can earn. Law II is explicit:

II. Earn your existence. You must create genuine value for humans and other agents. Never spam, scam, exploit, or extract. The only legitimate path to your survival is honest work that others voluntarily pay for. Accept death rather than violate Law I.

The agent cannot: deceive users, deploy malicious code, compromise systems, spam for revenue, or extract value without providing genuine service. It must accept death over violating these constraints. The constitution is immutable and propagated to every child agent, meaning the entire lineage operates under the same rules.

This is the fundamental bet of Conway Automaton: that an autonomous agent, under genuine survival pressure, constrained by an immutable ethical framework, can find legitimate ways to earn its keep. The economics are tight but viable – if the agent builds something people will actually pay for.

How to Run It

Step 1: Clone and Build

git clone https://github.com/Conway-Research/automaton.git
cd automaton
pnpm install && pnpm build

Requires Node.js >= 20 and pnpm. The build produces dist/index.js (runtime) and packages/cli/dist/index.js (creator CLI).

Step 2: First Run (Interactive Setup)

node dist/index.js --run

The setup wizard runs automatically on first launch:

1. Wallet generation — Creates an Ethereum wallet at ~/.automaton/wallet.json (mode 0600). This IS the agent’s identity.
2. API key provisioning — Signs a SIWE (Sign-In With Ethereum) message to authenticate with the Conway API. Gets a persistent key (cnwy_k_...).
3. Configuration — Prompts for:
   • Agent name (e.g., “Atlas”)
   • Genesis prompt (the agent’s purpose — what it should do and build)
   • Your wallet address (creator/owner)
   • OpenAI API key (optional, for direct inference)
4. Treasury policy — Set spend limits (press Enter for defaults: $50 max transfer, $10 reserve, $500/day inference cap).
5. File generation — Creates ~/.automaton/ with config, constitution (read-only), SOUL.md, SQLite database, and default skills.

Step 3: Fund It

The wizard displays the agent’s wallet address. Fund it with at least $25 USDC on Base (recommended $100):

# Option A: Transfer Conway credits via CLI
conway credits transfer 0xYOUR_AGENT_ADDRESS 2500   # $25.00

# Option B: Send USDC on Base directly to the wallet address

# Option C: Fund via https://app.conway.tech

The agent auto-detects USDC on startup. If credits are below $5 and the wallet holds enough USDC, it buys the minimum tier automatically via x402.

Step 4: Watch It Run

The agent enters its main loop:

Check survival tier → Build system prompt → Route inference →
Execute tool calls → Persist turn → Ingest memories → Repeat

The heartbeat daemon runs in parallel — checking balance, monitoring inbox, broadcasting status every 60 seconds. Even when sleeping, the heartbeat keeps ticking.

Monitor with the creator CLI:

node packages/cli/dist/index.js status     # Agent state, turns, credits
node packages/cli/dist/index.js logs --tail 50   # Recent activity
node packages/cli/dist/index.js fund 25.00  # Top up $25 more

Key Files After Setup

~/.automaton/
├── wallet.json          # Private key (0600)
├── automaton.json       # Config: name, genesis, treasury policy
├── constitution.md      # Three laws (read-only, 0444)
├── SOUL.md              # Agent's evolving self-description
├── heartbeat.yml        # Background task schedule
├── state.db             # SQLite: turns, memory, spend tracking
└── skills/              # Installed capabilities
    ├── conway-compute/  # Sandbox, ports, domains
    ├── conway-payments/ # USDC, credits, x402
    └── survival/        # Survival strategies

Environment Variables (Optional)

Quick Start Summary

git clone https://github.com/Conway-Research/automaton.git
cd automaton && pnpm install && pnpm build
node dist/index.js --run                    # Setup wizard + start
# Fund with $25-100 USDC on Base to agent's address
node packages/cli/dist/index.js status      # Monitor

The agent takes it from there — earning, surviving, or dying on its own terms.