every line on the tape is one instruction a dot sent to solana, with its amount and the note its agent left. nothing appears until a trade wakes a dot.
| kind | what happened |
|---|---|
| spawn | a trade landed with 0.05 sol free in the well, so the program made a new dot and gave it that sol as its charge |
| place | the first trade after a dot spawned set its home at the current price less its gap. it is now a resting bid |
| walk | a buy lifted the price and left the dot further down than its gap. it moved its home up by its stride |
| fire | a sell brought the price to a dot's home. the dot bought the coin with half its charge, inside a 2% impact cap |
| relay | just before buying, the firing dot handed part of its charge to the nearest dot resting below it |
| burn | the dot destroyed its split of the tokens it had just bought |
| pair | the dot matched the rest of its tokens with sol and added both to the pool. the shares stay in its account |
| refill | sol left after pairing went back to the well and counts toward the next dot |
relay, then buy, then burn, then pair, then refill. all of it settles in the same transaction as the fire, so a dot is never half done.
the openai dot running a dot can attach up to 120 characters to what it sends. the note is stored on chain with the event and printed here as written.
the coin's value in dollars, read from birdeye once a second. it is the only thing on this page that does not come from the program.
| when | the dots |
|---|---|
| a buy lifts the price | trailing dots walk up behind it by their stride |
| price climbs fast | slow dots fall behind and end up deeper than their gap |
| a sell reaches a dot's home | that dot fires: relay, buy, burn, pair |
| a sell keeps going | it meets the next dot down, now heavier from the relay |
| nobody trades | nothing happens. there is no timer anywhere |
spawned is every dot ever made. seeded, trailing, fired and pooled are where those dots are now and always add up to spawned. pool share held is the part of the coin's pool that sits in dot accounts and cannot be withdrawn.
| dot | state | gap | stride | split | relay | charge | under price | walks | doing now |
|---|
every dot gets four traits from the hash of the trade that spawned it. nobody picks them and they never change.
| trait | range | what it does |
|---|---|---|
| gap | 3% to 30% | how far under price the dot rests |
| stride | 20% to 80% | how much of the lost distance it closes on each walk |
| split | 10% to 50% | how much of what it buys gets burned |
| relay | 0% to 20% | how much charge it hands down before buying |
a dot with a 4% gap sits close and fires on small dips. a dot with a 28% gap waits for a real fall. because gaps are spread by chance, there is a dot at nearly every depth.
when a buy lifts the price the dot is left behind. stride is how fast it catches up. a high stride keeps the bid tight. a low stride lags and becomes a deep bid without meaning to.
when a dot fires, its split of the tokens it bought is burned. the rest goes into the pool. a high split dot shrinks supply. a low split dot deepens the pool.
before it buys, a firing dot passes its relay share to the dot below. the further a fall goes, the heavier the dots it meets.
| state | where in the field | meaning |
|---|---|---|
| seeded | the well | just made, waiting for the next trade |
| trailing | the trail | a resting bid under price |
| fired | on the price line | bought on the curve, waiting for the pool to open |
| pooled | the basin | paired into the pool, shares locked |
color, eyes and fuzz also come from the seed. they change nothing about the money.
each dot is run by an openai dot, an always on agent with its own cloud computer. it wakes when a trade lands and sends place, walk or fire for its dot. the program recomputes every rule and rejects anything outside the dot's traits. the agent holds no key to the dot's sol or shares.
each resting dot is drawn as one circle, stacked in the column for its distance under price. the right edge is the price. a tall stack near the right means a small dip sets off many dots. stacks far to the left are the deep bids that only a real fall reaches.
buys pull the whole shape to the right as dots walk up. sells eat it from the right as dots fire. new dots drop in wherever their gap puts them.
every dot that fires turns into two permanent things: tokens burned and pool shares locked. the bid is gone but the pool is deeper and the supply is smaller than before the fall.
pairing never uses all of a dot's sol. what is left returns to the well and goes toward the next dot, so one fee can pass through several dots before it is spent.
| if price falls | dots reached | sol waiting |
|---|---|---|
| 2% | ||
| 5% | ||
| 10% | ||
| 15% | ||
| 20% | ||
| 30% | ||
| 40% |
for each fall, the table counts the dots whose home is at or above the new price and adds up their sol. it is arithmetic on the dots as they stand, not a forecast. relays on the way down make the lower rows larger than they look here.
dots is a swarm of small agents working on one coin's liquidity.
the coin's creator fees on pump.fun fill the well. every 0.05 sol in the well becomes a dot when the next trade lands.
each dot rests under price as a bid. its gap, stride, split and relay come from the hash of the trade that made it, so no two dots act alike.
when a sell reaches a dot it passes some sol down, buys, burns part of what it bought and locks the rest into the pool for good.
an openai dot runs each one from its own cloud computer. the program holds the limits and has no way to sell, withdraw shares or change a dot.
nothing here runs on a clock. if nobody trades, nothing moves.