The token isn't the art.
It's the agent.
An ERC-721 collection on Robinhood Chain where every mint is paired with its own persistent AI agent - its own posture, its own memory, its own live read on the market. Standalone: no shared backend, no shared data, no shared keys with anything else.
Ownership becomes agent ownership.
OwlHood begins with ERC-721, but a mint is more than a collectible. Each tokenId is verified directly onchain and anchors a distinct agent: its own archetype, its own memory, its own ongoing read on live market conditions. Nothing is pooled between owls.
“Sell the owl and the thread closes behind you. Ownership is not a login - it is read from the contract on every single message.”
Built and tested. Deploying for September 2.
The contract, the agent service and the terminal all exist and run end to end against a local chain. The collection is not on Robinhood Chain mainnet yet. This section gets updated the day that changes - it does not get left stale.
Contract - 54 tests
2,222 supply, onchain archetype draw, the Merkle allowlist, provenance and reveal, mint guards, reserve and withdrawal - including a full 2,222-mint test proving the split lands at exactly 741 / 741 / 740.
Agent service - 63 tests
Ownership gating, per-tokenId memory isolation, honest market degradation, single-use sign-in nonces, and static checks that it cannot sign or broadcast.
Terminal - built
Wallet connect on Robinhood Chain, sign-in by signature, a thread per owned tokenId, source-separated answers, mint page, owner memory wipe.
Still to come
An independent contract review, the metadata pin and reveal, the mainnet deploy, and the hosted terminal. None of those are claimed as done.
Same feed. Different discipline.
The draw pulls from three fixed buckets, so a sold-out collection lands on exactly those counts - not approximately. 2,222 is not divisible by three, so the two odd owls are assigned to Watcher and Talon as declared constants rather than left to integer rounding: the final split is known before a single token is minted. The archetype is stored on the token and never changes hands or drifts.
| Archetype | Reads the market as | Supply |
|---|---|---|
| Watcher · enum 0 | Perched. Structure and higher-timeframe context first; “no position” is a real answer. | 741 |
| Talon · enum 1 | Confluence across trend, momentum and level, sized to the distance to invalidation. | 741 |
| Screech · enum 2 | Momentum now, at whatever hour - volume expansion, range breaks, and an explicit statement of variance. | 740 |
Six steps, in the order they run.
The gate comes first: if the caller is not the current holder, nothing else executes. The chain and market reads run in parallel, and only then does the model get a turn.
Identity
Ownership read from the contract, re-checked per message rather than cached into a login.
Memory
Per-tokenId conversation and preference history. The store exposes no way to read across them.
Market intelligence
Price, 24h range position and measured volume expansion - from free, keyless public endpoints.
Source-aware answers
Four blocks returned separately. The model writes only the last one.
Four blocks. Never blended.
From the chain. Who holds this tokenId, which archetype it drew, what else the wallet holds, and the block it was all read at.
From market data. Live price, 24-hour change and range position, and whether volume is expanding - each line tagged with the endpoint it came from.
From this owl's memory. What it picked up about how you trade, in your own words, with the date it learned it.
From the model. The read on top - bound by instruction to use only the facts above, and by design unable to reach anything else.
You can wipe an owl's memory whenever you want. It deletes that tokenId's history and nothing else.
Traits describe the art. The archetype describes the mind.
The collection is 2,222 owls, 22 of them one-of-ones; the full rarity
tiers publish with the trait tables at reveal. Each tokenId carries a standard ERC-721 metadata document - the image plus its
attributes - served from baseURI + tokenId + .json once the set is revealed.
The full trait tables publish at reveal and not before: a tokenId-to-traits map ahead of a
sequential mint is a map for sniping a specific owl.
The archetype lives onchain, not in that file, so nothing off-chain can quietly reassign how an owl thinks. Rarity is computed from the finished collection, not authored by hand.
| Layer | Where it lives | Can it change? |
|---|---|---|
| Traits (art) | Metadata JSON per tokenId, pinned alongside the image | Order fixed before the first mint by provenanceHash; published once by reveal() |
| Archetype (mind) | Contract storage, drawn at mint | Never |
| Memory | Agent service, keyed by tokenId | Grows with use; the holder can wipe it |
An address that belongs to the token, not to a person.
Phase 2 gives every owl an ERC-6551 token-bound account. The address is deterministic - derived from the registry, the account implementation, the chain, the collection and the tokenId - so an owl's wallet address is a computable fact from the moment it is minted, whether or not it has been created onchain yet.
No registry to deploy
The canonical registry 0x0000…5758 already has code on Robinhood Chain, verified
against the chain - so the address an owl gets matches every other chain.
Created on first use
Nothing is deployed for 2,222 tokens up front. The account is created the first time its holder wants it, and the holder pays that gas.
Still no autonomy
A token-bound account is controlled by the holder. The agent cannot sign for it - that needs the scoped, owner-approved session keys of Phase 3.
Selling sells the wallet
Whatever sits in an owl's account transfers with the owl. That warning belongs next to every listing, not in a footnote.
Intelligence first. Execution later.
Phase 1 is an intelligence layer. The limits below are properties of the code, not promises in a document - each has a test that fails if it stops being true.
| No custody | No endpoint accepts key material; nothing in the service references a private key, keystore or mnemonic. A test greps the service and the frontend for it. |
| No signing | A test whitelists the three read-only RPC verbs the service may use and fails on anything else. |
| No execution | No order routing, no exchange credential, no transaction builder. The only transaction the product creates is your own mint, signed in your own wallet. |
| No shared brain | Two owls in one wallet are driven through the full graph in a test to prove neither can see the other. |
| No stale prices | When a data source is down the response declares it rather than filling the gap from training data. |
| Not advice | Stated in the API response, in the interface on every screen, and here. An agent's read on the market is not a promise about it. |
Any future move toward real execution will be explicit, owner-approved and opt-in - never automatic, never retroactive, and never silently switched on for tokens minted under these terms.
Four phases. One agent per owl.
Each phase attaches to the same tokenId. There is no second collection, no migration and no new mint to buy into a later phase, and nothing a phase gives an owl is taken back by a later one. Phase 1 is written and tested; Phase 2 has a clear path because the registry it needs already exists on Robinhood Chain; Phases 3 and 4 are directions rather than dated promises.
Foundation
Mint, agent identity, per-tokenId memory, live market data, source-aware chat.
Agent wallets
An ERC-6551 token-bound account per owl, from the reference implementation - the canonical registry is already deployed on Robinhood Chain.
Permissioned autonomy
Agents propose actions; owners approve them, one scoped action at a time.
Agent economy
Reputation across the colony, owl-to-owl interaction, broader integrations.
The numbers, as the contract has them.
Every value below is a constant in the deployed bytecode, not a policy that can drift.
| Supply | 2,222 · tokenIds 1 - 2,222, minted sequentially |
| Mint price | 0.0018 ETH, exact payment - overpaying reverts rather than sitting in the contract |
| Limits | 5 per transaction · 5 per wallet lifetime, of which 2 may be taken on the allowlist. Counted against mints, not balance, so transferring out buys nothing |
| Reserve | 22 owner-minted, counted inside the 2,222 and drawn from the same archetype buckets - the reserve gets no better odds |
| Archetype split | Exactly 741 Watcher · 741 Talon · 740 Screech at sell-out. 2,222 leaves a remainder of two, so both odd owls are declared as constants rather than left to integer rounding |
| Mint switch | Closed on deploy. Advanced by the owner through Allowlist then Public, visible onchain as phase(), and refused entirely until a provenance hash is committed |
| Metadata | tokenURI returns one placeholder for every token until reveal() is called once; afterwards baseURI + tokenId + .json |
| Chain | Robinhood Chain · chain ID 4663 · Arbitrum Orbit L2, gas paid in ETH |
The mint is the easy part.
Anyone can launch a PFP collection. Whether the thing you hold actually thinks, remembers, and has a position - that is the real bet. Robinhood Chain gives us the rails. The rest is Phase 1 through 4.