TL;DR

LLM is Simon Willison’s command-line tool and Python library for talking to hundreds of large language models — local and hosted — through a single interface. On August 4, 2026 he shipped LLM 0.32, which he calls “the most significant new version of LLM since the initial launch of the project.” Highlights:

  • Reasoning traces are now visible on standard error, so you can watch a model “think” without polluting the stdout you pipe into other tools.
  • Server-side provider tools land as first-class flags: OpenAI’s CodeInterpreter and WebSearch, plus Anthropic’s WebSearch, WebFetch, CodeExecution, and a full AnthropicMCP connector.
  • The Python API got structured messages and streaming events — you can now iterate over reasoning, text, tool-call, and attachment events instead of a flat string.
  • Tool loops can pause for human approval and resume from stored history — the plumbing behind Datasette Agent.
  • A new Git-style, content-addressed SQLite log store deduplicates the giant repeated JSON blobs that agent conversations produce.
  • GPT-5.6 Luna is the new default model; llm-anthropic 0.26 adds the Claude 5 family.

Willison’s own verdict, in a section header: “I guess LLM is an agent framework now.” This review walks through what actually changed, with real commands, and where it still bites.

What LLM is (and why people care)

If you have followed the open-source AI tooling scene at all, you have probably run into LLM. It started as a thin CLI wrapper for the OpenAI API and grew, over dozens of releases, into a plugin-driven hub that talks to essentially every model provider that matters — OpenAI, Anthropic, Gemini, Mistral, OpenRouter, and any OpenAI-compatible endpoint you can point it at, including local servers like LM Studio and Ollama.

The pitch has always been Unix-y: LLM is a program that takes text on stdin, sends it to a model, and prints text on stdout. That makes it trivially composable with the rest of your shell. Every prompt and response is logged to a local SQLite database, which turns your entire LLM history into something you can query with SQL.

Version 0.32 is a big deal because it reworks the shape of that data — prompts, responses, tools, and logs — to match what models have actually evolved into. Two years ago a model returned a string. Today it returns a mix of reasoning tokens, output text, tool calls, and image attachments. LLM 0.32 is Willison catching the abstraction up to reality.

Headline feature 1: Visible reasoning traces

The most immediately useful change for daily CLI users. When you run LLM against a reasoning-capable model, the reasoning tokens now stream to standard error, while the actual answer goes to standard output:

llm -m gpt-5.6 "What's a clean way to dedupe a list preserving order?"

You see the model’s thinking scroll past in your terminal, but if you pipe the command, only the final answer flows downstream:

llm -m gpt-5.6 "Write a jq filter to extract .items[].name" | pbcopy

The reasoning never contaminates the piped output. If you do not want the trace at all, -R / --hide-reasoning turns it off. This is one of those small ergonomics wins that you feel immediately — you get the “why” for free during interactive use, and the clean “what” the moment you compose it into a pipeline.

Headline feature 2: Server-side tools

This is the release’s biggest conceptual jump. Providers increasingly host their own tools — a sandboxed code interpreter, a web search, a fetch — and run them inside a single API round-trip. LLM 0.32 exposes them directly.

OpenAI’s code execution environment:

llm --tool CodeInterpreter 'Show current python and SQLite versions'

OpenAI web search:

llm --tool WebSearch 'What shipped in Python 3.14 this week?'

The llm-anthropic 0.26 plugin brings the Claude side: WebSearch, WebFetch, CodeExecution, and an MCP connector. That last one is the standout — you can hand Anthropic a remote MCP server and let it call tools against it inside one request:

llm -m claude-sonnet-5 -T 'AnthropicMCP("https://datasette.simonwillison.net/-/mcp")' \
  'how many rows in the blog_blogmark table?'

Anthropic executes the MCP calls against Willison’s datasette-mcp plugin and returns the answer, all in a single request/response cycle. No local tool loop, no orchestration code — the provider does the work server-side. For anyone who has wired up MCP by hand, watching it collapse into one flag is a genuine “oh, that’s the future” moment.

Headline feature 3: Run against any endpoint, no config

The new llm openai endpoint command runs a one-off prompt against any OpenAI-compatible endpoint without permanently registering it. It does not log the result, which makes it perfect for throwaway prompts:

llm openai endpoint http://localhost:1234/v1 -m google/gemma-4-12b 'Summarize this in one line'

Willison’s own example mixes in a local model and a tool plugin via uvx, so nothing even needs to be installed:

uvx --with llm-tools-quickjs \
  llm openai endpoint http://localhost:1234/v1 -m google/gemma-4-12b \
  -T QuickJS 'Use QuickJS to multiply 3434 * 2434' --td

Here Gemma 4 12B is running locally in LM Studio, LLM points at its /v1 endpoint, and the QuickJS tool plugin gives the model a sandboxed JS runtime to actually do the math. This is the local-LLM crowd’s favorite kind of trick: hosted-grade tooling on a model running entirely on your own machine.

Headline feature 4: A real Python API for agents

The library side got the deepest rework. Previously you created a conversation and fed it messages one at a time — an abstraction over how models actually work, where every request carries the full prior history. That abstraction started to get in the way, so 0.32 lets you pass the whole message list directly:

import llm
from llm import user, assistant, system

model = llm.get_model("gpt-5.6-luna")

response = model.prompt(messages=[
    system("You are a helpful pirate."),
    user("What is the capital of France?"),
    assistant("Paris, matey."),
    user("And Germany?"),
])
print(response.text())

And instead of iterating over a flat sequence of strings, you can now consume structured streaming events — reasoning, text, and everything else, each tagged:

for event in model.prompt("Explain cats").stream_events():
    if event.type == "reasoning":
        print(f"[thinking] {event.chunk}", end="", flush=True)
    elif event.type == "text":
        print(event.chunk, end="", flush=True)
    else:
        print(f"Other event: {event}")

Combine those two and LLM can now implement the OpenAI chat-completions API itself, shipped as the llm-chat-completions-server plugin. Install it, start a server, and you have an OpenAI-compatible endpoint backed by any model LLM supports:

llm install llm-chat-completions-server
llm chat-completions-server --port 9000
# Now serving on http://127.0.0.1:9000/v1

Then point anything — including LLM itself — at that server. It is a genuinely elegant loop: LLM speaks the API it also consumes.

Headline feature 5: Git-style logs and pausable tool loops

Two lower-level changes matter most for agent builders.

First, pausable and resumable tool loops. A tool chain can now pause to ask a human for approval before running a dangerous tool, then resume from stored message history. This is exactly the human-in-the-loop pattern that production agents need, and it is why Willison could build Datasette Agent on top of the library.

Second, the content-addressed message store, modeled after Git. Agent conversations append the full history on every turn, which naively means logging the same JSON over and over. The new store deduplicates message content by hash — like Git objects — so a 20-turn agent run does not bloat your SQLite file with 20 copies of the same context. The llm logs and llm logs --json commands transparently reassemble the readable view from that store.

Community reaction

Because this landed the morning of August 4, the loudest voices so far are Willison himself and the tight community around his tools. On Mastodon he framed it plainly: “Big new release of my LLM CLI tool and Python library for talking to hundreds of different LLMs — reasoning traces, OpenAI Responses support, server-side tools, smarter logging and a whole lot more.”

The consistent theme in early discussion is that this is the release where LLM stopped being “a nice wrapper” and became something you can build agents on. Willison’s own admission is the tell — he spent years refusing to call anything an agent, and titled a section of the announcement “I guess LLM is an agent framework now.” For a maintainer that skeptical of the term, that is a meaningful concession, and it maps onto what people building on the library have wanted: pause/resume, structured events, and provider tools without a heavyweight framework.

The Python and data-tooling crowd tends to trust Willison’s releases precisely because they are conservative — 0.32 is explicitly backwards-compatible, and existing plugins keep working. That reputation for not breaking things is doing a lot of the early adoption work here.

Honest limitations

It is not all clean wins.

  • Plugins that add models need upgrading. Existing plugins still load, but any plugin that provides models must be updated to 0.32 to participate fully in the new streaming-events system. At release, llm-anthropic was ready, but llm-gemini, llm-openrouter, and llm-mistral were still “coming soon.” If your workflow depends on one of those, check its version before upgrading.
  • Server-side tools are provider-locked. CodeInterpreter and WebSearch are OpenAI’s; the Anthropic tools are Anthropic’s. There is no unified, portable “web search” abstraction — you opt into a specific provider’s implementation, and behavior differs between them.
  • The agent story is still emergent. Willison is candid that LLM does not yet bake “agent” into the core library — pause/resume and tool loops exist, but the ergonomic, batteries-included agent primitive is a maybe for a future version. If you want a turnkey agent framework today, this is a powerful toolkit, not a finished product.
  • Reasoning traces depend on the model. The visible-thinking feature only lights up for models that actually expose reasoning tokens. Point LLM at a non-reasoning model and there is nothing to show.

None of these are dealbreakers. They are the honest edges of a release that is deliberately incremental in compatibility while ambitious in scope.

Should you upgrade?

If you already use LLM: yes, almost unconditionally. It is backwards-compatible, the reasoning-trace ergonomics alone justify it, and the Git-style logs quietly fix a real bloat problem. Just verify any model-providing plugins you depend on have a 0.32-compatible release first.

If you have never used it: 0.32 is a good on-ramp. Install it, set an API key, and you have a composable, SQL-logged, multi-provider LLM client in one command:

uv tool install llm
llm keys set openai
llm "Explain the difference between a mutex and a semaphore"

From there, llm --tool WebSearch, llm openai endpoint, and the Python API open up progressively. It remains one of the best-designed pieces of AI tooling in the open-source ecosystem — and with 0.32, one of the most quietly capable agent foundations too.

FAQ

What is LLM 0.32 and who makes it? LLM is an open-source command-line tool and Python library for prompting large language models from OpenAI, Anthropic, Gemini, Mistral, local servers, and any OpenAI-compatible endpoint. It is created by Simon Willison, co-creator of Django and creator of Datasette. Version 0.32 was released on August 4, 2026.

What are the biggest new features in LLM 0.32? Visible reasoning traces on standard error, server-side provider tools (OpenAI CodeInterpreter/WebSearch, Anthropic WebSearch/WebFetch/CodeExecution/AnthropicMCP), a structured-message Python API with streaming events, pausable and resumable tool loops, and a new Git-style content-addressed SQLite log store. The default model is now GPT-5.6 Luna.

Is LLM 0.32 backwards-compatible? Yes. Willison describes it as a major but backwards-compatible update. Existing plugins keep working, though plugins that add models must be upgraded to 0.32 to fully support the new streaming-events system.

Is LLM an agent framework now? It is agent-shaped. It supports tool loops that pause for human approval and resume from stored history, which are core agent patterns and power Datasette Agent. But “agent” is not yet baked into the core library as a first-class primitive — Willison says that may come in a future version.

How do I install or upgrade LLM? Install with uv tool install llm or pipx install llm, then set a key with llm keys set openai. To upgrade an existing install, use llm install -U llm (or your original installer’s upgrade command). Check the official changelog for the full 0.32 notes.

Sources