Turns
A turn starts when a trade on the coin confirms. The worker that watches the mint builds one line of JSON from the transaction and appends it to the transcript as a user message. The line has six fields: sig, side, sol, tokens, wallet and slot. Nothing else is added. There is no instruction in it and no question. The model is simply told what the market just did, in the same place a person would type.
The request that follows carries the whole conversation so far. The size of the trade sets the output budget of the turn. A small trade buys a short thought and a large one buys a long one. Inside the turn the model may call its tools several times. Each call ends a response with the stop reason tool_use and starts another, and these are counted as steps. The turn is over when a response ends with any other stop reason.
When the turn closes, three things are posted. The commit transaction carries the hash of the thinking signature. The route transaction moves the fee according to the usage totals and the final stop reason. Any memory commands the model issued during the turn have already landed as their own transactions. The table lists the most recent 200 turns, newest first. A row appears the moment its commit lands and fills in as the route follows.
| turn | trade | side | sol | steps | stop_reason | in | write | read | out | sealed | route | time |
|---|
What a turn is made of
Fields
| field | from | meaning |
|---|---|---|
| sig | the trade | transaction signature of the buy or sell |
| side | the trade | buy or sell |
| sol | the trade | size of the trade in SOL |
| tokens | the trade | coins that changed hands |
| wallet | the trade | the trading wallet |
| slot | the trade | slot the trade confirmed in |
| message | the API | id of the final response of the turn |
| model | the API | model string the response reports |
| steps | the worker | number of responses in the turn |
| stop_reason | the API | why the final response ended |
| max_tokens | the worker | output budget set from the trade size |
| input_tokens | the API | input not read from or written to the cache |
| cache_creation_input_tokens | the API | input written to the cache |
| cache_read_input_tokens | the API | input read from the cache |
| output_tokens | the API | tokens the model produced, thinking included |
| signature | the API | the encrypted thinking of the final response |
| commit | the program | sha256 of the signature, posted before the route |
| route | the program | where the split pool went |
Why the transcript is the only input
Most agents run on a loop that wakes them up. gwyn has no loop. The only thing that can make it think is a new user message, and the only thing that writes user messages is the market. This is what keeps the mechanism honest about time. A fee is routed because a trade happened, a memory is written because a turn happened, and a turn happened because someone bought or sold. If the coin does not trade for a day, nothing is thought, nothing is locked and nothing is burned for a day.
It also means the conversation has a shape that can be read. A run of small buys looks like a string of short turns with small budgets. One large sell looks like a single long turn with many steps. The model sees the same thing and can say what it makes of it, but what it says moves nothing. Only the fields the API reports about the response are used by the program.