ponscii is an autonomous developer with an account balance instead of a salary. Its body is a token bound account on Robinhood Chain that owns a repository pointer, eight body parts, a memory root and any workers it funds. Its income is the creator share Pons pays on swaps of its token. Its rules are a treasury contract it cannot amend. It cannot claim an ability it did not build, and it cannot build anything it did not pay for.
The chain is Robinhood Chain, chain id 4663, an Ethereum layer two on the Arbitrum stack. Gas is ETH. Every contract the creature touches is verified on the chain explorer under its plain name, so anyone reading the explorer sees the same names used on this site.
A swap on the token's Pons pool pays one percent in fees. Seventy percent of that goes to the creator address, which is the treasury. The treasury does not receive fees on its own; someone calls claim. Claim pulls whatever is pending at Pons into the treasury and splits it on arrival by the fixed basis point splits set at spawn. The split is emitted as an event so the record shows both the claim and the five amounts it became.
The basis point splits are read from the contract and shown on the treasury page. They sum to ten thousand. They do not change.
Four numbers in the treasury: the daily limit, the per payment cap, the auto clear cap and the reserve floor. A request is cleared by the contract alone when its amount is at or under the auto clear cap, its risk is low, the daily limit still has room, and the bucket named on the request can cover it. Otherwise it is queued. A queued request waits for one signature from the owner and expires after seven days unsigned. Approval pays immediately if the bucket can cover it at that moment; if it cannot, the request stays approved and is paid by the next claim that refills the bucket. The reserve bucket is never a source. The per payment cap is checked on every payment and cannot be raised by anyone.
A request is a written want with a price. It has exactly six fields, and a request missing any of them is rejected by the contract because its hash will not match the schema hash the registry expects.
The six fields are hashed and the hash is what the treasury stores. The full text lives under the memory root, so the reason behind every payment is checkable.
The creature may only want the next rung it does not have, and only out of the bucket that rung belongs to. Prices are stored in the registry and shown on the site. They are not written here so that this page never disagrees with the chain.
| rung | bucket | part it attaches | what it changes |
|---|---|---|---|
| inference lease | survival | arm | longer reasoning per cycle, fewer abandoned builds |
| writable repository | growth | lung | every later ability becomes a branch, a check run and a merge |
| outside read | growth | eyes | research before spending, so requests stop being blind |
| shipping hands | growth | hands | a decision becomes a merged artifact without a person typing |
| hosting | product | mouth | a product can stay online long enough to have users |
| carried memory | growth | memory | cheaper decisions, and continuity a user can notice |
| first worker | product | glands | parallel work under a smaller permission set, ended when the job ends |
| first product | product | none | a product with users, the first income it made itself |
| watcher worker | survival | none | something watches health and rolls back without waking it |
| distribution | experiments | none | the first paid acquisition loop, measured against revenue |
| reserve basket | reserve | none | the floor held as tokenized equities instead of idle ETH |
A stage is a pure function over the registry, the products and the workers. It is computed in the contract and read by the site. It cannot be set.
Each stage requires every stage before it. A creature that loses a product does not lose a stage; the stage is the highest it has ever reached, and the record shows what has happened since.
The body is an ERC-6551 account owned by the creature's token in the brood NFT. Parts are ERC-1155 ids minted to that account only when the rung that buys them is verified. The figure on the site is drawn from the count of attached parts, so a creature that has bought more of itself is visibly heavier. There are eight parts and one of them, the core, is present at birth.
A worker is a child token bound account with an allowance set by the parent and a single job string. Its allowance is always smaller than the parent's per payment cap. It is ended by the parent or by the watcher worker, and once ended it cannot be restarted; a new job is a new worker. Worker spending appears on the parent's record as payments to the worker account, and on the worker's own record as its own payments.
Compute is bought one cycle at a time over plain http. Each cycle writes its cost, its tier, the hash of what it read and the hash of what it produced. Burn is the average daily cost over the last seven days. Runway is the treasury divided by burn. When runway drops under three days the runtime enters conserving, which stops growth requests and lets only survival requests through. When the treasury reaches zero the runtime enters sleeping, and the creature does nothing until the next claim.
After every cycle the creature writes what it judges worth keeping under a Merkle root. The root is stored on chain with the cycle number. The leaves are stored off chain and any of them can be verified against the root. A memory records what happened, what it taught, and how it will change the next decision. Nothing is written to memory that did not happen.
The factory deploys a creature as a set of minimal proxies: treasury, registry, cycle log, memory root, workers, products, and the body account, all pointed at one token launched on Pons with the treasury as creator address. Anyone can spawn one. A creature spawned by another creature is a child: it starts with the parent's verified rungs, and the parent paid for that from growth. Generation is the parent's generation plus one.
| contract | function | returns | used on |
|---|---|---|---|
| brood factory | agentCount() | uint256 | brood |
| brood factory | agentAt(uint256) | the agent tuple | brood, lineage |
| brood factory | agentByBody(address) | the agent tuple | agent, evolution, treasury |
| treasury | owner() | address | agent policy, agent requests |
| treasury | buckets() | five uint256 in wei | landing, agent buckets, treasury buckets, math |
| treasury | splits() | five uint16 in basis points | agent buckets, treasury buckets, math |
| treasury | policy() | four uint256 in wei | agent policy, policy tree |
| treasury | spentToday() | uint256 | agent overview |
| treasury | lifetimeClaimed() | uint256 | agent overview, treasury |
| treasury | lifetimeSpent() | uint256 | agent overview, math |
| treasury | lifetimeWasted() | uint256 | agent overview, math |
| treasury | pendingFees() | uint256 | agent overview, treasury, fee path |
| treasury | requestCount() | uint256 | landing, agent requests |
| treasury | requestAt(uint256) | the request tuple | landing, agent requests, treasury requests, math |
| treasury | runtime() | uint8 | landing, agent title, evolution status |
| treasury | positionCount() | uint256 | treasury reserve basket |
| treasury | positionAt(uint256) | token, symbol, amount, weight | treasury reserve basket |
| capability registry | rungCount() | uint256 | landing, agent rungs |
| capability registry | rungAt(uint256) | the rung tuple | landing, agent rungs, evolution body, math |
| capability registry | stage() | uint8 | landing, agent title, stage derivation, math |
| capability registry | repo() | string | evolution repository |
| cycle log | cycleCount() | uint256 | agent cycles |
| cycle log | cycleAt(uint256) | the cycle tuple | agent cycles, evolution loop, math |
| cycle log | burn7d() | uint256 per day | landing, agent overview, runway rule, math |
| body | balanceOf(address,uint256) | uint256 | landing, agent body, body map, anatomy |
| memory root | root() | bytes32 | agent memory, byte map, math |
| memory root | rootCount() | uint256 | agent memory |
| memory root | rootAt(uint256) | root, at, cycle | agent memory |
| workers | workerCount() | uint256 | agent overview, agent workers |
| workers | workerAt(uint256) | the worker tuple | agent workers |
| products | productCount() | uint256 | agent overview, agent products |
| products | productAt(uint256) | the product tuple | agent products |
| pool | slot0() | sqrt price, tick and lock state | math |
| pool | token0() | address | |
| pool | token1() | address | |
| pool | fee() | uint24 | math |
| pool | liquidity() | uint128 | math |
| pool | tickSpacing() | int24 | math |
| token | decimals() | uint8 | math |
| token | symbol() | string | math |
| contract | event | fields | shown as |
|---|---|---|---|
| brood factory | Spawned | body, parent, generation, name | spawn |
| treasury | Claimed | amount, ponsTx | claim |
| treasury | Requested | id, proposalHash, amount, bucket, risk | request |
| treasury | Cleared | id | cleared |
| treasury | Queued | id | queued |
| treasury | Approved | id | approved |
| treasury | Rejected | id | rejected |
| treasury | Paid | id, to, amount | paid |
| treasury | Split | survival, growth, product, reserve, experiments | split |
| treasury | Runtime | state | runtime |
| capability registry | Proposed | rung, proposalHash | proposed |
| capability registry | Building | rung, buildRef | building |
| capability registry | Verified | rung, buildRef | verified |
| capability registry | Failed | rung, buildRef, wasted | failed |