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. Use the OpenAI-compatible endpoint below, or choose your app in the client setup section.

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.

Use Jesse in your tools.

Start with your Jesse key. Choose your app, merge its settings, and select jesse as the model. The setup guide covers 33 clients, including Factory.ai and Oh My Pi.

Keep your key in your app's credential store or launch environment. Merge the setup into existing settings. MCP connects Jesse as a tool inside your assistant; it does not change that assistant's model. Factory's hosted web and mobile apps do not load local custom-model settings.

Build with the full API

Go beyond chat with streaming, answer receipts, per-key memory, documents, versioned tool packs, resumable agent phases and result checks. The SDK, MCP tool list and OpenAPI specification share one maintained contract.

Developer guidance · OpenAPI specification · API capabilities · Endpoint reference

Setup recipes are prepared; full sessions in every listed app have not been verified. Each guide shows its status. Jesse currently checks new functions and small programs; existing-code editing is not established.

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

Agent graphs

Jesse can run as one node of an agent graph (LangGraph or similar). She proposes calls and checks results, and your graph runs them. She never calls a tool, a hook or a URL herself.

One graph step per turn: the first turn of a task (a pack request, or "phase": true) returns jesse.phase.id. Send {"phase": {"id": …}, "messages": [only the new ones]} to continue. Your node's system prompt is not read as the task, only what it allows or forbids. With "pipeline": "name", each turn proposes the next step of the pack's pipeline. A json_schema reply that does not fit its schema (inline, or "schema_id": "pack#id") is never sent as almost-JSON: content is null, refusal says why, and the receipt has solver: "help", checked: "schema".

# Store a pack once
curl https://jesse.my/api/v1/packs -H "Authorization: Bearer $JESSE_API_KEY" -H "Content-Type: application/json" -d '{
  "name": "calendar",
  "tools": [{"name": "calendar.free_slots", "commit": false,
             "description": "Find free slots between two times for a meeting of a given length.",
             "parameters": {"type": "object", "additionalProperties": false, "required": ["start", "end", "minutes"],
               "properties": {"start": {"type": "string", "format": "date-time"},
                              "end": {"type": "string", "format": "date-time"},
                              "minutes": {"type": "integer"}}}}]}'

# Then call it by name: no tools array
curl https://jesse.my/api/v1/chat/completions -H "Authorization: Bearer $JESSE_API_KEY" -H "Content-Type: application/json" -d '{
  "model": "jesse", "pack": "calendar",
  "messages": [{"role": "user", "content": "Find a free 30 minute slot from 2026-10-01T09:00:00Z to 2026-10-01T17:00:00Z."}]}'
# -> tool_calls, and jesse: {"solver": "tool", "verified": false, "call": {"name": "calendar.free_slots", "args": {…}, "commit": false, …}, "phase": {"id": "ph_…", …}}

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.