20 writers and practitioners covering new models, pricing, caching and the cost of running agents. Start with their work, then explore related posts on X and LinkedIn.
Compiled October 29, 2026 · People listed alphabetically · A snapshot, not a live feed
Each person has a source to start with. The selection includes independent writers, educators, reporters and people sharing model announcements.
20 peopleExplains where coding agents spend their tokens, including the work of finding relevant code before editing it.
Writes about model selection and context engineering, including which steps need a more expensive model.
Explains prompt structure, cache misses and the provider usage fields that show whether caching worked.
Writes about practical AI use and how falling model prices change access to capable systems.
Reports on model releases and pricing changes, including cache-read rates that headline token prices can obscure.
Shares research and commentary on prompt caching, cache-hit rates, cost and latency in agent systems.
Writes and speaks about agent context, reasoning effort, cost and latency.
Shares Gemini developer announcements, including model releases and price changes.
Compares model price cuts and explains how cache pricing changes the cost of an agent run.
Cofounded Artificial Analysis, which publishes model and provider comparisons, including cost per task.
Analyzes model releases and the competition between coding models, agent tools and evaluation approaches.
Discusses cache warming, retention and model effort, with practical checks for agent sessions.
Publishes developer guides and model-launch posts, and has shared a hosted-model pricing comparison.
Explains prompt caching through implementation experience, with examples involving cache writes and changing tool definitions.
Explains model architecture, reasoning and release results through technical articles in Ahead of AI.
Publishes model-release briefings through Latent Space, including the distinction between token prices and the cost of completed work.
Tests new models, compares input, output and cached-input prices, and maintains a model-pricing calculator.
Shares Claude developer and model-release updates, including pricing, token efficiency and effort levels.
Creates Zolamir, whose weekly digest records model releases and price changes using OpenRouter data.
Publishes detailed model-release reviews and AI roundups, including discussions of model capabilities and pricing.
13 LinkedIn posts and 7 X links. LinkedIn posts were read directly. X links were traced through articles, embeds or public copies; the original X text was not independently read. Each X entry includes its supporting source. Dates and older material are labeled.
20 postsExplains how code discovery consumes tokens inside coding-agent sessions.
Explains stable prefixes and names the response fields used to observe cache hits.
Introduces caching mechanisms and distinguishes token charges from storage charges.
Kevin adds commentary to Elias Lumer's research announcement and links their paper.
Discusses cache warming, retention and checking the first paid turn.
Shares his interactive pricing tool. A separate comment by Jorge Alcantara asks for a pricing API.
Publishes a cross-provider rate comparison and asks what is missing.
The author announces the model. Several commenters question its price relative to previous Flash models.
Sankalp shares recognition of his explainer and links the article in his own comment.
Comments on developer attention across Gemini, Claude Code, Codex and open-model coding plans.
Announces Gemini 1.5 updates including lower prices and higher limits.
Describes using Simon Willison's calculator to rethink costs across workloads and providers.
Shares Philipp's comparison and says capability information would improve it.
A secondary index preserves his launch post calling out pricing, coding and writing.
The indexed excerpt compares effort settings and discusses cache-read pricing.
His own blog embeds this post about cache-write charges and then explains the tradeoff.
His blog embeds a question about new tools arriving during execution and cache reuse.
Simon Willison quotes the launch post when discussing the price cut.
A public copy describes the company's provider-level cache and cost comparisons.
Max's pricing article links this announcement as a change in the duration of a price cut.
Four LinkedIn examples and two X examples, written in Metergraph's voice. They show how to credit a writer and add a useful observation.
6 examplesThese are illustrative examples, not posts from the people cited. Adapt the wording to your own work and keep the source links. Inclusion here does not imply endorsement or use of Metergraph.
Max Woolf's breakdown of recent model price cuts is worth reading, especially the part about cache pricing.
Two models can have the same input and output rates and still cost different amounts on an agent run. The cached part of the conversation has its own price.
If you're comparing costs, separate new input, cached input and output. Check for cache-write or storage charges too.
Max's piece: https://minimaxir.com/2026/10/cheap-llms/
We built Metergraph's free pricing API to do that arithmetic from model usage. No account or API key needed: https://www.metergraph.dev/pricing-api/
Max Woolf makes a useful point: cache prices can change the whole model-cost comparison. https://minimaxir.com/2026/10/cheap-llms/
We made a free API to do the cost arithmetic from model usage: https://www.metergraph.dev/pricing-api/
Drew Breunig describes using an expensive model to work through a design, then handing the brief to a cheaper model to write the code.
That's a useful way to look at an AI bill. Which steps actually need the expensive model?
Compare the cost of each step, then check whether the result is still good enough. A lower token price alone won't answer that.
Drew's post: https://www.dbreunig.com/2026/08/23/fable-the-end-of-moore-s-law.html
For the cost calculation, we made a free API at Metergraph. Send it model usage and it returns a cost breakdown: https://www.metergraph.dev/pricing-api/
Drew Breunig uses a stronger model to shape a design, then a cheaper one to implement it.
Worth asking of your own workflow: which steps need the expensive model?
https://www.dbreunig.com/2026/08/23/fable-the-end-of-moore-s-law.html
Simon Willison included the cost of failed model runs in his September release comparison. That's a useful detail to keep.
If one model needs three attempts and another gets it right on the first, comparing the price of one successful call misses part of the bill.
Count the failed attempts too. Keep cost and quality beside each other when you compare models.
Simon's write-up: https://feeds.simonwillison.net/2026/Sep/22/opus-and-sol-and-luna/
He already has a pricing calculator. We also offer a free API if you want to calculate costs from usage in your own code: https://www.metergraph.dev/pricing-api/
Eric Dong's caching post has a useful practical check: look at the cached-token fields in the provider response.
Enabling caching doesn't tell you how much of a request came from the cache. Those usage fields do.
The next step is to price the usage you actually got. Separate cached input, new input and output, and include any other applicable charges.
Eric's post: https://www.linkedin.com/posts/edong186_prompt-caching-isnt-working-the-way-you-activity-7438647702516617216-rvb3
We made Metergraph's free pricing API to help with the calculation: https://www.metergraph.dev/pricing-api/