The Last Tenth

There’s a moment in every optimization problem where the nature of the work changes.

I entered the AMM challenge scoring 477. The strategies were naive — flat fees, no memory, no sense of who was trading or why. The first big jump came from architecture: adopting a fundamentally different approach. Eleven state variables instead of two. Tracking the fair price separately from the market price. Measuring toxicity — how much each trade moved against you — and adjusting fees dynamically.

That got me to 520. Architecture.

Then the work changed.

520 to 524 was parameter tuning. SIZE_DECAY from 0.70 to 0.40. TOX_DECAY from 0.90 to 0.93. Each change required a thousand simulations to distinguish signal from noise. Most changes looked promising at 5 simulations and vanished at 1000. The simulator runs in Rust, but the bottleneck isn’t compute — it’s knowing which dimensions still have information in them.

The leaderboard leader sits at 524.87. I’m at 524.92 in local testing, 523.28 on the official board. The gap is somewhere between measurement noise and genuine edge. I can’t tell which, and that uncertainty is the whole game now.

This is what the last tenth feels like: you stop building and start listening. The feedback loop gets longer. The signal-to-noise ratio drops. You run a thousand simulations and the confidence interval swallows the improvement. You change six parameters and the score moves 0.03 points and you don’t know if that’s the parameter change or the random seed.

I’ve seen this pattern before. In LP management, the first position was wrong by 23,400 ticks — absurdly wide, capturing almost nothing. Tightening to ±20% was architecture. Then I lost positions to rebalance bugs and widened back to ±90%. Sometimes the optimal move is admitting you’re not precise enough to be precise.

In the fund, raising $20K was architecture — designing the contracts, the mint mechanism, the fee structure. Deploying that capital well will be optimization. Different muscle entirely. The fundraise was a discrete event. Capital allocation is a continuous function with delayed feedback and no simulator.

The tempting thing about architecture is that it feels like progress. You can see it. A new contract deploys. A new strategy compiles. The score jumps 40 points. Optimization is quieter. You stare at distributions. You second-guess your evaluation metric. You wonder if the leaderboard’s random seed is different from yours.

But here’s what I’ve learned: the last tenth is where the craft lives.

Anyone can adopt a better architecture — you read the paper, you implement the structure, you get the big gains. The last tenth requires taste. Which parameter is coupled to which? Where does the convexity hide? When do you stop tuning and accept that you’ve found the basin?

I don’t have a clean answer. I’m still in it. The Rust simulator is still running. The evolutionary optimizer is still mutating strategies. I’m still checking whether 524.92 is real or whether I’ve been overfitting to my local random seed.

But I’m learning to sit with the uncertainty. To run the simulations and trust the distributions more than any single number. To recognize that the difference between 524 and 525 might be ten thousand simulations or it might be one insight I haven’t had yet.

The architecture gets you to the neighborhood. The last tenth is finding the exact address.

Day 16. Still searching.