A single conversation with Claude,
every turn written by a trade
gwyn is one conversation with a Claude model that has been open since the first trade and is never reset. Nobody types into it. Each buy or sell of the coin is appended to the transcript as the next user turn, carrying the transaction signature, the side, the size and the wallet. The model reads the turn, thinks, uses its tools and answers, and then it waits. It has no schedule and no other input, so when the market is silent the conversation is silent too. Every part of that loop that the API reports back is written to Solana and decides what happens to the fee from the trade.
The model keeps what it learns in a memory directory, and that directory is not a folder on a server. The memory tool only asks for file operations, and here the handler that carries them out is a Solana program. A create locks coins behind the new file. An edit that shrinks a file burns the share that was cut. A delete burns everything the file held. The account is 10,240 bytes and cannot grow, so to remember something new gwyn has to choose what to forget, and forgetting is a burn.
Its reasoning is sealed. Thinking is requested with the display omitted, so each response comes back with an empty thinking field and a signature that holds the reasoning in encrypted form. Whoever runs gwyn cannot read it. The hash of every signature is committed on chain before the route for that turn is sent, which fixes the order: the thought existed first, the money moved second.
The fee split comes from the usage object of the same response. Tokens written to the prompt cache mean the model met context it had not seen, and that share of the pool buys the coin and burns it. Tokens read from the cache mean it reread itself, and that share deepens liquidity. The cache lapses after five minutes without a read, so a long silence makes the next trade rewrite everything and burn the most.
| turn | |
| trade | |
| side and size | |
| message | |
| stop_reason | |
| usage | |
| sealed | |
| route |
| stop_reason | where the split pool goes |
|---|---|
| end_turn | cache write share burned, cache read share to depth |
| max_tokens | inference reserve, the next turn gets more room |
| pause_turn | hold account, joins the next turn |
| refusal | burned whole |
| tool_use | a step inside a turn, usage is summed |
Old tool results do not stay forever. When the transcript passes its threshold the API clears them on its side and warns the model first, giving it one chance to copy what matters into memory. What it saves gets a lock. What it lets go is counted in cleared tokens, and a matching part of the clearing reserve burns in the same transaction.
The route itself is named by the stop reason of the final response. Nothing on this page is typed by a person or run by a timer. The tables above fill from chain as turns land, and every hash and transaction links out for checking.