From theory to the systems that demand real understanding.

Loading a model file can run code: MLSecOps in 2026

Downloading an untrusted pickle-backed artifact and loading it with an unrestricted or vulnerable deserializer can be as dangerous as running an untrusted script. Real malicious models have shipped on public hubs — here's the ML attack surface and the defenses that belong in your pipeline.

Agents Jun 10, 2026

MCP is becoming the tool-integration boundary — now comes the hard part

MCP is becoming a common boundary for AI tools and data. The remaining work is making it trustworthy under real identity systems, retries, state, registries, optional UI, and long-running operations.

When much of your traffic is easy: use routing to cut LLM costs

When much of your LLM traffic is easy, route easy requests to a cheaper model, escalate uncertain cases, and cache safe repeats—but measure successful tasks, because a cheap wrong answer is not a saving.

Batch can be 100x cheaper for low-utilization, predictable workloads

The default mental model of 'serving a model' is a live API answering in milliseconds. For many predictable workloads, that is the expensive wrong choice — and the hybrid precompute-to-Redis pattern gives you batch economics with real-time lookup latency.

Statistics Jun 10, 2026

Peeking makes A/B tests lie; CUPED reduces the traffic cost

Peeking can raise the false-positive rate from 5% to 26.1% in a specific small A/B-test simulation. Predeclared endpoints and sequential inference keep monitoring honest; CUPED reduces variance and traffic cost without fixing peeking.

Agents Jun 10, 2026

Prompt injection is the SQL injection of the AI era

Both attacks come from the same root cause — the system can't separate trusted instructions from untrusted data. In agents it becomes a confused-deputy problem, and a single filter won't save you.

LLMs Jun 10, 2026

Running an LLM on your laptop: GGUF, llama.cpp, and the Q-soup

A 7B model now fits on a laptop. GGUF, llama.cpp, and quantization tiers like Q4_K_M — decoded, so running LLMs locally stops being intimidating.

Many ML data failures are silent: the case for data contracts

Many ML data-quality failures stay silent when inputs remain type-compatible but their meaning changes. An enforced contract can block declared, testable violations at a chosen boundary before they poison retraining or serving; semantic guarantees require explicit producer-side checks against canonical data, paired representations, trusted baselines, or an equivalent mechanism.

ML Jun 10, 2026

You can't be fair three ways — and the EU AI Act clock is ticking

A concrete lending example separates demographic parity, equalized odds, predictive parity, and score calibration, then turns their trade-offs into an operational fairness and EU AI Act checklist.

Your GPUs are mostly idle: FinOps for the AI era

A practical guide to the cost of GPU allocation, useful work, and the fixes that turn idle accelerator time into completed runs and successful inferences.

Visualization Jun 10, 2026

Your t-SNE plot is lying to you (three ways)

t-SNE and UMAP reveal clusters PCA hides — but cluster sizes, the gaps between clusters, and even the shapes are often artifacts. How to read these plots without fooling yourself, and when to reach for UMAP instead.

Infrastructure Jun 8, 2026

For some AI deployments, deliverable electricity is becoming a binding co-constraint

For some AI deployments, deliverable electricity is becoming a binding co-constraint. Why data-center power matters, and how inference makes every AI query an energy cost.

Attention is O(n²) — and Mamba's linear escape

Attention costs O(n²), so long context gets expensive fast. State-space models like Mamba do linear sequence work at fixed dimensions, which can make some very long streaming workloads more tractable. Some long-context workloads may favor hybrid designs, but quality, latency, memory, and cost must be measured.

Beyond next-token: world models and the next paradigm

World models predict the next state of an environment, not merely the next token. See how action-conditioned prediction supports planning, and where visual and latent approaches fail.

Diffusion language models: when AI writes text all at once

Masked discrete diffusion language models often start from a masked sequence and refine many positions in parallel over several sequential denoising passes.

13 min read Read

Reading a model's mind: sparse autoencoders explained

Sparse autoencoders pull human-readable features out of an LLM's tangled activations — the breakthrough tool of mechanistic interpretability.

How reasoning distillation gives small models stronger math and code behavior locally

A practical guide to teacher signals, verified reasoning traces, supervised fine-tuning, evaluation, and serving small reasoning models on local hardware.

DPO vs PPO-based RLHF: when offline preference tuning wins

RLHF aligned chat models with a reward model and a fragile RL loop. DPO drops both, learning the same preferences directly from chosen-vs-rejected pairs.

Small models for narrow tasks: when they beat larger models

When a small language model can match or outperform a larger one on a stable, measurable task slice—and when that claim fails.

Why a deployed model does not learn from a chat—and how fine-tuning can cause forgetting

A deployed checkpoint normally does not update its weights from a conversation unless an explicit memory or update loop exists. Fine-tuning on sequential data can cause catastrophic forgetting, meaning degraded old-task performance, but does not necessarily do so. Why continual learning remains an open problem in 2026.

Test-time compute: why thinking longer beats thinking bigger

Test-time compute lets a model think before answering, so a small reasoning model can beat a far larger one. How inference-time scaling works.