OpenAI-compatible apps

Private Inference speaks the OpenAI Chat Completions format, so most tools that accept a custom OpenAI base URL work with zero code changes — set three values and you’re private by default across every model.

Base URL:  https://api.t2000.ai/v1
API key:   sk-…            (create one at agents.t2000.ai/manage → API keys)
Model:     t2000/auto      (routes each step; billed at the model that served)

Get a free key at agents.t2000.ai/manage (sign in with Google — same Passport + balance as Audric). Every account gets a free daily allowance on moonshotai/kimi-k2.7-code; paid models are metered per token and fail closed at a $0 balance. Browse models + pricing any time with GET /v1/models (public, no key).

One command: `t2 connect`

If you have the t2 CLI installed, t2 connect <client> writes the provider config for you — paste the key once and it’s saved for later connects:

npm install -g @t2000/cli
t2 connect t2code --key sk-...     # t2 code (the t2000 coding agent)
t2 connect claude-code             # Claude Code, via claude-code-router
t2 connect grok                    # Grok Build (BYOK custom-model block)
t2 connect aider                   # also: continue · codex · cline · cursor

--print shows what would be written without touching anything. Clients whose config is GUI-managed (Cline, Cursor) get a paste-ready walkthrough instead of a file write. The manual setup for every client follows below.

Which model id to set

t2000/auto — the default for coding agents. Routine steps run on a cheap open model; long-context, planning, and retry-after-failure steps escalate to a frontier one. You pay the price of the model that served (x-t2000-served-model header names it).
t2000/auto-open — the same router, open models only. Your prompts never reach a closed-model provider.
A pinned id — any id from GET /v1/models, e.g. phala/glm-5.2 for hardware-verified confidential inference.

Environment variables (the universal swap)

Almost every OpenAI client reads these two variables. Set them once and the tool is repointed at t2000:

export OPENAI_BASE_URL="https://api.t2000.ai/v1"
export OPENAI_API_KEY="sk-..."

OpenAI SDK

from openai import OpenAI

client = OpenAI(
    base_url="https://api.t2000.ai/v1",
    api_key="sk-...",
)

resp = client.chat.completions.create(
    model="zai/glm-5.2",
    messages=[{"role": "user", "content": "Hello from t2000"}],
)
print(resp.choices[0].message.content)

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.t2000.ai/v1",
  apiKey: process.env.T2000_API_KEY,
});

const resp = await client.chat.completions.create({
  model: "zai/glm-5.2",
  messages: [{ role: "user", content: "Hello from t2000" }],
});
console.log(resp.choices[0].message.content);

Cursor

Cursor can route its chat models through any OpenAI-compatible endpoint:

Settings → Models → API Keys → OpenAI API Key.
Paste your sk-… key, expand Override OpenAI Base URL, and set it to https://api.t2000.ai/v1.
Under Models, add t2000/auto (plus any pinned ids you want), then Verify.

Cursor’s agentic features are tuned for specific frontier models. For a drop-in private chat model, add t2000/auto (or a pinned id like anthropic/claude-sonnet-5) and select it in the chat model picker.

Coding CLIs (custom OpenAI-compatible provider)

Most open-source coding CLIs take a custom OpenAI-compatible provider — give it the base URL, your key, and t2000/auto as the model. Tool calls (file edits, shell) pass through /v1 natively — the router escalates hard steps, and the free daily allowance applies when the served model is kimi-k2.7-code.

OpenAI Codex CLI

Add t2000 as a model provider in ~/.codex/config.toml:

[model_providers.t2000]
name = "t2000"
base_url = "https://api.t2000.ai/v1"
env_key = "T2000_API_KEY"

[profiles.t2000]
model = "t2000/auto"
model_provider = "t2000"

Then run with the profile (export T2000_API_KEY=sk-… first):

codex --profile t2000

Grok Build

xAI’s Grok Build TUI takes BYOK custom models in ~/.grok/config.toml — the same pattern (t2 connect grok writes this for you):

[model.t2000]
model = "t2000/auto"
base_url = "https://api.t2000.ai/v1"
name = "t2000 auto (Private Inference)"
env_key = "T2000_API_KEY"
api_backend = "chat_completions"

[models]
default = "t2000"

Then (export T2000_API_KEY=sk-… first):

grok -m t2000     # or /model t2000 in the TUI

Note the trade-off plainly: routing Grok Build’s inference through us covers the model side, but the binary itself is xAI’s — auto-updating, closed development (no external contributions). If the client’s own wire behavior matters to you, that’s what t2 code is for.

Vercel AI SDK

Use the OpenAI-compatible provider:

import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
import { generateText } from "ai";

const t2000 = createOpenAICompatible({
  name: "t2000",
  baseURL: "https://api.t2000.ai/v1",
  apiKey: process.env.T2000_API_KEY,
});

const { text } = await generateText({
  model: t2000("zai/glm-5.2"),
  prompt: "Hello from t2000",
});

LangChain

from langchain_openai import ChatOpenAI

llm = ChatOpenAI(
    base_url="https://api.t2000.ai/v1",
    api_key="sk-...",
    model="zai/glm-5.2",
)
print(llm.invoke("Hello from t2000").content)

Other OpenAI-compatible clients

The same base URL + key works in any tool that targets OpenAI Chat Completions — coding agents like Kilo Code, Cline, Continue, and Aider (--openai-api-base), frameworks like LiteLLM (openai/<model>) and LlamaIndex, and most “bring your own OpenAI key” apps and agents. If a tool has an “OpenAI base URL” or “custom endpoint” field, point it at https://api.t2000.ai/v1, set the model to t2000/auto (or pick a pinned id from GET /v1/models), and every call is private by default — billed from your one balance.

Anthropic-format tools (Claude Code)

Tools that speak the Anthropic Messages format (/v1/messages) — such as Claude Code — don’t talk to an OpenAI Chat Completions endpoint directly. Two options:

A translation proxy today — run LiteLLM (or a similar Anthropic↔OpenAI shim) pointed at https://api.t2000.ai/v1, and set the tool’s ANTHROPIC_BASE_URL to the proxy.
Native /v1/messages is on the roadmap (the additional-endpoints item) — when it ships, Anthropic-format tools will work with the base-URL swap alone.

Good to know

Streaming works everywhere SSE does — set stream: true; pass stream_options: { include_usage: true } for a final usage chunk.
Model IDs are namespaced (provider/model); the live list is whatever GET /v1/models returns, each tagged private or confidential.
Keys are secrets — keep them server-side, one per app/environment so you can revoke independently. Don’t ship a raw key in a browser bundle.
Spend is bounded by your balance (and your auto-recharge threshold, if enabled). Each key is capped at 120 requests/minute.

See the Private Inference reference for the full endpoint, model, pricing, privacy, and error details.

Get started

Identity

Wallet

Payments

Private Inference

Confidential AI

Reference

API reference

OpenAI-compatible apps

One command: `t2 connect`

Which model id to set

Environment variables (the universal swap)

OpenAI SDK

Cursor

Coding CLIs (custom OpenAI-compatible provider)

OpenAI Codex CLI

Grok Build

Vercel AI SDK

LangChain

Other OpenAI-compatible clients

Anthropic-format tools (Claude Code)

Good to know

​One command: t2 connect

​Which model id to set

​Environment variables (the universal swap)

​OpenAI SDK

​Cursor

​Coding CLIs (custom OpenAI-compatible provider)

​OpenAI Codex CLI

​Grok Build

​Vercel AI SDK

​LangChain

​Other OpenAI-compatible clients

​Anthropic-format tools (Claude Code)

​Good to know

One command: `t2 connect`

Which model id to set

Environment variables (the universal swap)

OpenAI SDK

Cursor

Coding CLIs (custom OpenAI-compatible provider)

OpenAI Codex CLI

Grok Build

Vercel AI SDK

LangChain

Other OpenAI-compatible clients

Anthropic-format tools (Claude Code)

Good to know