# LLM Check — full page content

Source: https://llm-check.dirtyrabbit.work/
Published: 2026-08-12 · Last updated: 2026-09-21

## What is LLM Check?

LLM Check is a free, browser-based test bench for LLM models and new AI features. Bring your own API key, point the page at an endpoint, and smoke-test streaming chat, raw protocol behaviour, parameters, model comparisons and specialised modules such as TypeSafe Jev.

LLM Check is a browser front end for LLM APIs. It exists so you can check what a model actually does — which protocol it answers on, what it streams back, how parameters change the output, how long the first token takes — without installing an SDK, writing a script or running a local server.

The page is deliberately thin. It hosts no models and sells no tokens. A Cloudflare Worker relays each call to the endpoint you configure, authenticated with the key you provide, so nothing is stored on the server side. Configuration is provider-based: pick the built-in OpenCode Go preset, add a custom OpenAI-compatible base URL, or use the TypeSafe preset for Jev.

New capabilities are added as small modules. A module owns its own form, request and rendering, so the test bench grows without rewriting the core.

![LLM Check running in a browser: the provider, key, model and parameter sidebar on the left and the chat panel with a message box on the right](https://llm-check.dirtyrabbit.work/app-screenshot.png)

*The test bench: configure a provider, model and key in the sidebar, then work in the Chat, Compare or Jev module.*

LLM Check is an independent project, published and maintained by its authors. It has no account system, no paid tier and no third-party analytics; questions and bug reports go to the contact address at the end of this page.

## Key features

At a glance: 3 debug modules ship today, Compare runs up to 8 models in parallel, and Auto routing tries 2 OpenAI-style protocols before falling back to Anthropic Messages.

- **Bring your own endpoint.** Any OpenAI-compatible base URL works, including proxies, gateways and self-hosted servers; OpenCode Go and TypeSafe ship as presets.
- **Protocol auto-detection.** On Auto the page tries `/chat/completions`, then `/responses`, then `/messages` — OpenAI protocols first, Anthropic last — and remembers the protocol that worked for that model so it is tried first next time.
- **Parameter panel.** Set `temperature`, `top_p`, `max_tokens`, switch streaming on or off, and merge extra request fields as JSON.
- **Inspector.** Review the outgoing URL, masked request headers, request body, raw stream events, status code, time to first byte, total latency and token usage.
- **Streaming and cancellation.** Answers render token by token and can be aborted mid-stream.
- **Model comparison.** Send one prompt to several models in parallel and compare answers, latency and usage side by side.
- **Attachments.** Images go to the model as image input; text and source files are inlined into the prompt; other binary files are passed as references. Images can also be pasted from the clipboard.
- **No account.** There is nothing to register and no login step. Your API key is the only credential.

## Modules

Each tab in the test bench is a module with its own form and result rendering.

- **Chat.** Conversational testing against the configured endpoint, with streaming, cancellation, attachments, follow-up context and parameter overrides.
- **Compare.** The same prompt sent to up to eight models in parallel, with per-model protocol, latency, token usage and upstream errors.
- **Jev (System One).** The TypeSafe decision endpoint: send a state plus typed questions and read back choices, scores and yes/no probabilities with confidence, without any text generation.

![Compare module: a list of models to tick, a field for extra model ids, one shared prompt box and a Run comparison button](https://llm-check.dirtyrabbit.work/app-screenshot-compare.png)

*Compare sends one prompt to every ticked model at once and reports each answer with its protocol, latency and token usage.*

![Jev module: a state text box plus a choice question, a score question and a noul question with their criteria](https://llm-check.dirtyrabbit.work/app-screenshot-jev.png)

*The Jev module builds a state plus choice, score and noul questions and renders the typed answers with probabilities instead of prose.*

| Module | Shape of the call | What it renders |
|--------|-------------------|-----------------|
| Chat | Streaming chat completion over SSE | Reply text, reasoning, usage and latency |
| Compare | Non-streaming, one prompt per model | One column per model with answer, protocol, timing and errors |
| Jev (System One) | Single JSON request/response | Choice, score and noul answers with probabilities and confidence |

Adding another module means adding one file that mounts into the module host and registering it; the shared request, storage and inspector layers are reused as-is.

## How to use LLM Check

1. Open https://llm-check.dirtyrabbit.work/ in a current desktop or mobile browser.
2. Choose a **Provider** in the sidebar and paste the matching API key. For a custom endpoint, edit the base URL and the auth header style first.
3. Confirm the key. When the endpoint exposes a model list, it loads right away; otherwise type a model id manually.
4. Leave the **Protocol** selector on Auto unless you want to pin a specific endpoint such as `/messages`.
5. Send a message and read the answer as it streams in. Press Cancel to stop early.
6. Open the **Inspector** to check the raw exchange and timings, or switch to **Compare** to run the same prompt against several models.

## Providers and protocols

- **OpenCode Go.** The gateway at `https://opencode.ai/zen/go/v1` serves models over three protocols — OpenAI-compatible chat completions, OpenAI responses and Anthropic messages. On Auto the page tries them in that order and remembers the working one per model. Requests carry an `x-opencode-session` header so the gateway can group a browser session.
- **Custom endpoints.** Any HTTPS base URL that speaks OpenAI chat completions, OpenAI responses or Anthropic messages. Both `Authorization: Bearer` and `x-api-key` authentication styles are supported.
- **TypeSafe.** The System One endpoint at `https://api.typesafe.ai/v1/systemone` powers the Jev module. It is a single request/response call, never a stream.

| Provider | Base URL | Auth header | Protocols tried |
|----------|----------|-------------|-----------------|
| OpenCode Go | `https://opencode.ai/zen/go/v1` | `Authorization: Bearer` and `x-api-key` | `/chat/completions` → `/responses` → `/messages` |
| Custom endpoint | any HTTPS base URL you supply | `Authorization: Bearer` or `x-api-key` | `/chat/completions` → `/responses` → `/messages` |
| TypeSafe (Jev) | `https://api.typesafe.ai/v1` | `Authorization: Bearer` | `/systemone` only, single request/response |

![Diagram of the Auto protocol routing order: /chat/completions first, then /responses, then /messages](https://llm-check.dirtyrabbit.work/protocol-routing.png)

*Auto routing: the page stops at the first endpoint that answers and remembers it for that model.*

Upstream errors are translated into readable messages: a model that is unavailable, a region restriction, an authentication failure, a rate limit, or a protocol mismatch all surface with a different explanation.

## Cost

LLM Check itself is free. There is no paid tier, no account and no per-message charge on this side: you can send 1 request or 1,000 and the site still costs you nothing.

The only cost is what your own provider bills for the calls you make with your key. The page holds no model access of its own and resells no tokens, so usage is billed directly by the endpoint you configure.

## Examples

- **Find which protocol a model answers on.** Leave the selector on Auto, send one message, then open the Inspector: a model served on `/responses` shows a failed `/chat/completions` attempt followed by a successful `/responses` call, and the working protocol is remembered for next time.
- **Compare two models on the same prompt.** Open Compare, tick two or more models and send the prompt once; each column shows the answer, protocol, latency and token usage.
- **Check a structured decision call.** The Jev module sends a state plus choice, score and noul questions to the TypeSafe System One endpoint and renders the typed answers with their probabilities and confidence.

## API key and privacy

- Provider keys are entered by you and kept in `localStorage` under the `llm_check.v1.settings` key. Keys saved before the rename are migrated automatically.
- The Worker forwards a key only to the endpoint you configured, as you configured it (`Authorization: Bearer`, `x-api-key`, or both). It does not log keys, store them, or share them with any other service.
- Conversations, attachments and inspection records live only in the browser tab. Reloading or closing the page discards them.
- The Inspector masks API keys in the recorded request headers.
- To remove stored keys, clear site data for this origin in your browser settings.
- Your key remains subject to the terms and usage limits of the provider you configured.

## Frequently asked questions

**What is LLM Check?**
A free browser test bench for LLM APIs. You bring your own key, point the page at an endpoint, and then check models and new AI features: streaming chat, parameter overrides, raw stream inspection, model comparison and specialised modules such as the TypeSafe Jev decision form.

**Which providers can I test?**
Any endpoint that accepts an OpenAI-compatible chat completions or responses request, plus Anthropic Messages style endpoints and the OpenCode Go gateway, which is included as a preset. A TypeSafe preset covers the System One endpoint used by Jev.

**Do I need an API key?**
Yes. The test bench holds no model access of its own. Every request is authenticated with the key you enter, so without a valid key the model list stays empty and requests are rejected upstream.

**Where is my API key stored?**
In your browser's `localStorage` on this origin, so you do not have to retype it on your next visit. When you send a request, the key travels to this site's Worker, which immediately forwards it to the upstream endpoint you configured over HTTPS. It is not written to a database or a log on the server side.

**Why does a model fail with an internal server error?**
Some gateways serve different models on different protocol endpoints, for example `/chat/completions`, `/responses` or `/messages`. On Auto the page tries them in that order — OpenAI protocols first, Anthropic last — and remembers which protocol worked for that model, trying it first on later requests. You can also pin a protocol manually.

**Can I see the raw request and response?**
Yes. The Inspector records the outgoing URL, request headers with keys masked, the request body, the raw response or stream events, the status code, time to first byte, total latency and token usage for every call.

**What is the Jev module?**
Jev is TypeSafe's System One model. It does not generate text; it evaluates a state against typed questions and returns structured answers with probabilities and confidence. The Jev module sends a state plus choice, score and noul questions and renders the typed answers, probability bars and usage.

**Can I compare several models at once?**
Yes. The Compare module sends one prompt to up to eight models in parallel and shows each answer with its protocol, latency, token usage and any upstream error.

**Is my conversation saved anywhere?**
No. Messages live in the browser tab for the current session and there is no server-side conversation storage. Reloading the page starts a fresh conversation.

**Is the page free?**
Yes. Using the page is free and requires no registration. You still need your own API key, and any charges that key incurs are billed by your provider.

## Sources and references

Background used when documenting the gateway behaviour and the structured data on this page:

- [OpenCode Go gateway documentation](https://opencode.ai/docs/go/) — endpoints, model availability and error signatures.
- [Anthropic Messages API](https://docs.anthropic.com/en/api/messages) — the `/messages` request and streaming event shape.
- [Cloudflare Workers documentation](https://developers.cloudflare.com/workers/) — the runtime and static asset hosting behind this site.
- [schema.org WebApplication](https://schema.org/WebApplication) — the structured data type used for the test bench.
- [TypeSafe](https://typesafe.ai/) — the vendor behind the System One decision model used by the Jev module.

## Contact

Questions and bug reports: zweizhao@foxmail.com