// open-weights inference for your coding agent

Your agent.
Your inference.
Your machine.

Keep the coding agent you already use — Claude Code, OpenCode — and run it on open-weights models you control. Private by default, no vendor lock-in, no wallet. We don't replace your agent; we just swap the backend. One command.

curl -fsSL https://raw.githubusercontent.com/Libertai/libertai-cli/master/packaging/install.sh | sh curl -fsSL https://apt.libertai.io/install.sh | sudo bash brew install Libertai/tap/libertai cargo install --git https://github.com/Libertai/libertai-cli --branch master --locked

Read the docs See how it works

Private by default
Open weights
No lock-in
<60s first run

~/code/payments — libertai private · open weights

$ libertai login

✓ Signed in · no wallet needed · free trial credits active

$ libertai claude "add retry + backoff to the Stripe client"

claude code · backend: libertai · model: qwen3.6-35b-a3b · mode: plan

● read src/payments/stripe.ts

● read src/lib/http.ts

I'll wrap the client in an exponential-backoff retry (3 attempts, jittered) and surface a typed RetryError. Here's the diff:

+ for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {

+ try { return await this.request(req); }

+ catch (e) { await sleep(backoff(attempt)); }

Apply changes to stripe.ts? ❯ yesnoplan

// the wedge

The only end-to-end private, open backend for your coding agent.

Cline and Aider make you bring your own key to someone else's cloud. Claude Code's backend is proprietary and centralized. LibertAI is the one stack where the inference is open, private by default, and lock-in-free — keep the agent you already use, run it on your machine, one command away.

Private by default

Prompts, code and context run against inference you control — not harvested to train someone else's model. Privacy isn't a setting you opt into; it's the default path.

no telemetry on your code

Open weights

Qwen, DeepSeek, Gemma and other open-weights models — inspectable, reproducible, swappable. No black box, no silent model swaps under you mid-project.

inspect · pin · swap

No lock-in

Point the same agent at LibertAI, OpenAI, Anthropic, OpenRouter, or your own endpoint. OpenAI-compatible all the way down. Leave whenever you want — your workflow comes with you.

bring any endpoint

One command

A single static binary. Install, log in, and you're in an agent session in under a minute — no Node runtime, no Docker, no wallet, no crypto.

<60s to first run

// your agent, our backend

Already use Claude Code?
Keep using it.

libertai claude launches your Claude Code with LibertAI wired in as the backend — open-weights models, confidential inference, no lock-in. Your slash commands, plan mode, permission tiers, hooks, and skills all keep working exactly as they do today. Nothing to relearn — same Claude Code, open and private backend, in one command.

Plan / Accept-Edits / Auto permission tiers
MCP servers — stdio, HTTP & SSE
Claude-Code-format hooks, skills & custom commands
Headless --print mode for scripts & CI

/ type a command… ⌘K

/plan plan-first mode, Shift+Tab to cycle
/review review the working diff
/fork branch the session from any message
/memory persistent project memory
/init generate project guide
/security-review audit pending changes
/model swap the active model
/compact compress the context
/resume reattach a saved session

+ 45 more · 55+ built-in · your .claude/commands/ work too

// the other headline launcher

Prefer OpenCode?
Same deal.

libertai opencode does for OpenCode what libertai claude does for Claude Code: launches the agent you already use with LibertAI wired in as the backend — open-weights models, confidential inference, no lock-in. Four things happen on launch:

01

A provider, written for you

OpenCode ignores OPENAI_* env vars for custom providers — it wants a provider entry in ~/.config/opencode/opencode.json. libertai opencode writes one idempotently: a provider.libertai block pointing at api.libertai.io/v1, using opencode's env-reference syntax apiKey: "{env:LIBERTAI_API_KEY}" — your key never gets written to the file.
02

Your key, injected at launch

On every launch it exports LIBERTAI_API_KEY (and the usual OPENAI_BASE_URL / ANTHROPIC_BASE_URL set) from your saved config, so the provider entry resolves your key at runtime. Run libertai login once; never paste it into opencode.
03

Models from your config

The provider's model map is built from your config — your default_chat_model, default_code_model, and the three launcher tiers — plus the live /v1/models catalog. Nothing to hand-list. If you don't pass --model, it launches with libertai/<default_code_model>.
04

Nothing clobbered

It's idempotent and non-destructive: your other providers and top-level keys in opencode.json are preserved, and the bundled image/search skills land in ~/.claude/skills/ without overwriting anything you've customized.

$ libertai opencode $ libertai opencode --model libertai/glm-5.2

{
  "provider": {
    "libertai": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "LibertAI",
      "options": {
        "baseURL": "https://api.libertai.io/v1",
        "apiKey": "{env:LIBERTAI_API_KEY}"
      },
      "models": { "glm-5.2": { "name": "glm-5.2" }, "…": { "name": "…" } }
    }
  }
}

// two ways in

No wrong door.

Point the agent you already love — Claude Code, OpenCode — at LibertAI, or use the bundled utilities. Either way it's one login and an OpenAI-compatible endpoint — no rewiring your setup.

utilities

Bundled utilities & MCP

One binary — ask, chat, image, search, and an MCP server for any agent.

$ libertai chat streaming REPL with history
$ libertai ask one-shot completion
$ libertai image generate & save images
$ libertai search web search, news & images
$ libertai mcp MCP server — private search & fetch for any agent

bring your own

Launch any agent on LibertAI

Pre-wired presets inject LibertAI credentials and launch the tool you already use.

Claude Code libertai claude
OpenCode libertai opencode
Aider libertai aider
Claw Code libertai claw
Hermes libertai hermes

…or point any OpenAI-compatible tool — Cline, Continue, Roo — at api.libertai.io.

// open weights

Models you can read, pin, and replace.

Every model is open-weights and OpenAI-compatible, with a -thinking variant when you want longer reasoning. Pin a version so it never changes under you — or set default_code_model to anything you like, including your own endpoint.

Code

Fast, tool-fluent models tuned for agentic editing.

qwen3.6-35b-a3b
deepseek-v4-flash

Reason & chat

Large open-weights models for planning and deep reasoning.

qwen3.5-122b-a10b
gemma-4-31b-it

Image

Generate assets right from the CLI or an agent skill.

z-image-turbo

Your own

Already paying for a frontier API, or self-hosting?

OpenAI
Anthropic
OpenRouter
localhost:*

// coming soon

The same engine, hand-it-to-anyone GUI.

LibertAI Desktop wraps the very same agent loop in a polished three-pillar workspace — built on Tauri, private by default. The CLI for your terminal; the Desktop for everyone else on your team.

LibertAI Desktop

Code

Multi-pane agent sessions with a slide-in diff editor and inline approvals.

Agent

Long-running, plan-driven agents working across your repos and tasks.

Chat

Quick, project-aware conversations on private open-weights models.

Get the Desktop beta first.

One email when it lands. No spam, no token, unsubscribe anytime.

Under the hood, inference runs on Aleph's decentralized network — that's how we keep it private and unstoppable. But you never touch a wallet or a token to use it: sign in with email, get free trial credits, top up with a card. The decentralization is ours to operate, not your homework.

// ready in under a minute

Liberate your coding agent.

Install the binary, log in, and run Claude Code or OpenCode on private open-weights inference. One command.

View on GitHub free trial credits · no wallet · no crypto

Your agent. Your inference. Your machine.

The only end-to-end private, open backend for your coding agent.

Private by default

Open weights

No lock-in

One command

Already use Claude Code?Keep using it.

Prefer OpenCode?Same deal.

A provider, written for you

Your key, injected at launch

Models from your config

Nothing clobbered