llm-keys-ui version 0.1

If you run coding agents on remote machines and hate pasting API keys into chat sessions, a new plugin called llm-keys-ui (version 0.1) offers a neat workaround. It gives you a small web interface for storing keys on a machine, so your agent can retrieve them later without the secrets ever appearing in a conversation.

The problem it solves

The plugin comes from Simon Willison, who describes a workflow many developers will recognize. He has been using Codex Remote to run coding agents on different machines while managing everything from his phone. Those machines are sometimes used for tinkering with LLM projects, and every so often a project needs an API key configured.

The obvious approach — pasting the key directly into the ChatGPT app so the agent can set it up — bothered him. Secrets pasted into an agent session end up in the conversation transcript, which isn't ideal for anything sensitive. He wanted a way to get keys onto a machine that bypasses the chat entirely.

How the plugin works

The solution is a plugin that exposes a browser-based interface for managing keys. Once installed, you can ask Codex to run a single command:

```
uvx --with llm-keys-ui llm keys-ui --all
```

The agent then reports back a URL you can open — and this is the clever part, the URL can point to a local network address or a Tailscale device IP. That means you can reach the key-management interface from your phone even when the machine itself is remote, as long as you're connected through your tailnet or local network.

From that web interface, you can save additional API keys to the machine without ever typing them into a chat window.

Later, when the agent actually needs a key to do its work, it can fetch it with a command like:

```
llm keys get anthropic
```

That command can be dropped into a shell script or run as part of a larger task, so the agent gets access to exactly the credential it needs at the moment it needs it — without the key ever being displayed in the conversation.

Why this matters

This pattern fits neatly into a broader concern about how secrets travel through AI agent workflows. Anything typed into an agent session can end up in logs, transcripts, or model context. Keeping credentials out of the conversation and on the machine itself is a simple but meaningful security improvement.

The reliance on Tailscale also makes the setup practical for real-world use. Many people already run coding agents on home servers, spare laptops, or cloud boxes and access them through a private mesh network. Being able to serve the key-management UI over that same network means no extra infrastructure is required — no public-facing web server, no exposing sensitive endpoints to the internet.

Getting started

Because the plugin runs through `uvx`, you don't need to install anything permanently. The `uvx --with llm-keys-ui` invocation pulls in the plugin on demand and runs the `llm keys-ui --all` command, which starts the interface and covers all configured keys. If you already use the `llm` command-line tool for working with models, the key storage carries over — keys saved through the UI are the same ones `llm keys get` retrieves.

The workflow, in short:

1. Tell your Codex agent to run the `uvx` command above.
2. Ask it for the URL of the interface, including any local network or Tailscale addresses.
3. Open that URL on your phone or computer and paste in the API keys you need.
4. From then on, the agent can pull keys with `llm keys get <provider>` whenever a task requires one.

A small tool with a focused purpose

Version 0.1 signals this is an early release, and the plugin does one thing rather than many. But that focus is its strength: it addresses a genuine friction point in the growing world of remote agent workflows, where the question of "how do I safely hand my agent a credential?" doesn't yet have a standard answer.

If you manage coding agents across multiple machines and want to keep API keys out of your chat transcripts, llm-keys-ui is worth a look. It's a lightweight addition to an existing `llm`-based setup, and the phone-friendly web UI fits the increasingly common pattern of steering agents entirely from a mobile device.