Most of my time with LLMs goes into unglamorous text chores: translating a paragraph, condensing a long report, rewriting something that came out too wordy. While going through a batch of recent write-ups on exactly that, three things stuck with me — how generation actually works under the hood, that the cheap tier of models is now good enough for everyday jobs, and that an agent can quietly spend a small fortune while producing nothing at all.
Inference: the model never really sees your words
When I paste an article and ask for a translation or a summary, the model isn't manipulating strings. The text is turned into numbers, those numbers run through the network, and the answer comes back one token at a time. The whole pipeline is called inference, and a translated Habr piece walks through it in detail.
That framing is more practical than it sounds. Translation, summarization and shortening aren't three separate features — they're one mechanism with different prompts:
prompt -> tokens -> numbers -> [model] -> next token
-> append -> repeat
Which means when output quality differs between models, the task type usually isn't the reason. The model is.
GPT-6 got split, and the cheaper half is the interesting one
In September 2026, OpenAI split GPT-6 into two working models, Sol and Luna. Sol is the budget one: prices cut by 50%. For routine work — summarizing an inbox, generating a first draft of a text — that's the version I'd reach for first, because it makes running high volumes of summarization or drafting affordable.
Sol is described as the practical choice for everyday text tasks, and that matches how I use models: most requests are boring, repeating, and don't need frontier-level reasoning. The source material doesn't say much about Luna beyond it being the other half of the split, so I won't guess at how the two compare on anything but price.
Shortening text without losing facts: six models, one review
A review called "Koroche, GPT" looked at six neural networks on a single job: cutting a text down while keeping its facts intact. That's exactly the job I hit most often — long reports, overlong messages, articles that need to fit a word count.
The interesting part isn't the ranking. The review also explains how to check the output, and it makes a point I keep relearning: sometimes you should put back the lines you deleted. Shortening is not the same as deleting. If the meaning goes missing, the words you saved cost you more than they saved you.
My working habit after reading it: diff the shortened version against the original line by line, and confirm every fact survived before anything ships.
The 37 minutes and 300,000 tokens that produced nothing
The cautionary tale from the material: YandexGPT, given a real agent task, fell into an infinite loop. It made 295 repeated tool calls, rebuilt its context 296 times, ran for 37 minutes and spent around 300,000 tokens — without delivering a result.
That's the failure mode I care about most when tokens are billed. It isn't a slow answer or a weak answer; it's a model that cannot stop. A step limit and a repeat check are cheap insurance, even in a rough sketch like this:
MAX_STEPS = 25
seen = []
for step in range(MAX_STEPS):
action = agent.next_action()
if action.signature in seen:
break # same tool call again -> stop before it gets expensive
seen.append(action.signature)
From a chat window to an agent
A September 2026 guide shows how to turn an ordinary LLM chat into a full AI agent by setting up OpenCode step by step. It's worth a read if you're moving from "summarize this" to "go do this", because the thing you optimize changes. With a chat, you optimize the answer. With an agent, you also optimize how many steps it takes to get there — which is exactly where the YandexGPT story comes back around.
Who is actually using this in 2026
In Russia in 2026, roughly 35 million people use neural networks — about one in four residents. A top-15 list of Russian-language chat models compares GPT, Claude, Gemini, DeepSeek and others for everyday text work, which is a decent reminder that the mainstream use case is still text chores, not autonomous agents. Tracking releases matters more now that names, tiers and prices shift every few months; Daily LLM News from AINews.ai monitors releases across GPT, Claude, Gemini and the rest of the segment.
What I take away
Three things. Inference is a single mechanism behind translation, summarization and shortening, so pick your model rather than your feature. The cheaper tier is usually enough — Sol at 50% off handles routine summarizing and drafting. And budget for the agent that doesn't know when to stop: 300,000 tokens for zero output is the number I keep next to my API key. Whatever the model shortens, read the diff.
This article was originally published on AI Release — https://ai-release.org. If you follow model releases, pricing changes and practical agent experiments, the channel at https://t.me/ai_release1 is where I keep up with them.
Top comments (0)