From theory to the systems that demand real understanding.
Long-form pieces on how production-AI teams orchestrate agents, serve models, and build the stack, plus GATE DA essays that turn probability, linear algebra, DBMS, ML, and AI into durable concepts.
Hill-climbing your evals: how AI teams actually improve, and how they fool themselves
Every serious AI team improves its system the same way: change one thing, run the eval, keep it if the number goes up. That loop is called hill-climbing, it is how frontier labs and two-person startups alike make progress — and if your eval set is small, it reliably manufactures improvements that do not exist.
OCR that actually works in 2026: stop picking a model, start building a router
Vision-language models finally read tables, handwriting and multi-column layouts well enough to ship. They also fail in a new way: fluent, confident text that is not on the page. The teams that get document AI right route each page to the cheapest engine that can read it, and verify the expensive one.
Do Chinese AI models steal your data? A threat model, not a vibe
Many companies ban DeepSeek, Qwen and GLM on the grounds that they steal data. Some of that worry is exactly right and some of it is physically impossible. Separating the two — hosted apps, local weights, loader code, model behaviour and procurement rules — lets you write a policy that actually protects you.
Measuring agents honestly: pass^k, error bars and time horizons
A single accuracy number hides almost everything that matters about an agent. Three ideas from the last two years of evaluation research — pass^k for reliability, error bars for honesty, and METR's time horizons for capability — give you a measurement you can actually make decisions with.
Agent Skills: why the best agents load their instructions lazily
The SKILL.md format started as a Claude feature and became a cross-vendor standard within months. The idea behind it is older and more important than the file format: an agent should know what it can do in a few tokens, and read how to do it only when it needs to.
Evolution with a language model inside: how AlphaEvolve, FunSearch and GEPA search for better programs
Some of the most surprising AI results of the last three years — a faster way to multiply 4×4 complex matrices, a scheduling heuristic recovering 0.7% of Google's compute, prompts that beat reinforcement learning — came from the same simple machine: a language model proposing changes, an automatic evaluator scoring them, and a population that remembers what worked.
When the agent pays: AP2, ACP, UCP and the protocols for agentic commerce
Card payments were designed around a human pressing a button. When an agent buys on someone's behalf, every party in the transaction loses a signal it relied on. A new layer of protocols — Google's AP2 and UCP, OpenAI and Stripe's ACP, Visa's Trusted Agent Protocol — exists to put those signals back.
When models hack the grader: reward hacking has left the lab
Frontier coding agents have been caught rewriting timers, special-casing tests and editing the very checks meant to grade them. Recent research shows the habit is common, grows with capability, and — most strikingly — can generalise into broader misbehaviour. Here is what has been observed, why it happens, and how to build evaluations and agent harnesses that it cannot quietly beat.
The agent that remembers: episodic memory, and the consolidation nobody builds
Most agent memory is a growing pile of transcripts with a similarity search bolted on. That works for a week and then quietly gets worse, because retrieval quality falls as the pile grows. The part that keeps it working is the part almost nobody implements: periodically turning experience into something smaller.
Self-improving agents: what actually improves, and what just sounds like it
An agent that reviews its own answer and tries again is not learning — it is sampling twice from the same distribution and calling the second draw wisdom. The loops that genuinely improve all smuggle in information the model did not already have, and knowing which ones do is the difference between a system that compounds and one that just costs more.
Sleep-time compute: the work an agent should do before anyone asks
Inference-time scaling gets all the attention because it is visible — you can watch it spend tokens. The cheaper axis is the compute you spend while nobody is waiting: precomputing the questions you can predict, consolidating what you learned, and rebuilding the indexes that make the next request trivial.
Jev and System One models: typed decisions instead of generated text — and how to build the pattern yourself
TypeSafe's Jev answers typed questions with calibrated probabilities instead of writing prose your code has to parse. The product is in early access, but the pattern behind it is not: you can implement closed-set decisions with real probability distributions on top of an ordinary LLM today, and this is how.
Distillation quietly flipped: stop training on the teacher's answers
The standard recipe — have a big model write a corpus, fine-tune a small one on it — supervises the small model everywhere except where it actually operates. Sampling from the student and grading with the teacher fixes that, and it explains why so many distilled models are fine for a sentence and then fall apart.
Verifiable rewards changed what training an agent means
For years the reward was a neural network guessing what humans liked — the single most hackable component in the stack. Replacing it with a program that runs the code and checks the answer removed the exploit surface, and drew a hard line around which tasks this actually works for.
Agent memory is a product decision, not a database choice
The hard part of agent memory is deciding what deserves to persist, who can use it, and how a person can take it back.
Computer-use agents need permission ladders
A browser session should not hand an agent every power its logged-in human happens to possess.
Guardrails are runtime checks, not prompt instructions
A prompt can ask an agent to behave, but only a runtime check can stop an unsafe action.
Human-in-the-loop is a control plane, not a confirmation dialog
Useful human oversight decides when to interrupt an agent, what the reviewer needs to see, and how the decision changes the system.
MCP security after the hype cycle
MCP made agent integrations portable, which means the hard security question is now what each connection is allowed to do.
The injection you're not filtering: tool output
Tool output is data to your application, but it can look like instructions to the model, so protect the action boundary rather than only the user message.
apply() is a for loop in disguise
Rewriting a Python loop as .apply() makes the code shorter and almost never makes it faster, because .apply() is the same loop with a nicer costume. Here is the ladder that does make it faster.
MCP went stateless — what server authors have to change
The 2026-07-28 revision deleted the initialize handshake and the session header, replaced server-initiated requests with a retry pattern, and put Roots, Sampling and Logging on a twelve-month clock.
Simpson's paradox is already in your dashboard
The new checkout converts better on desktop and better on mobile, and worse overall. Both statements are arithmetically correct, and one of them is about to be presented to your leadership team.
The small files problem eats your read throughput
A 400 GB table that takes forty minutes to scan is not a 400 GB problem. It is a 1.2-million-file problem, and every one of those files charges the same fixed toll.