The Tartarus AI API

Why the interface is OpenAI-shaped

The OpenAI chat completions format became the de facto interface for language models, and nearly every client library, editor integration, agent framework and evaluation harness targets it. Implementing it rather than inventing a new one means none of that has to be rewritten.

It also means you are not locked in. Work that runs through a standard interface can be pointed somewhere else with a configuration change, which is the correct amount of commitment to ask of someone evaluating a service.

Authentication

Tokens are minted in the dashboard under Account, CLI access. Pro allows ten active tokens; revoking one takes effect immediately and does not affect the others.

A token outlives the plan that created it, so plan access is rechecked on every request rather than only at mint time. If a plan lapses or is downgraded below the tier that includes API access, existing tokens stop working the same minute.

export OPENAI_BASE_URL=https://api.tartarusai.chat/api/v1
export OPENAI_API_KEY=<your token>

Endpoints

Two, which is the whole surface.

Model ids are the public keys fast, deep and coder. There are no version suffixes to pin: the ids are stable and the weights behind them are ours to maintain.

A request

Set stream to true for server-sent events, or leave it out for a single JSON response. Both follow the OpenAI response shape.

curl https://api.tartarusai.chat/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENAI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "coder",
    "stream": true,
    "messages": [
      { "role": "user", "content": "Refactor this to remove the nested callbacks." }
    ]
  }'

With an existing SDK

Nothing about the client changes. The official OpenAI libraries read the same two environment variables, so an existing script usually needs no code edit at all.

from openai import OpenAI

client = OpenAI()   # reads OPENAI_BASE_URL and OPENAI_API_KEY

stream = client.chat.completions.create(
    model="deep",
    messages=[{"role": "user", "content": "Plan the migration in stages."}],
    stream=True,
)

for chunk in stream:
    print(chunk.choices[0].delta.content or "", end="")

Limits, and how they differ from chat

API traffic draws on the same weekly and session allowances as the browser. Two limits behave differently over the API, deliberately.

The per-response output cap is larger, because an agent writing a file legitimately needs more room than a chat turn: 24K tokens over the API against 8K in chat.

A request that exceeds the plan's context ceiling is rejected rather than trimmed. The web interface silently drops older turns to make a request fit, which is right for a person and wrong for a program: a client that can compact and retry should be told, not quietly given a different conversation than it sent.

Errors worth handling

The ones that are not simply a bad request.

401

The token is revoked or was never valid. Mint a new one under Account, CLI access.

402

There is no active plan on the account, or the active plan does not include API access. Minting a new token will not help until the plan does.

413

The request exceeds the plan's context ceiling. Compact the conversation and retry — this is the case the web interface handles by trimming.

429

Either the per-minute rate limit or a token allowance. Rate limiting clears in seconds; a spent weekly allowance clears when the week resets, and a spent session allowance when the five-hour window rolls. The error body distinguishes them.

Where it differs from the OpenAI API

Compatibility claims are worth more when the exceptions are published.

• The model catalogue is fast, deep and coder. Passing an OpenAI model name is an error rather than a silent substitution.
• The plan's output cap is authoritative. A max_tokens larger than your plan allows is clamped rather than honoured.
• Only chat completions and model listing are implemented. There is no embeddings, images, audio, files or assistants surface.
• Oversized requests return 413 rather than being truncated.