Jesse.Weightless inference.

One base URL. Your key.

Sign in on your account page for 60 free exchanges, create a key, and send a chat completion. Anything that speaks the OpenAI API works unchanged.

curl https://jesse.my/api/v1/chat/completions \
  -H "Authorization: Bearer $JESSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jesse-prod",
    "messages": [{"role": "user", "content": "What is 17 * 23?"}]
  }'

from openai import OpenAI

client = OpenAI(base_url="https://jesse.my/api/v1", api_key=JESSE_API_KEY)

reply = client.chat.completions.create(
    model="jesse-prod",
    messages=[{"role": "user", "content": "What is 17 * 23?"}],
)
print(reply.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://jesse.my/api/v1", apiKey: process.env.JESSE_API_KEY });

const reply = await client.chat.completions.create({
  model: "jesse-prod",
  messages: [{ role: "user", content: "What is 17 * 23?" }],
});
console.log(reply.choices[0].message.content);

Worked out, checked, or quoted.

Jesse is not a language model. Each request goes to the solver that can answer it: exact arithmetic, a unit table, a program Jesse runs against tests, a reference page. Every reply says which solver answered and whether the answer was checked. When no solver can answer, Jesse says so and explains why instead of guessing.

Jesse can't yet write stories or essays, give opinions, work conditional probability, or act on your behalf. How to ask Jesse lists 100+ phrasings that are checked against the live service with every release.

Every answer comes with a receipt

The response is a standard chat completion plus a jesse object that says how the answer was produced. Check it in code: for example, trust verified: true answers and show the others with their source. A streamed reply (stream: true) carries the same jesse object on its last chunk, the one with finish_reason.

{
  "id": "chatcmpl-jesse-…",
  "object": "chat.completion",
  "model": "jesse-prod",
  "choices": [{ "index": 0, "finish_reason": "stop",
    "message": { "role": "assistant", "content": "17 * 23 = 391." } }],
  "usage": { "prompt_tokens": 12, "completion_tokens": 4, "total_tokens": 16 },
  "jesse": {
    "solver": "compute",
    "verified": true,
    "checked": "computed",
    "tried": ["compute:answered"]
  }
}

One engine, three behaviours.

Every model runs the same solvers. They differ in what they remember. GET /api/v1/models lists them.

Open beta: be careful with confidential or export-controlled material. Your data is partitioned by API key and is never used for other customers' answers.

Jesse in Claude Code and Codex.

Jesse can be the model inside Claude Code and Codex. She drives the shell herself: she reads the project, runs your tests, writes a program she has already checked, compares its SHA-256, runs the tests again, and says done only when they exit 0. No other model is involved. Her progress shows natively: Claude Code's task list and Codex's plan tick off each step as she goes.

export ANTHROPIC_BASE_URL=https://jesse.my/api
export ANTHROPIC_AUTH_TOKEN=$JESSE_API_KEY
export ANTHROPIC_MODEL=jesse-next
export ANTHROPIC_SMALL_FAST_MODEL=jesse-next

model_provider = "jesse"
model = "jesse-next"

[model_providers.jesse]
name = "Jesse"
base_url = "https://jesse.my/api/v1"
env_key = "JESSE_API_KEY"
wire_api = "responses"

[tools.update_plan]
enabled = true

# optional, removes Codex's "model metadata not found" warning:
# curl -o ~/.codex/jesse-models.json https://jesse.my/codex/jesse-models.json
# model_catalog_json = "/Users/you/.codex/jesse-models.json"

How to ask

The tests in test_rev.py fail. Write a Python function reverse_string(s) that reverses a string, in rev.py. Then run `python3 -m pytest -q`.

Name the file, and end with the command that checks the work: pytest, python3 -m unittest, npm test, cargo test, go test or make test. Each turn of the agent is one request on your key, usually seven or eight for a task.

Today she writes new functions and small programs that her solvers can check, Python first. She does not edit existing code yet. When she cannot check a program she says so and changes nothing. With tools on the turn, the harness's system prompt is not used as task text.

One plan.

Endpoints.

Base URL https://jesse.my/api/v1. Send your key as Authorization: Bearer jesse_live_… (or x-api-key). Never put it in a URL.

Chat

Memory and feedback

Documents

Web

QR codes

In a chat, send the image as a message part, {"type": "image_url", "image_url": {"url": "data:image/png;base64,…"}} (Anthropic: an image block; Responses: input_image), and ask what it says, or ask for a code in words ("make a QR code for …", "a Wi-Fi QR code for network … password …"). The reply carries the result in jesse.qr.

# Make a code and save its PNG
curl https://jesse.my/api/v1/qr/encode \
  -H "Authorization: Bearer $JESSE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "https://jesse.my", "ecc": "Q"}' | jq -r .png_base64 | base64 -d > qr.png

# Read every code in a photo or screenshot
curl https://jesse.my/api/v1/qr/decode \
  -H "Authorization: Bearer $JESSE_API_KEY" \
  -H "Content-Type: image/jpeg" \
  --data-binary @photo.jpg

Streaming

With "stream": true the reply arrives as OpenAI server-sent events: chat.completion.chunk objects, then data: [DONE]. The OpenAI SDKs handle this with stream=True.

Errors

Errors use the OpenAI shape: {"error": {"message", "type", "param", "code"}}. The message always says what to do next.

If something fails inside Jesse, you still get a 200 with a reply that says so, never a bare 500. Check jesse.solver in code rather than relying on the status alone.