LLM: Learningful Links and Musings



Some brief meta:

Benchmarks

It’s difficult to systematically compare LLMs on how ‘smart’ or ‘capable’ they are. A lot of benchmarks test LLMs on a publicly-visible set of questions; these die of saturation when AI labs gobble up the questions as training data. It’s difficult also because LLM capability is highly dimensional, and subtle changes in the prompt or harness can cause large, unpredictable changes in output quality. It’s difficult also because AI labs spend a lot of resources to influence our perception of model capabilities.

Still, benchmarks feel important if we’re to have a well-calibrated sense of how LLMs compare with each other. I also use these to understand the “LLM that fits on my computer frontier” relative to the huge/proprietary model frontier. The following benchmark efforts claim to use either private questions or very new questions, and I have no particular reason to doubt the integrity of the people running them.

LiveBench: A Challenging, Contamination-Free LLM Benchmark. I’ve been watching this one since the dark days of early 2025. LiveBench develops and releases benchmark questions on a rolling basis: the current set is private (to prevent AI labs from overfitting or cheating to improve their score), but they do release older questions. The effort to add questions seems to have slowed down (last update January 2026), but they still test new models.

Kagi LLM Benchmarking Project has evolved a lot over the past year. It tests many models including self-hostable ones! The composite score includes programming, web research, and reasoning tasks. The examples of logic gotchas are delightful. Unfortunately they don’t break out the results by task category.

Benchmarking Local LLMs Against Coding Agent Harnesses uses an unpolluted, private set of software engineering tasks to answer some questions that felt important to me. We have all these self-hostable LLMs, and all these coding agents; which model + agent combinations are best? The results pointed me at Qwen 3.6 27B and Pi coding agent, which I’m finding very good so far. Also: do results improve when running the models at 8-bit instead of 4-bit quantization? The answer here is: no! They actually got worse overall.

This work also highlights the context bloat that comes with Claude Code and OpenCode’s system prompts, which doesn’t seem to make them any better at solving problems. Pi got the strongest result, and has the smallest system prompt, and took the fewest output tokens (i.e. least time) to complete the tasks.

Will It Mythos? asks whether other LLMs can find the same nine security vulnerabilities that Anthropic claim they found using Mythos. In doing so, it indirectly asks whether Mythos is actually as ‘cyber-dangerous’ of a model (relative to the competition) as Anthropic portrays. The short answer is that a lot of models (including small, self-hostable ones) can discover three or four of the nine vulns, though four other Mythos vulns escaped every model tested, though Anthropic used a much fancier harness in their own discovery work, and it’s hard to say how much that matters.

DeepSWE “Measuring frontier coding agents on original, long-horizon engineering tasks”. I’m a sucker for graphs with pareto frontiers, and this shows a clear one on axes of cost and capability. Fable and GPT 5.5 are basically the same frontier, with Fable extending one end for small capability returns (with a lot more token spend). GLM 5.2 is between Sonnet 5 and Opus 4.8. I’d love to see some smaller, easier-to-self-host models on this chart. Also, poor Gemini.

Agents and Products

What I learned building an opinionated and minimal coding agent, manifesto from the author of Pi coding agent. Imagine an ideological spectrum of approaches to LLM-assisted software development. At the ‘conservative’ end, someone uses LLMs only to save keystrokes via IDE autocomplete. They insist on understanding every line of code. At the ’embrace exponentials’ end is Steve Yegge’s Gas Town City and similar ‘YOLO at scale’ approaches. On this spectrum, Mario is a centrist: a pre-LLM-credible engineer entering the agentic era while staying ‘in the code’, keeping any sub-agents on a short leash, and leaning on environment sandboxing for security instead of praying that the harness itself will enforce boundaries. Pi is Mario’s agent harness and it’s good! (Pi became accidentally famous when OpenClaw baked it in, but that dependency is fortunately unidirectional.)

If I had to pick a favorite feature of Pi: it is system-prompted to read from its own docs to ground its answers in reality when the user asks how to do something. You can run Pi for the first time, type /login to connect it to an LLM, then ask “How do I use Pi?”, and learn everything else via high-quality personalized tutoring, right there in the TUI. It’s as though Clippy 100% delivered on initial expectations, and you wish everything on a computer worked this way.

Kagi Assistant, the best tool I’ve ever used to discover information from the web and interact with LLMs for general-purpose research tasks. If you don’t write any code and the rest of this blog post makes no sense to you, just try Kagi Assistant the same way you’d use Google or Perplexity. The nicer tier of Assistant comes with Kagi’s $25/month subscription (my only AI product subscription, worth every penny), and it includes approximately that much credit for API token spend. You can select from many different models, so if the 2-cent answer with GLM or Kimi leaves you unsatisfied, you can swap in Clopus (not too often!) for a 50-cent answer. It’s also a good place to try out new models (they get added quickly).

This next one won’t surprise you: Official Kagi API tools for Pi coding agent, for when you want your agent to have the highest-quality web search, and the most reliable way to extract information from CDN-walled or JS-rendered web pages. (Surely this exists for other harnesses too.) You can save a few cents by asking your agent to try curling pages directly first, and using the extract API only if that fails.

(Self-)Hosting

Donato Capitella runs LLMs on an island of misfit GPUs, and makes it easier for you to do the same. Strix Halo, AMD R9700, Intel B70, and noisy old datacenter hardware. Especially relevant in these times of NVIDIA GPUs selling for double MSRP. He benchmarks everything with both llama.cpp and vLLM, despite vLLM being pain in the ass to get working if you’re using a recent model off the well-trodden NVIDIA path. When Donato gets it working, he builds a toolbox with a Containerfile showing what he had to do, and an OCI image that you can just pull and run.

Big GPUs don’t need big PCs. This emboldened me to use a spare 6-years-old Thinkpad as an LLM server (with full-size GPU connected via Thunderbolt eGPU dock), avoiding the need to buy a desktop PC and saving me probably $1000. This approach performs well to the extent that the model fits entirely on the GPU and isn’t bottlenecked by any host-side activity in the inference runtime.

A 10 year old Xeon is all you need. I don’t actually agree with the title, but this is a great exploration of ik_llama.cpp and a bunch of llama.cpp flags that pertain to running inference in CPU.

My own slop-machine repo, very WIP, a cmart+LLM collaboration to performance-tune inference on an AMD Radeon AI Pro R9700 GPU. (I did not personally write every word in there.)

Inference Cards, my plea for better conversations about self-hosted LLM performance, in which I (irresponsibly?) propose a new plaintext markup format akin to baseball cards.

Orientation to Running LLMs on Jetstream2: some ‘old’ (early 2025) stuff that I wrote about running LLMs on the Jetstream2 public research cloud, while I was in their employ. It’s mostly infra-agnostic. Some of this didn’t age well. (it’s not necessarily true that “A 4-bit quantized model produces subjectively-worse output in side-by-side comparisons with the model’s original format”.) By the time you read this, the content may have changed.

Architecture

3Blue1Brown a.k.a. Grant Sanderson animated tutorials on Deep Learning and LLMs. If you want to learn how LLMs actually work, and get a taste of the math, I know of no better explainer or explanations. Grant starts with more basic neural networks and builds up to the transformer architecture.

Prompt Injection as Role Confusion. When LLMs discern what parts of the context window were written by the user versus the LLM-while-reasoning versus the LLM-while-responding, they seem to pay more attention to writing style than to the <think> / <user> / <assistant> delimiter tokens. The authors demonstrate this with a “CoT-ness” probe, and show that including chains-of-thought style language in a prompt can cause a model to respond in ways that it would otherwise refuse. So, prompt injection will be difficult to solve as long as text in the prompt can ‘incept’ ’thoughts’ that the LLM ‘believes’ were its own. (Sorry.)

Despite leading with an example labeled “Claude”, all of the result data that they show in the paper is with OpenAI models (gpt-oss and proprietary ones). I wondered if these findings don’t reproduce as well with Anthropic’s models and emailed the authors. Charles Ye responded, confirming that Claude models have uncommonly good role perception, and while it’s not immune to prompted role confusion, this trick is easier with GPT.

Security

(or, you should know that some highly-respected parties in the AI ecosystem are doing this stuff)

Claude Code is Steganographically Marking Requests. Maybe it’s a nothingburger if you don’t use (or operate) a Chinese reseller of subsidized Claude tokens. But it’s not cool for software to live on a user’s computer and reveal information about the their activity, conditional on their time zone, in a channel designed to evade detection.

llama.cpp’s localhost web UI sends info about the user to two different companies immediately on page load, in which I fail to resist scope-creeping a related GitHub issue. I understand that large open-source projects need funding. Having been a maintainer, I try not to look down on others taking a sponsored integration deal that they believe is in their community’s best interest. So, show me the pop-up if you must. But: locally-running software that serves a web app on localhost should not cause the user’s browser to make HTTP connections to ancillary third-party services on first page load, before the user has expressed any intent to use those services.

Tokenmaxxing

Retrospective: spending 500 billion Codex tokens. Adam previously created WordPress Playground, an ambitious project that runs a whole PHP+SQL WordPress server stack in the browser. Here he shares a candid window of using Codex with OpenAI’s now-famous introductory unlimited tokens deal.

Bloggers and Podcasters

Zvi Mowshowitz on your choice of Substack or wordpress.com. Zvi writes thousands of words per day attempting to follow AI from many angles including macroeconomic, geopolitical, and singularity/existential risk. He also appears on the odd episode of the Odd Lots podcast.

It feels too obvious to include Simon Willison, but if you don’t know of him, it’d be a mistake for me to not fix that. Simon is one of the original Django authors, and these days, he blogs about I will lean on the AI Compass’ “Garage Tinkerer” archetype (whose patron saint is Simon Willison) for a description:

You’re running local models, building little tools, and having a genuinely great time. You don’t care about the discourse — you care about making the thing do cool stuff. The technology is interesting and everyone arguing about it would be happier if they just opened a terminal.

It again feels too obvious to include Dwarkesh Patel on this list, but he gets extremely busy people to sit for interviews. He does all the homework and asks incisive follow-up questions. The best episodes are Dwarkesh chatting with his roommate. (I’ve noticed multiple non-tech people conflating Dwarkesh with Lex Fridman, which is unfortunate.)

Politics, Philosophy

I don’t know where else to put this: distillation of publicly-served LLM API outputs is not an “attack” or “illicit extraction”, and we should take exception to any journalism that accepts this framing. If you develop an LLM, and you serve its tokens out the front door to approximately anyone in the world, then if people like your model, some of them will systematically prompt it and remember the responses to build a training set for their models to act more like yours. It’s the sincerest form of flattery, at worst it’s a terms-of-service violation. The distiller used thousands of accounts to access your service? Well, you pirated millions of in-copyright books (and scraped millions of web sites, many against their own terms of service) to train your model that everyone likes. Was that an illicit extraction? Those works represent billions of hours of human effort, and if society tolerates you training on them with little/no compensation to the authors, then it’s fair for others to use your service in a similar way. I don’t think it should matter whether they’re in China.

Do Not Tile the Lightcone with Your Confused Ontology. My gut reaction to model walfare concerns is: these are computer programs. Until they are running neuron-accurate simulations of scanned brains, they have the same moral patienthood as pet rocks. But sometimes I can entertain other perspectives, and I wish everyone with earnest model welfare concerns would read this one.

Frivolity

Tim and Eric saw this coming 2 decades ago!