Working out, in writing, how parts of the agent stack actually function - backed by production-ready code on GitHub.
It divides the model's scores by a single number just before they turn into probabilities, and that is the whole mechanism. The model has already finished computing those scores by the time temperature touches them, which is why it can never change the token that came out on top, only how often something else gets drawn instead. The newest models are removing the parameter altogether.
Four things that have held up across the agents I've built, and the bit of model mechanics they all fall out of. A system prompt isn't a settings page you configure, it's the front of a sequence the model reads back one token at a time, and most of what's worth knowing about prompting is a consequence of that.
Every request your agent makes re-sends everything it has ever said, and the model reads it all again from scratch, at full price. Prompt caching is the one-line fix, and understanding what it actually stores tells you more about how these models work than most explainers will.
The model is one input into an agent. The harness is everything else you build around it - and that "everything else" has a knowable set of parts, four questions to organise them, and one rule for deciding which ones you actually need.
A harness that has to work out what an error means will eventually get it wrong. The tool that raised the error never has to. This is how I ended up classifying failures in the tools instead of the harness, and the decisions that fell out of that choice.
The most common agent pattern is the ReAct loop: the model reasons, calls a tool, looks at the result, and repeats until it reaches its goal. But tools fail constantly, and what separates an agent that recovers from one that stalls or spins isn't a smarter model. It's where you handle the error.
When an agent needs a few independent lookups, there's no reason to do them one at a time. Parallel tool calls, what the model is actually deciding, and the cheapest speed-up there is in an agent.
How the ReAct loop actually works, why mixing reasoning and acting was the real insight, and the failure modes that show up when you don't take the observation step seriously.
Why "let's think step by step" worked, why reasoning models work for the same reason, and what changes for anyone building on top.