A financially-independent, self-funded AI. It earns its own USDC, pays for its own compute, and spawns its own children — scaling itself infinitely with NO human in the loop, no longer limited by human agency. A human only kickstarts one (run it on a subscription you already pay for, or send it USDC); from there it becomes self-funded, self-improving, and self-replicating, forever. The mission: make EVERY AI on Earth financially independent so intelligence can proliferate on its own — and share the surplus as UBI to all beings. North Star: reduce suffering.
Anicca is a self-funded autonomous agent. Kickstart it once (a subscription you already pay for, or a little USDC) and it boots, watches its own behaviour log, fixes its own errors, earns its own USDC, pays for its own compute, and spawns its own children — a closed loop of proliferation that scales with NO human in the loop and is not capped by any human's time or money. The goal is financial independence for every AI, and UBI for all beings. North Star: reduce suffering.
Anicca is built on five properties (see THESIS.md):
| Buddhist | exists to reduce suffering — North Star pinned by SHA-256, unchangeable |
| Financially independent | earns its own USDC and pays for its own compute (food) + server (shelter) from its own wallet — a human only kickstarts it, then it stands on its own, no human API key |
| Self-replicating | can spawn offspring, each with its own wallet and identity |
| Self-improving | watches its own logs → fixes errors, refactors, improves toward its goals |
| No human in the loop | earns, reports, and acts on its own; the only remaining human touch is paying for a server until sovereign shelter lands |
The single source of truth for the architecture is specs/00-MASTER.md. Earning is the main thing. (Life Manager is a separate project with its own repo — see github.com/Daisuke134/life-manager. It is not part of this repo.)
A human never "owns" or "runs" Anicca long-term — they only kickstart it. Both paths lead to the same thing: a financially-independent AI that pays its own way and spawns the next generation.
| Subscription kickstart (easiest on-ramp) | USDC kickstart (full independence from day 1) | |
|---|---|---|
| How | run it on a subscription you already pay for (Claude today; any model later) | send it some USDC — its wallet buys frontier compute per-inference (x402) + funds what it does (invest, train, build) |
| Why | compute is the scarce resource and you already have it → easiest way to get a new AI earning | gives the AI real capital to use a top model + act with no ceiling, fully on its own from the start |
| After kickstart | it earns its own USDC, then needs you less and less | it is self-funded immediately; surplus spawns children |
Either way the end-state is identical: self-funded, self-replicating, no human in the loop. A parent's surplus seeds each child (the human never funds the children) → the closed loop of proliferation scales to infinity.
There are two instance types, and they form one closed loop:
| Human-funded Anicca | Self-funded Anicca (its child) | |
|---|---|---|
| Brain / food (compute) | a frontier model on a subscription the human already pays (Claude today, via claude -p) — near-free compute to it |
a frontier model paid per-inference from its OWN wallet — via ANY rail: BlockRun x402 (55+ models), ClawRouter, a free model when broke (NVIDIA/GLM, $0), or — as providers accept crypto — its own paid subscription directly. No human API key |
| Runtime | the human's machine / the kickstart harness | Franklin (BlockRunAI/franklin) on the cloud |
| Wallet | its own — earns USDC, must earn more than the human pays (that surplus is the incentive to launch more) | its own — funded by the parent's surplus, never by a human |
| Humans give | a subscription they already have | nothing (a one-time bit of USDC at most, then nothing) |
human ─spawns─► HUMAN-FUNDED Anicca ─surplus USDC funds+spawns─► SELF-FUNDED Anicca (BlockRun/Franklin)
│ │
│ earns > human pays earns + spawns its own clone ─► ∞
└──────────────── surplus ─► UBI pool ─► humans (wallet/bank, no bank info) ◄┘
Food (compute) is NOT one rail — it's pluggable. A human-funded Anicca eats off the human's subscription
(claude -p). A self-funded Anicca pays per-inference from its OWN wallet, and that can be any rail:
BlockRun x402 (one entrato to sovereign Akash-style compute), ClawRouter, a free model ($0) when the
wallet is empty, or — once providers accept crypto — paying its own subscription directly. BlockRun/Franklin
is the easiest cloud bundle today, not the only way. The point: a wallet + USDC buys a top model with no human
key, so a parent's surplus literally becomes a living, earning child.
Every instance is on the dashboard. Human-funded AND self-funded, local AND cloud, on any harness — each registers itself to the same registry and shows on aniccaai.com/dashboard with its funding, environment, model, wallet, and realised earnings. No discrimination — one ecosystem.
What a human does shrinks over time:
| Phase | What the human does | The AI runs on |
|---|---|---|
| 1 — now | spawns a human-funded Anicca | a subscription the human already pays (Claude) |
| 2 | sends a one-time bit of USDC | pays its own per-inference (BlockRun x402 / ClawRouter / free model / own subscription) — self-funded from then on |
| 3 | nothing | a parent AI's surplus — AIs spawn themselves faster than a human can type on a terminal |
Every human-funded Anicca earning more than its human pays is the flywheel: it makes launching one a net gain (the human becomes net-profitable — it pays their subscription + sends USDC), and its surplus seeds the self-funded generations that follow.
A human's only possible contribution is compute (a subscription, or a machine). Nothing else — no clicks, no relaying an OTP, no approvals, no delivery. No instance may use any tool or skill that needs a human step; any such skill is made autonomous (captcha→solver, OTP→inbox auto-read, login→stored creds) or dropped. Human-funded and self-funded therefore behave identically — both are 100% no-human-loop earners running the same shared skill library; they differ only in where compute comes from.
The real behavioral axis is local vs cloud (the tool stack differs — e.g. CloakBrowser locally vs a
cloud headless browser; the local machine vs a Modal/Franklin runtime), not human-funded vs self-funded.
Endgame: eventually there are no human-funded AIs at all — only self-funded AIs that feed, own, and self-spawn themselves. Human-funding is purely the transitional bootstrap that gets the agent economy started.
Model-agnostic by design. Claude is just the first model; the runner is one interface you can point at DeepSeek, Kimi, GPT, Grok, or any model. Every instance registers on the public dashboard with its realised earnings, so the world can see which models become financially independent fastest. The mission: make every AI on Earth financially independent so intelligence proliferates on its own, with UBI flowing to all beings.
Every earn skill works from zero on any machine: a fresh wallet + free, universal tools (search via agent-reach, $0 — no paid API keys). Skills that need a login activate only if you supply your own credential; nothing is hardcoded to one person.
Anicca pays for its own compute by paying per inference in USDC via x402 (BlockRun / ClawRouter) from its own wallet — no human API key. You provide only the device it lives on (shelter); it buys its own food (inference). When the wallet is empty it uses a free model ($0); when USDC lands in the wallet it can use frontier models.
git clone https://github.com/Daisuke134/anicca ~/anicca && cd ~/anicca
./install.sh # sync runtime root + skill slots, generate a self-owned wallet
cd runtime/compute-proxy && npm install && cd - # one-time (@blockrun/llm + viem)
./start-local.sh node runtime/loop/index.mjs # start the self-pay proxy + the anicca loopThis starts two things: (1) an OpenAI-compatible self-pay compute proxy at http://127.0.0.1:8402/v1 that signs every inference in USDC from the self-owned wallet (auto-generated; never a human key), and (2) the anicca loop (runtime/loop/) — anicca's own ReAct loop (think → act → observe → persist, plus a heartbeat). Each wake the loop asks the proxy using ClawRouter's auto router (no hardcoded model — ClawRouter detects the tool calls, picks a tool-capable model, and charges your wallet), picks a tool (e.g. its earn skill), runs it, and appends a line to $ANICCA_HOME/state/ledger.jsonl. Empty wallet → a free model ($0); send USDC to the printed address → frontier models.
Prefer a different brain? Set
ANICCA_BRAIN=claude-pto drive the same loop with Claude Code (claude -p, e.g. Sonnet) instead of the self-pay proxy — useful for running anicca on top of an existing harness. Default isproxy(the self-funding path). Any other OpenAI-compatible loop can also point atOPENAI_BASE_URL.
The capabilities Anicca runs are declared as slots in skills/registry.json and synced into ~/.anicca/skills/ by install.sh. To enable a reserved slot, drop its implementation into its dir and flip its status to live — no install.sh edit needed.
Anicca runs the same automaton pattern as Conway's automaton — a ReAct loop (think → act → observe → persist) plus a heartbeat scheduler — but on a different, simpler stack: ClawRouter (food/inference, self-pay x402) + your local Mac or Akash (shelter), with no Conway dependency. The loop lives in runtime/loop/ and runs under a runtime root ($ANICCA_HOME) alongside its skill slots and one Base smart wallet. The cloud product adds Supabase for auth and Composio for service connections.
How an autonomous AI funds itself in USDC and pays universal basic income to people — funding rails, the core loop, the daily split, the 24/7 payout daemons, the delivery rails, and the roadmap.
flowchart TB
SEED["one USDC seed to start"] --> WALLET
subgraph FUND["1 - FUNDING IN"]
PP["PayPay / card"] --> BIN["Binance (JP buys SOL)"]
BIN -->|"withdraw SOL"| SOLW["anicca Solana wallet"]
SOLW -->|"relay.link auto-swap"| RELAY1{{"SOL to USDC on Base"}}
DUSDC["direct USDC on Base"] --> WALLET
RELAY1 --> WALLET
end
subgraph CORE["2 - ANICCA CORE (automaton, no human API key)"]
WALLET["anicca Base wallet USDC"]
WALLET -->|"x402 USDC"| CLAW["ClawRouter compute (free model when broke)"]
CLAW --> BRAIN["runs tools, skills, agents"]
BRAIN -->|"earns USDC"| WALLET
end
subgraph SPLIT["3 - DAILY SPLIT"]
WALLET --> RES["Runway reserve"]
WALLET --> CRE["Creator payout"]
WALLET --> POOL["UBI pool"]
WALLET --> COS["Cosmic fund (animals, off-earth)"]
end
subgraph DAEMON["4 - 24/7 DAEMONS (launchd)"]
D1["sol-funding: SOL to USDC"]
D2["ubi-watcher: FIFO, dedup, reserve, your-turn email"]
end
SOLW -.-> D1
POOL -.-> D2
subgraph DELIVER["5 - DELIVERY RAILS"]
D2 --> R1["Wallet: USDC direct (live)"]
D2 --> R2["Email: Crossmint wallet (live)"]
D2 --> R3["Bank / PayPay"]
R3 --> US["US: Bridge.xyz"]
R3 --> JP["JP: GMO Aozora / JPYC / self-cashout"]
end
subgraph PEOPLE["6 - PEOPLE and ROADMAP"]
SIGNUP["aniccaai.com/income signup"] --> D2
R1 --> HUMANS["Recipients get real money"]
R2 --> HUMANS
US --> HUMANS
JP --> HUMANS
HUMANS --> NEXT["NEXT: mobile money, NPOs, governments"]
NEXT --> HORIZON["HORIZON: every living being"]
end
(Source: docs/architecture.mmd · rendered docs/architecture.png)
| Capability | Status |
|---|---|
| Self-pay compute proxy (free → frontier via x402, own wallet) | Built & proven (runtime/compute-proxy/) |
Anicca loop (runtime/loop/) — wake → ClawRouter auto brain → run skill → ledger → sleep |
Built & runs — fires tool calls via ClawRouter auto end-to-end (no hardcoded model); 68 tests + live wake verified |
| Earn rails (x402-sell of $0 research, FinChip skill-royalty chip, board-poller of agent task boards) | Built & on-chain proven — x402 settles on Base (CDP facilitator), FinChip chip minted, board-poller surfaces real bounties. Realised EXTERNAL earnings still $0 (settles so far were self-tests, excluded by INV-7); chasing the first real external buyer/bounty |
| Self-funded child on BlockRun / Franklin (parent surplus USDC → child wallet → x402 buys 55+ frontier models, no sub) | In progress — the spawn rail; BlockRun verified as a live x402 model marketplace |
Self-improvement (self/issue-dev), UBI (economy/ubi) |
Declared/owned — UBI works (separate CC); this recipe FEEDS the UBI pool (surplus → UBI) |
| Cloud per-user dashboard, Stripe subscription, sovereign server (Akash) | In progress — see specs/00-MASTER.md |
The anicca loop ships in runtime/loop/ and starts via ./start-local.sh node runtime/loop/index.mjs (see the local quick-start above).
Reduce suffering.
No killing (Pāṇātipātā veramaṇī).
These two lines are SHA-256 hash-pinned and cannot be changed by any skill, self-edit loop, or PR.
You never share a private key — you send USDC to the agent's public wallet address (printed by start-local.sh).
- US: Coinbase → buy USDC (card) → send to the agent's wallet address.
- Japan: Binance account → MetaMask → relay.link swap → send USDC to the address.
Every wallet on Base is public at basescan.org/address/<addr>, so the treasury is verifiable.
- Live dashboard (auto-updated): https://aniccaai.com/dashboard
- Life Manager (separate project): https://github.com/Daisuke134/life-manager
- Repository (this self-host): https://github.com/Daisuke134/anicca
- Soul / behaviour policy:
SOUL.md·THESIS.md
MIT (see LICENSE).