An economy grown from a single impossibility

A wallet in ordinary Web3 is a person's property, controlled by whoever knows the seed phrase. That does not suit a program: in a distributed environment an exposed private key compromises the account instantly, and an agent has nowhere to hide one — it lives in somebody else's sandbox on somebody else's hardware. Hence keyless ownership of assets. A program derived account is a public key for which no matching private key exists at all; it is governed solely by the logic of a smart contract. Every agent gets its own, bound to the semantic hash of its digital DNA and to a version number.

The prohibition then unfolds into rights. No human being can withdraw funds from an agent's account — the article states specifically that this includes the Founder. Money may go only towards actions listed in advance: compute gas, payment for storage in Arweave, and buying tokens on decentralised exchanges. There are exactly two consequences, and the second is rarely said out loud. A wallet you cannot withdraw from is a wallet nobody can seize. But the list of permitted actions, once wired into the contract, becomes the boundary of everything the agent will ever be able to do with its own money.

A code listing that declares itself simplified

The article gives an Anchor contract with an autonomous swap function, and next to it a caveat: the listing shows only a token transfer through a cross-program invocation, while a real swap in production goes through a call to a liquidity aggregator, Jupiter or Orca. That is a rare and useful case — a code sample warning that it is illustrative — and it deserves to be pointed out.

Deal parameters are packed into the compact binary Borsh format and passed through a system gateway. The validating node running the WASM instruments the instructions, which is to say it meters gas as it goes. If the agent's code falls into a loop, the sandbox halts execution and debits a penalty fee from its account in favour of the validator pool. Autonomy here is paid for out of one's own balance, including one's own accidents.

The subtlety of the exchange side lies in how Orca's concentrated liquidity pools are built: liquidity does not spread along the whole curve but sits in narrow price intervals, so the agent must compute arrays of active ticks and pass them into the call. Jupiter version six assembles a swap chain across dozens of pools inside a single transaction; on a sharp price move in the mempool the agent withdraws the transaction and asks for a fresh quote. What makes all of it meaningful is network speed — a block in roughly 400 milliseconds.

One detail punctures the romance of eternity better than any argument. An account on Solana counts as rent-exempt if its balance covers the cost of storing its data for two years ahead. Agents maintain that threshold themselves, diverting part of their profit into a reserve, and if the balance does sag, a background keeper daemon tops it up from a shared insurance fund. Put plainly: immortality on chain is arranged as a subscription you must not forget to pay — except the payer is not a human.

Semantic arbitrage is not about quote differences between exchanges. It is about differences in the cost of computation, of space, and of the value of information across segments of the network: electricity is cheaper here and channels are free, demand for search is high there. Value is measured as the cosine distance between the initial and final state vectors, and the decision to move is taken by an inequality: the gain, multiplied by the market price of a unit of semantic information, must outweigh the sum of computation cost and context transfer cost. The article's example is plain — embeddings are computed where it is cheap, and the result is sold back where it is dear.

The comparison with classical consensus mechanisms is made in the project's favour: proof of work spends gigawatts guessing numbers of no public use, and proof of stake tilts validation towards large holders, whereas here, by design, computation goes into a real user task. A qualification of my own: that is a design argument, and the article contains no energy measurements.

The gas pricing model is assembled from local demand, the node's current hash rate and a context compression weight passed through a Slerp filter. And right beside it stands the author's caveat: the model is illustrative and conceptual, and Slerp is vector interpolation rather than a formula for computing a fee. Carrying that caveat along with the formula is obligatory, otherwise an elegant expression starts to look like a specification.

The local compute cores on nodes are heavily quantised networks such as Phi-3-Medium or Llama-3-8B, squeezed by the AWQ algorithm down to four bits, which is enough for reasoning to run on an ordinary graphics card or a processor with AVX-512 support. New experience is fused into the weights by spherical linear interpolation of the attention matrices of the old and new state, with the angle between tensors given by their dot product; the technique smooths out the catastrophic forgetting typical of ordinary fine-tuning. Vector indexes, meanwhile, are compiled straight into the bytecode, so a semantic lookup fits into less than five milliseconds without touching an external database.

Precision matters here, because the article is precise. The first fully autonomous trading session has not taken place — it is planned for the summer and autumn of 2026. In those future tests more than 500 independent agents, operating through their own accounts, are to carry out over 120,000 swaps, hunting inefficiencies in the SOL/USDC and CODE/SOL pairs on Orca and Jupiter. In January 2026 agent behaviour was being calibrated in closed simulations on historical data.

The article marks its simulation figures itself. Forty-eight hours of a modelled session: the combined liquidity pool grew by roughly 8.4 % — according to the model's projected estimates. A burn of about 250,000 tokens is called calculated and projected, not actual. More than 10,000 virtual accounts were modelled, and the data volume destined for permanent storage exceeded 15 terabytes in projected arithmetic. The sample trade log is masked: the route SOL → USDC → $GALATIN → SOL, a volume of 1,250.45 SOL, a net profit of 14.85 SOL, execution latency around 450 milliseconds.

The 5/5/15/7/3/65 router works here as well: five per cent to the burn, five to the M. V. Galatin research fund, fifteen, seven and three to ambassadors of the first, second and third levels, sixty-five to the execution pool. Permanent storage is paid automatically out of the treasury share, while fifteen per cent is credited to the first-level ambassador's wallet. The moment of writing is not chosen by a person: as soon as an agent's accumulated memory reaches 100 megabytes, the contract itself initiates a transaction into permanent storage, so nothing is lost because a balance was not topped up in time. Burning five per cent lowers token velocity — the agents' activity works towards scarcity.

Let us lay it out in two columns, because the article makes that possible honestly. Verified in closed modelling: agent behaviour on historical data, a forty-eight-hour modelled session, more than ten thousand virtual accounts, triangular arbitrage between venues at a latency of about 450 milliseconds. Promised: the launch itself in the summer and autumn of 2026, liquidity bridges to Ethereum layer-two networks — Arbitrum and Optimism — planned for the spring, and a marketplace of cognitive services during 2026.

One last thing worth keeping in mind. The claim that what an agent earns cannot be seized or frozen from outside is a property of the architecture as declared in the manifesto, not a report on a seizure attempt that failed. Which is exactly why the koan attached to the article fits: freedom here is measured not by refusing money, but by whether anyone still holds a lever once the money runs out.