OsirisBrain — Integration Guide & Documentation

Quick Start

Create an account at osirisbrain.com/portal
Get an API key from the Dashboard → API Keys tab. Your key starts with sk-osiris-
Make your first request — OsirisBrain is 100% OpenAI-compatible:

      
# Any OpenAI-compatible client works
curl https://app.osirisbrain.com/v1/chat/completions \
  -H "Authorization: Bearer sk-osiris-..." \
  -H "Content-Type: application/json" \
  -d '{"model":"osirisbrain-coder","messages":[{"role":"user","content":"Hello"}]}'
    

That's it.

Every request is automatically routed through the OsirisBrain pipeline: multiple AI models collaborate, the best response is selected, and an auditor verifies it before you see the answer.

API Reference

Base URL

https://app.osirisbrain.com/v1

Authentication

Send your API key as a Bearer token in every request:

Authorization: Bearer sk-osiris-...

Available Models

osirisbrain-coder  # Text, code, reasoning — $2/$10 per 1M tokens
osirisbrain-ultra  # Multimodal: images, documents, PDFs + text — $4/$16 per 1M tokens
    

Two tiers, one API key.

Your sk-osiris- key works with both models. Use osirisbrain-coder for coding, text, and reasoning tasks. Use osirisbrain-ultra when you need image understanding, document analysis, or multimodal reasoning (screenshots, diagrams, PDFs, charts).

Endpoints

POST /v1/chat/completions — Chat completions (OpenAI-compatible, supports tools)
GET /v1/models — List available models
GET /health — Service health check
POST /api/admin/login — Dashboard login
GET /api/admin/pipeline-config — View pipeline configuration (admin)
PUT /api/admin/pipeline-config — Update which models handle which roles (admin)

Tool Calling (Function Calling)

OsirisBrain supports OpenAI-format tools natively. All models in the pool support function calling.

{
  "model": "osirisbrain-coder",
  "messages": [...],
  "tools": [{
    "type": "function",
    "function": {
      "name": "bash",
      "description": "Execute a command",
      "parameters": {
        "type": "object",
        "properties": {
          "command": { "type": "string" }
        },
        "required": ["command"]
      }
    }
  }]
}
    

OpenCode OpenAI-compatible

Add OsirisBrain as a provider in your opencode.json:

{
  "provider": {
    "osirisbrain": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "OsirisBrain",
      "options": {
        "baseURL": "https://app.osirisbrain.com/v1",
        "apiKey": "{env:OSIRISBRAIN_API_KEY}"
      },
      "models": {
        "osirisbrain-coder": { "name": "OsirisBrain Coder" },
        "osirisbrain-ultra": { "name": "OsirisBrain Ultra (images + docs)" }
      }
    }
  },
  "model": "osirisbrain/osirisbrain-coder"
}
    

Then set your API key: export OSIRISBRAIN_API_KEY=sk-osiris-...

Cursor OpenAI-compatible

Open Cursor → Settings (gear) → Models
Add a custom model name: osirisbrain-coder
Enable "Override OpenAI Base URL"
Base URL: https://app.osirisbrain.com/v1
API Key: sk-osiris-...
Click Verify

Note:

The override applies to all OpenAI-routed models in Cursor. Turn it off when you want Cursor's native models.

Cline (VS Code) OpenAI-compatible

Open Cline sidebar → Settings (gear)
API Provider → select "OpenAI Compatible"
Base URL: https://app.osirisbrain.com/v1
API Key: sk-osiris-...
Model ID: osirisbrain-coder
Click Save

OpenClaw OpenAI-compatible

Add to your openclaw.json (JSON5):

{
  agents: {
    defaults: { model: { primary: "osirisbrain/osirisbrain-coder" } },
  },
  models: {
    mode: "merge",
    providers: {
      osirisbrain: {
        baseUrl: "https://app.osirisbrain.com/v1",
        apiKey: "${OSIRISBRAIN_API_KEY}",
        api: "openai-completions",
        models: [
          { id: "osirisbrain-coder", name: "OsirisBrain Coder" },
          { id: "osirisbrain-ultra", name: "OsirisBrain Ultra (images + docs)" },
        ],
      },
    },
  },
}
    

Then: export OSIRISBRAIN_API_KEY=sk-osiris-...

OpenHands OpenAI-compatible

OpenHands (formerly OpenDevin) supports any litellm-compatible model. Configure in config.toml:

# config.toml
[llm]
model = "openai/osirisbrain-coder"
api_key = "sk-osiris-..."
base_url = "https://app.osirisbrain.com/v1"
    

Or via environment variables:

export LLM_MODEL="openai/osirisbrain-coder"
export LLM_API_KEY="sk-osiris-..."
export LLM_BASE_URL="https://app.osirisbrain.com/v1"
    

Hermes Agent OpenAI-compatible

Hermes Agent (NousResearch) uses litellm under the hood. Set environment variables:

export HERMES_MODEL="openai/osirisbrain-coder"
export OPENAI_API_KEY="sk-osiris-..."
export OPENAI_API_BASE="https://app.osirisbrain.com/v1"
export OPENAI_BASE_URL="https://app.osirisbrain.com/v1"
    

Hermes + OsirisBrain

Hermes Agent gets autonomous multi-model collaboration. Every request is routed, audited, and delivered by OsirisBrain's pipeline — Hermes sees one unified model.

Continue.dev OpenAI-compatible

Add to ~/.continue/config.yaml:

name: OsirisBrain
version: "1.0.0"
schema: v1
models:
  - name: OsirisBrain Coder
    provider: openai
    model: osirisbrain-coder
    apiBase: https://app.osirisbrain.com/v1
    apiKey: ${{ secrets.OSIRISBRAIN_API_KEY }}
    roles: [chat, edit, apply]
  - name: OsirisBrain Ultra
    provider: openai
    model: osirisbrain-ultra
    apiBase: https://app.osirisbrain.com/v1
    apiKey: ${{ secrets.OSIRISBRAIN_API_KEY }}
    roles: [chat, edit, apply]
    

Mini-SWE-Agent OpenAI-compatible

Configure mini-swe-agent to use OsirisBrain:

# ~/.config/mini-swe-agent/.env MSWEA_MODEL_NAME=openai/osirisbrain-coder OPENAI_API_KEY=sk-osiris-... OPENAI_API_BASE=https://app.osirisbrain.com/v1 OPENAI_BASE_URL=https://app.osirisbrain.com/v1 MSWEA_CONFIGURED=true MSWEA_COST_TRACKING=ignore_errors

Then run: python -m minisweagent --task "Fix the bug in app.py"

cURL / Python / Any HTTP Client

OsirisBrain is 100% OpenAI-compatible. Any library that supports custom base URLs works:

Python (openai library)

from openai import OpenAI

client = OpenAI(
    api_key="sk-osiris-...",
    base_url="https://app.osirisbrain.com/v1"
)

response = client.chat.completions.create(
    model="osirisbrain-coder",
    messages=[{"role": "user", "content": "Write a Python decorator"}]
)
print(response.choices[0].message.content)
    

Node.js

import OpenAI from "openai";

const client = new OpenAI({
  apiKey: "sk-osiris-...",
  baseURL: "https://app.osirisbrain.com/v1",
});

const response = await client.chat.completions.create({
  model: "osirisbrain-coder",
  messages: [{ role: "user", content: "Hello" }],
});
    

How the Pipeline Works

Every request goes through a multi-model collaboration pipeline. You send one request — multiple AI models work together behind the scenes.

L1: Exploration

Fast model (DeepSeek V4 Pro, ~200ms) handles file reading, code exploration, and test runs. 95% of turns use this path.

L3: Writing

For code changes: planner → 3 models execute in parallel → GLM selects best → GLM audits. Quality guaranteed.

Audit Loop

GLM-5.2 (I:51, top 5 globally) reviews every code change. If issues found → fix → re-audit. Up to 2 iterations.

Configurable

Admins can change which model handles each role from the dashboard. No code changes, no restart.

Models in the pool

GLM-5.2 (I:51, #5 globally) · DeepSeek V4 Pro ($0.18, fastest) · Qwen 3.7 Max (I:46) · MiniMax M3 (I:44) · Kimi K2.7 Code

FAQ

What's the difference between Coder and Ultra?

OsirisBrain Coder ($2/$10 per 1M tokens) handles text, code, and reasoning. OsirisBrain Ultra ($4/$16 per 1M tokens) adds multimodal capabilities — it can understand images, screenshots, diagrams, PDFs, and documents. Use Coder for coding agents (mini-swe-agent, OpenCode, Cursor). Use Ultra when your workflow involves visual content (UI analysis, document processing, chart reading). Both share the same API key and endpoint.

Yes, 100%. Any tool that supports custom OpenAI base URLs works with OsirisBrain. Just set the base URL to https://app.osirisbrain.com/v1 and use your sk-osiris- API key.

Which models are behind OsirisBrain?

OsirisBrain orchestrates 5 frontier models: GLM-5.2 (Intelligence Index 51, ranked #5 globally), DeepSeek V4 Pro, Qwen 3.7 Max, MiniMax M3, and Kimi K2.7 Code. Each model handles tasks where it's strongest. The pool is configurable by the admin.

Do you support tool calling / function calling?

Yes, all models in the pool support OpenAI-format tool calls natively. This includes multi-turn tool calling for agentic workflows.

How does pricing work?

Pay per token. Coder tier: $2/1M input, $10/1M output. Ultra tier: $4/1M input, $16/1M output. You're billed for the total tokens consumed across all models in the pipeline. No subscription required.

Can I use OsirisBrain for SWE-bench?

Yes. OsirisBrain works with mini-swe-agent, OpenCode, and other coding agents. We've verified resolution on real SWE-bench Lite tasks with the official Docker harness.

Is there a free tier?

New accounts get credits to try the service. Contact us at osirisbrain@gmail.com for enterprise pricing or custom pools.

← Back to Home