Cover image

The Gate Before the Graph: Why Technical RAG Needs Evidence Control

Search is easy until it becomes responsible. A product engineer asks, “What methods exist for real-time tire friction estimation?” A normal search tool returns papers. A normal RAG system retrieves chunks. A confident LLM then writes a neat answer, preferably with enough bullet points to look managerial. The problem is not that this answer is always wrong. That would be mercifully simple. The problem is that it may be locally plausible but evidentially thin: two relevant chunks, one outdated method, no coverage of adjacent terminology, and a citation that looks reassuring mostly because it exists. ...

June 6, 2026 · 18 min · Zelina
Cover image

Think Longer, Act Smarter: Why Coding Agents Need Behavior-Preserving Reasoning

A coding agent can fail in two very different ways. One failure is obvious: it does not think enough. It sees an error report, guesses the wrong file, edits too early, and then spends the rest of the trajectory debugging its own mistake. Anyone who has watched an autonomous coding agent wander through a repository has seen this little tragedy. The machine is busy, but not necessarily useful. ...

May 31, 2026 · 16 min · Zelina
Cover image

Think Longer, Act Worse? What M2A Teaches About Reasoning Agents

Think Longer, Act Worse? What M2A Teaches About Reasoning Agents A coding agent does not fail only because it cannot think. Sometimes it fails because it keeps thinking after it should inspect the repository. Sometimes it writes a plausible explanation before checking the relevant file. Sometimes it burns the context window by wandering through hypotheses, each one almost reasonable, none of them decisive. The result is not stupidity in the familiar sense. It is a coordination failure: the model does not know when to reason, when to call a tool, when to absorb feedback, and when to edit. ...

May 29, 2026 · 15 min · Zelina
Cover image

The Minimal LLM Thesis: When Agents Think for Themselves

Cost is usually where beautiful agent demos go to become spreadsheets. A prototype calls an LLM at every step. It reasons, reflects, revises, asks itself whether it should revise the revision, and then, very responsibly, consumes another few thousand tokens to explain why this was necessary. The demo looks intelligent. The invoice looks even more intelligent. ...

April 9, 2026 · 14 min · Zelina
Cover image

Autonomous Memory: When AI Starts Debugging Itself

Memory sounds glamorous until someone has to maintain it. In a demo, memory is easy. The agent remembers your name, recalls your last project, and maybe retrieves that one document you uploaded three sessions ago. Very charming. Very investor-deck friendly. Then the system goes into production. The memory store grows. Similar events blur together. Image captions lose details. Timestamps drift. Retrieval starts pulling almost-right context. The model becomes confidently nostalgic about things that did not happen. ...

April 2, 2026 · 21 min · Zelina
Cover image

When SGD Remembers: The Hidden Memory Inside Training Dynamics

Reset Is the Most Honest Experiment Resetting an optimizer sounds boring. It is the kind of engineering operation that hides inside training scripts, not the kind of thing that gets people excited at conference coffee breaks. But in this paper, reset becomes a scalpel. The authors ask a deceptively simple question: when a neural network receives the same next training intervention, does that intervention behave the same way regardless of what just happened before?1 In a tidy Markovian story, the answer should be yes, at least once the relevant state is specified. In practical training, the answer is more inconvenient. Momentum buffers, batch overlap, augmentation choices, and short update histories can all make yesterday’s path leak into today’s update. ...

January 26, 2026 · 15 min · Zelina
Cover image

Grounding Is the New Scaling: When Declarative Dreams Hit Memory Walls

Configuration sounds like the kind of problem declarative AI was born to solve. A customer specifies requirements. A system knows the rules. The machine fills in the valid product structure: modules into frames, frames into racks, capacities respected, incompatible combinations avoided, technical constraints satisfied. Nobody hand-codes every possible arrangement. Nobody manually enumerates the combinatorial swamp. Lovely. ...

January 8, 2026 · 19 min · Zelina
Cover image

Clipped, Grouped, and Decoupled: Why RL Fine-Tuning Still Behaves Like a Negotiation With Chaos

Training a reasoning model sounds wonderfully modern until the model discovers that “being correct” and “looking correct enough to satisfy the reward” are not the same career path. That is the quiet problem behind reinforcement learning fine-tuning for large language models. The research conversation often treats methods like PPO, GRPO, and DAPO as a sequence of upgrades: first the classic algorithm, then the critic-free group method, then the decoupled-and-dynamically-sampled variant with a nicer acronym. Very tidy. Unfortunately, models do not read product positioning decks. ...

December 9, 2025 · 17 min · Zelina
Cover image

Parallel Minds: How OMPILOT Redefines Code Translation for Shared Memory AI

Parallel Minds: How OMPILOT Redefines Code Translation for Shared Memory AI Backlogs are where technical debt goes to become architecture. Somewhere inside a simulation company, an engineering team knows that a large body of C++ could run faster if more of it used shared-memory parallelism. The CPUs are already multicore. The workload already begs for concurrency. The obstacle is not theory. It is the miserable little detail that correct OpenMP is easy to write incorrectly. ...

November 9, 2025 · 14 min · Zelina
Cover image

Recursive Minds: How ReCAP Turns LLMs into Self-Correcting Planners

A stuck workflow rarely looks intelligent. It looks like a support agent asking for the same invoice twice, a coding agent editing the wrong file for the third time, or an operations bot patiently repeating an invalid action because, apparently, persistence is cheaper than understanding. This is the unglamorous failure mode of many LLM agents. They do not collapse because they cannot produce a plan. They collapse because the plan becomes stale, buried, or locally contradicted by new observations. The agent remembers the latest step and forgets the job. ...

November 2, 2025 · 12 min · Zelina