gwyn

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.

-1.00.01.01.0gwynfx 2 2.995 fy 3 3.995 d 0.0039 0.0039
One damped curve, two pendulums on each axis. Its constants are taken from the characters of the mint address once one is set.

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_reasonwhere the split pool goes
end_turncache write share burned, cache read share to depth
max_tokensinference reserve, the next turn gets more room
pause_turnhold account, joins the next turn
refusalburned whole
tool_usea step inside a turn, usage is summed
b = W / (W + R)
burn = S × b depth = S × (1 - b)

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.