Integrations

Before you start

Copy your API key from Account. Paid models need credit or holder free tokens on that model, from the free try or a plan (see Holder benefits). Set the key in your shell before running the command-line examples; replace the placeholder with your own key.

export SEVREN_API_KEY="YOUR_SEVREN_API_KEY"

Use sevren or sevren-lite-27b as the model ID. Copy the exact ID from Models, and read current limits and prices there. Keep API keys out of Git and shared configuration files.

OpenAI Chat Completions uses https://api.example.com/v1. Claude Code uses the Anthropic-compatible base URL https://api.example.com, without /v1. Codex requires a Responses-compatible endpoint.

Chat Completions accepts text, streaming and function tools, so agents can use their native tools. The Messages API accepts text, tool use and streaming. Images, structured output and the legacy functions fields are not supported on either route; a client that sends them receives 400. See Chat completions and Anthropic API for the accepted request fields.

OpenCode

Add this to opencode.json, merging it with your existing settings. The provider uses Chat Completions and reads your key from SEVREN_API_KEY. Sharing is disabled, and the example denies every tool permission; change permission to let the agent use its tools.

{
  "$schema": "https://opencode.ai/config.json",
  "model": "sevren/sevren",
  "small_model": "sevren/sevren-lite-27b",
  "share": "disabled",
  "permission": {
    "*": "deny"
  },
  "provider": {
    "sevren": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Sevren",
      "options": {
        "baseURL": "https://api.example.com/v1",
        "apiKey": "{env:SEVREN_API_KEY}"
      },
      "models": {
        "sevren": {
          "name": "Sevren"
        },
        "sevren-lite-27b": {
          "name": "Sevren Lite 27B"
        }
      }
    }
  }
}

Start OpenCode from that shell. Use /models to choose sevren/sevren or sevren/sevren-lite-27b. Sevren supports tool calls, so the agent's tools work once its permissions allow them. OpenCode provider documentation.

Claude Code

Claude Code connects directly to Sevren' Anthropic-compatible Messages API, POST /v1/messages. An OpenAI-to-Anthropic proxy is not required. The endpoint is documented on Anthropic API.

export ANTHROPIC_BASE_URL="https://api.example.com"
export ANTHROPIC_AUTH_TOKEN="$SEVREN_API_KEY"
export ANTHROPIC_MODEL="sevren"
export ANTHROPIC_DEFAULT_OPUS_MODEL="sevren"
export ANTHROPIC_DEFAULT_SONNET_MODEL="sevren"
export ANTHROPIC_DEFAULT_HAIKU_MODEL="sevren-lite-27b"
export CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1

claude

The bearer token authenticates to Sevren. ANTHROPIC_MODEL selects Large for the main session; Opus and Sonnet aliases select Large; Haiku background tasks select Small. Without these variables Claude Code asks for Claude model names, which Sevren does not serve (404 not_found_error). To use Small for the main session, run claude --model sevren-lite-27b. A session token expires after 14 days: when Claude Code reports an authentication error, sign in again and set the new token, or use an account key. A long session is bounded by the model's context window. Run /status to confirm the base URL and credential. Nonessential traffic is disabled by the example; client tools and plugins can still make their own network requests. Claude Code gateway documentation.

Codex

Current Codex clients use the Responses API. Sevren' Chat Completions URL cannot be used directly, and wire_api = "chat" is not a supported configuration.

If you operate a gateway that translates Responses, streaming and tool interactions into requests supported by Sevren, configure its upstream as https://api.example.com/v1 with your Sevren key. The example below assumes that gateway listens locally on port 4000. A gateway is not included or deployed by this guide.

Merge this provider into your user-level ~/.codex/config.toml. Replace the local URL if your gateway uses another address.

model = "sevren"
model_provider = "sevren_gateway"

[model_providers.sevren_gateway]
name = "Sevren via local Responses gateway"
base_url = "http://127.0.0.1:4000/v1"
env_key = "SEVREN_GATEWAY_API_KEY"
wire_api = "responses"
requires_openai_auth = false
supports_websockets = false

export SEVREN_GATEWAY_API_KEY="YOUR_GATEWAY_API_KEY"
codex

SEVREN_GATEWAY_API_KEY is the gateway's credential; the gateway keeps the upstream Sevren credential separately. Anthropic compatibility alone does not provide Responses compatibility. Official OpenAI configuration reference.

Cline

Open Cline's settings and choose the OpenAI Compatible provider. Configure both Plan and Act when they use separate provider settings.

Read context and output limits from Models. Sevren accepts native tool calls on this route. Keep image and computer-use support disabled: images are not supported. Cline provider documentation.

Hermes

Hermes connects to Sevren through OpenAI Chat Completions. Merge this model section into ~/.hermes/config.yaml. The custom provider reads your key from SEVREN_API_KEY, so start Hermes from the shell where you exported it.

model:
  default: sevren
  provider: custom
  base_url: https://api.example.com/v1
  key_env: SEVREN_API_KEY

Run hermes to start a session. To use Small, change model.default to sevren-lite-27b. You can also run hermes model, choose Custom endpoint and enter https://api.example.com/v1, your Sevren key and either model ID. Sevren supports tool calls on this route, so Hermes can use its native tools. Hermes provider documentation.

Aider

Run Aider in your project directory with the OpenAI-compatible provider. The openai/ prefix selects Aider's provider; the model ID sent to Sevren is sevren.

export OPENAI_API_BASE="https://api.example.com/v1"
export OPENAI_API_KEY="$SEVREN_API_KEY"

aider --model openai/sevren --edit-format diff

Use openai/sevren-lite-27b to select Small. Diff editing uses text responses. Review changes before applying or committing them. Aider provider documentation.

Continue

Merge these models into your local ~/.continue/config.yaml and replace each API-key placeholder. The examples enable Chat and Edit and explicitly use Chat Completions.

name: Sevren
version: 1.0.0
schema: v1

models:
  - name: Sevren
    provider: openai
    model: sevren
    apiBase: https://api.example.com/v1
    apiKey: YOUR_SEVREN_API_KEY
    roles: [chat, edit]
    useResponsesApi: false
  - name: Sevren Lite 27B
    provider: openai
    model: sevren-lite-27b
    apiBase: https://api.example.com/v1
    apiKey: YOUR_SEVREN_API_KEY
    roles: [chat, edit]
    useResponsesApi: false

Select a Sevren model in the extension. Agent mode can use native tools, since Sevren supports tool calling; autocomplete and embeddings are separate capabilities and are not configured here. Continue provider documentation.

Security-testing agents

Strix and artex-ko are autonomous penetration-testing agents: they probe a target on their own. Run them only against systems you own or are explicitly authorized to test. sevren-lite-flash suits this work; sevren also works. Create the key on the account page; a session token expires after 14 days, so use an account key for a long unattended run.

Strix [ TOP Cybersec agent ]

Strix is an open-source AI penetration-testing tool whose autonomous agents find and validate vulnerabilities. Install it per its README; it requires Docker. It uses LiteLLM-style provider and model names and an OpenAI-compatible base URL, which you point at Sevren.

export STRIX_LLM="openai/sevren-lite-flash"
export LLM_API_KEY="sk-sv-user-…"            # your Sevren key (session token or account key)
export LLM_API_BASE="https://api.example.com/v1"

strix --target ./your-app        # or: strix -n --target https://your-app

The openai/ prefix selects the OpenAI-compatible driver; the part after it is the Sevren model id. Sevren serves these models, so use a Sevren model id (sevren-lite-flash or sevren), not a closed-provider name. Strix relies on tool calling, which Sevren supports. Strix documentation.

artex-ko [ TOP Cybersec agent ]

artex-ko is the Korean-localized edition of the ARTEX autonomous pentest framework: a Go backend with an embedded Next.js UI and PostgreSQL. Build it from source per its README; the prebuilt Docker image is unavailable. It reaches an OpenAI-compatible endpoint through ARTEX_LLM_BASE_URL.

ARTEX_LLM_PROVIDER=openai
ARTEX_LLM_MODEL=sevren-lite-flash
ARTEX_LLM_BASE_URL=https://api.example.com/v1
OPENAI_API_KEY=sk-sv-user-…        # your Sevren key

The key and base URL can also be set on its LLM 설정 settings page. For OpenAI-compatible endpoints, cap max_tokens at 16,384, following its own guidance. artex-ko documentation.

Other agents

For another client with an OpenAI Chat Completions provider, set its base URL to https://api.example.com/v1, supply your Sevren key as a bearer token and select an ID from Models. Function tools and streaming work; images do not. Clients that speak Anthropic Messages use https://api.example.com instead (see Anthropic API); clients that require the Responses API need a gateway, as described for Codex.

Troubleshooting

Client history, telemetry, plugins and tools follow that client's settings. Sevren' server retention policy does not disable local files or network requests made by an external agent. See Privacy and Authentication.