Tools

Anthropic's terminal agent. Speaks the Anthropic Messages API, so it needs a bridge.

Where

Environment variables, or a local bridge in front of the API

Verified on

2026-09-20 against the official documentation

# Claude Code does not send OpenAI chat completions requests.
# Point a local bridge at Cognitivers and point Claude Code at the bridge.
#
# 1. Run the bridge on localhost (see the LiteLLM page for the config file)
litellm --config ./cognitivers.yaml

# 2. Then start Claude Code against it
export ANTHROPIC_BASE_URL=http://localhost:4000
export ANTHROPIC_AUTH_TOKEN=sk-cog-...
export ANTHROPIC_DEFAULT_SONNET_MODEL=cog-pro
export ANTHROPIC_DEFAULT_HAIKU_MODEL=cog-fast

• Claude Code posts to /v1/messages, not /v1/chat/completions. Without a bridge it cannot talk to this API.
• It counts every byte the bridge relays and aborts a stream that goes silent for 300 seconds, so the bridge must forward keep-alive pings during a long prefill.
• ANTHROPIC_AUTH_TOKEN sends Authorization: Bearer. ANTHROPIC_API_KEY would send X-Api-Key instead.
• CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1 fills the /model picker from the /v1/models endpoint of the bridge.

OpenAI's terminal agent and IDE extension. Custom providers are a first-class setting.

Where

~/.codex/config.toml

Verified on

2026-09-20 against the official documentation

model = "cog-fast"
model_provider = "cognitivers"

[model_providers.cognitivers]
name = "Cognitivers"
base_url = "https://api.cognitivers.com/v1"
env_key = "COGNITIVERS_API_KEY"

• The reserved provider ids openai, ollama and lmstudio cannot be reused; pick your own id.
• env_key names the environment variable that holds the key. The key itself never goes in the file.
• To redirect only the built-in OpenAI provider at a proxy, openai_base_url is the shorter form. Defining a provider as above is the explicit one.

DeepSeek's agent harness. Providers are declared in one YAML settings file.

Where

$DSH_HOME/settings.yaml

Verified on

2026-09-20 against the official documentation

llm-pi-ai:
  providers:
    cognitivers:
      displayName: "Cognitivers"
      api: "openai-completions"
      baseURL: "https://api.cognitivers.com/v1"
      apiKeyEnv: "COGNITIVERS_API_KEY"
      defaultContextWindow: 262144
      defaultInput:
        - "text"
      models:
        - id: "cog-fast"
          name: "Cog Fast"
          contextWindow: 262144
        - id: "cog-pro"
          name: "Cog Pro"
          contextWindow: 262144

• The namespace is llm-pi-ai, with hyphens. It is the provider plugin's name, not a separate product.
• baseURL includes the /v1 suffix. Without it requests go to /chat/completions instead of /v1/chat/completions.
• apiKeyEnv is a reference to an environment variable name. Secrets never go in this file.
• api accepts openai-completions, openai-responses and anthropic-messages. Use openai-completions here.
• For a route the catalog does not know, the models list replaces the catalog for that route, so declare every model you want to use.

Minimal terminal coding harness. Same provider schema as DSH, in JSON.

Where

~/.pi/agent/models.json

Verified on

2026-09-20 against the official documentation

{
  "providers": {
    "cognitivers": {
      "name": "Cognitivers",
      "baseUrl": "https://api.cognitivers.com/v1",
      "api": "openai-completions",
      "apiKey": "$COGNITIVERS_API_KEY",
      "compat": {
        "supportsDeveloperRole": false,
        "maxTokensField": "max_tokens"
      },
      "models": [
        { "id": "cog-fast", "name": "Cog Fast", "contextWindow": 262144 },
        { "id": "cog-pro", "name": "Cog Pro", "contextWindow": 262144 }
      ]
    }
  }
}

• apiKey takes a literal, a $VARIABLE reference, or a shell command prefixed with !. Use the variable form so no secret is stored in the file.
• Set compat.supportsDeveloperRole to false when the server behind the API does not understand the developer role; the prompt is then sent as a system message.
• compat.maxTokensField picks between max_tokens and max_completion_tokens. This is the setting that most often decides whether a tool works at all.
• Run /login to store the key in auth.json instead of the models file.

A fork of Pi with the editor wired in. Same schema, YAML, and model roles per task.

Where

~/.omp/agent/models.yml and ~/.omp/agent/config.yml

Verified on

2026-09-20 against the official documentation

# ~/.omp/agent/models.yml
providers:
  cognitivers:
    baseUrl: https://api.cognitivers.com/v1
    api: openai-completions
    apiKey: $COGNITIVERS_API_KEY
    models:
      - id: cog-fast
        name: Cog Fast
        contextWindow: 262144
        maxTokens: 32768
      - id: cog-pro
        name: Cog Pro
        contextWindow: 262144
        maxTokens: 32768

# ~/.omp/agent/config.yml
modelRoles:
  default: cognitivers/cog-pro
  smol: cognitivers/cog-fast

• Same provider schema as Pi, in YAML: baseUrl, api, apiKey, models.
• run omp models cognitivers to check that the route loads before starting a session.
• Roles let one route serve several jobs: default for normal turns, smol for cheap fan-out.

Cannot use a third party endpoint. Its own documentation lists five providers and no base URL.

Where

Not available

Verified on

2026-09-20 against the official documentation

# Nothing to configure today.
#
# Cursor's own documentation lists the providers that accept your own key
# (OpenAI, Anthropic, Google, Azure OpenAI, AWS Bedrock) and documents no base
# URL field. Custom keys work with chat models only: tab completion keeps
# using Cursor's own models, and requests route through Cursor's servers.

• We are not listing a workaround we cannot support. If Cursor adds a base URL setting, this page changes the same day.
• For the same job with a real editor surface, see the Zed, VS Code and Continue pages.

Custom Endpoint provider. Point it at the base URL and VS Code discovers the models itself.

Where

chatLanguageModels.json

Verified on

2026-09-20 against the official documentation

[
  {
    "name": "Cognitivers",
    "vendor": "customendpoint",
    "url": "https://api.cognitivers.com/v1",
    "apiKey": "${input:chat.lm.secret.cognitivers}"
  }
]

• Declaring url at provider level makes VS Code ask the endpoint for its model list instead of requiring a models array, which is the least friction of any editor here.
• Requests carry Authorization: Bearer by default.
• It covers chat, agent mode and utility tasks. It does not cover semantic search, inline suggestions or embeddings.
• On Copilot Business and Enterprise an administrator has to enable the bring-your-own-key policy first.

The most precise fit for our stack: it exposes the request-shape switches other editors hide.

Where

~/.config/zed/settings.json or .zed/settings.json

Verified on

2026-09-20 against the official documentation

{
  "language_models": {
    "openai_compatible": {
      "cognitivers": {
        "api_url": "https://api.cognitivers.com/v1",
        "available_models": [
          {
            "name": "cog-fast",
            "display_name": "Cognitivers Fast",
            "max_tokens": 32768,
            "capabilities": { "tools": true, "images": false },
            "max_tokens_parameter": true
          },
          {
            "name": "cog-pro",
            "display_name": "Cognitivers Pro",
            "max_tokens": 32768,
            "capabilities": { "tools": true, "images": false },
            "max_tokens_parameter": true
          }
        ]
      }
    }
  }
}

• capabilities.max_tokens_parameter defaults to false, which sends max_completion_tokens. Set it to true to send max_tokens.
• The key is not stored in settings.json: Zed reads it from an environment variable named after the provider, COGNITIVERS_API_KEY.
• Tab completion is a separate feature (edit_predictions) and needs a /v1/completions endpoint, which this API does not serve.

Open source assistant for VS Code and JetBrains, configured with YAML.

Where

~/.continue/config.yaml

Verified on

2026-09-20 against the official documentation

name: cognitivers
version: 1.0.0
models:
  - name: Cog Pro
    provider: openai
    model: cog-pro
    apiBase: https://api.cognitivers.com/v1
    apiKey: ${{ secrets.COGNITIVERS_API_KEY }}
    roles: [chat, edit, apply, summarize]
    defaultCompletionOptions:
      contextLength: 262144
    capabilities: [tool_use]
  - name: Cog Fast
    provider: openai
    model: cog-fast
    apiBase: https://api.cognitivers.com/v1
    apiKey: ${{ secrets.COGNITIVERS_API_KEY }}
    roles: [chat, autocomplete, edit]
    capabilities: [tool_use]

• capabilities must list tool_use explicitly. Capability detection fails on unfamiliar model names, and without tool_use there is no agent mode.
• Do not enable useLegacyCompletionsEndpoint: this API serves chat completions, not the legacy completions endpoint.
• Roles decide which jobs a model serves: chat, autocomplete, embed, rerank, edit, apply, summarize.

VS Code agent extension with a generic OpenAI Compatible provider and a verify button.

Where

Extension settings, stored in ~/.cline/data/settings/providers.json

Verified on

2026-09-20 against the official documentation

# In the extension settings panel:
#   API Provider:  OpenAI Compatible
#   Base URL:      https://api.cognitivers.com/v1
#   API Key:       sk-cog-...
#   Model ID:      cog-pro
#
# Use the Verify button to test the connection before starting a task.

• Cline has no embedding surface, so cog-embed has no use here.
• Unlike Roo Code it falls back to XML tool calling, so it degrades instead of failing if native tool calls are imperfect.

VS Code agent extension, same provider shape as Cline, with stricter tool-call requirements.

Where

Extension settings panel; the profile exports to JSON

Verified on

2026-09-20 against the official documentation

# In the extension settings panel:
#   API Provider:  OpenAI Compatible
#   Base URL:      https://api.cognitivers.com/v1
#   API Key:       sk-cog-...
#   Model ID:      cog-fast
#
# Codebase indexing has its own selector: choose OpenAI Compatible and put
# the same base URL there, with cog-embed as the model.

• Roo Code uses native tool calling exclusively, with no XML fallback. Test tool calls before relying on it for agent work.
• Its codebase indexing can use cog-embed through the same base URL, but it needs a vector store of your own.
• Exported profiles contain API keys in plain text, so treat the export as a secret.

Pair programming in the terminal. Any OpenAI compatible endpoint, by environment or config file.

Where

.aider.conf.yml, or the OPENAI_API_BASE environment variable

Verified on

2026-09-20 against the official documentation

# .aider.conf.yml
openai-api-base: https://api.cognitivers.com/v1
openai-api-key: sk-cog-...
model: openai/cog-pro

• The model needs the openai/ prefix: aider --model openai/cog-pro. Without it Aider looks for a different provider.
• Environment variables work too: OPENAI_API_BASE and OPENAI_API_KEY.
• Only OpenAI and Anthropic keys belong in the YAML file; put other keys in .env.

Terminal agent configured with a JSON file and the AI SDK.

Where

opencode.json in the project, or ~/.config/opencode/opencode.json

Verified on

2026-09-20 against the official documentation

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "cognitivers": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Cognitivers",
      "options": {
        "baseURL": "https://api.cognitivers.com/v1",
        "apiKey": "{env:COGNITIVERS_API_KEY}"
      },
      "models": {
        "cog-fast": { "name": "Cog Fast" },
        "cog-pro": { "name": "Cog Pro" }
      }
    }
  },
  "model": "cognitivers/cog-pro",
  "small_model": "cognitivers/cog-fast"
}

• Use the npm package @ai-sdk/openai-compatible for chat completions. @ai-sdk/openai targets the Responses API instead.
• Model ids under models must match the ids returned by /v1/models.
• The default model is the top level model key, written as provider/model.

Block's agent. Uses OPENAI_HOST rather than the OPENAI_BASE_URL name other tools use.

Where

Environment variables, plus config.yaml for the model

Verified on

2026-09-20 against the official documentation

# The host goes without a trailing path: Goose appends the base path itself.
export OPENAI_HOST=https://api.cognitivers.com
export OPENAI_BASE_PATH=v1/chat/completions
export OPENAI_API_KEY=sk-cog-...

# ~/.config/goose/config.yaml
active_provider: openai
providers:
  openai:
    enabled: true
    model: cog-pro
    configured: true

• The variable is OPENAI_HOST, not OPENAI_BASE_URL, and OPENAI_BASE_PATH defaults to v1/chat/completions.
• Goose does not read provider keys from config.yaml. A key placed there is ignored and shows up later as an authentication error.
• For several endpoints at once, add a JSON file under custom_providers/ with engine set to openai.

Charm's terminal agent. The provider type matters: openai-compat, not openai.

Where

crushrc in the project or ~/.config/crush/crushrc

Verified on

2026-09-20 against the official documentation

# Add the provider.
provider add cognitivers \
  --type openai-compat \
  --base-url "https://api.cognitivers.com/v1" \
  --api-key "${COGNITIVERS_API_KEY:?set COGNITIVERS_API_KEY}"

# Register the models.
model add cognitivers/cog-pro --name "Cog Pro" --context-window 262144
model add cognitivers/cog-fast --name "Cog Fast" --context-window 262144

• Use openai-compat. The openai type is for routing through OpenAI itself.
• Configuration moved to a Bash crushrc file. crush.json still works but is deprecated and receives no new options.
• Both files run as code: keep them out of untrusted hands.

Code you write yourself. Every mainstream client takes a custom base URL, with one naming difference per language.

Where

Your own code, or the environment

Verified on

2026-09-20 against the official documentation

# Python: the argument is base_url, the variable is OPENAI_BASE_URL
export OPENAI_BASE_URL=https://api.cognitivers.com/v1
export OPENAI_API_KEY=sk-cog-...

# Node and TypeScript: the argument is baseURL, with capital URL
# new OpenAI({ baseURL: "https://api.cognitivers.com/v1", apiKey: ... })
#
# Vercel AI SDK: createOpenAI({ baseURL, apiKey }), then openai.chat("cog-fast")
#   Use .chat(), because openai("cog-fast") targets the Responses API.
#   Alternative: createOpenAICompatible({ name, apiKey, baseURL })
#
# LangChain Python: pip install langchain-openai
#   ChatOpenAI(model="cog-fast", base_url="https://api.cognitivers.com/v1", api_key="...")
#   Precedence: the kwarg, then OPENAI_API_BASE, then OPENAI_BASE_URL.

• Python uses base_url; Node uses baseURL. One letter of case, and it is the most common silent mistake.
• Vercel AI SDK: use openai.chat('cog-fast'). The default factory targets the Responses API and will fail against chat completions.
• LangChain turns stream_usage off when OPENAI_BASE_URL is set, so enable it explicitly if you count tokens in a stream.
• OpenAI Node SDK: the README documents streaming through the Responses API only. Streaming chat completions works with stream: true, but check it against your own version.

Not an agent. A local proxy that speaks OpenAI outward and Anthropic inward, which is what makes Claude Code usable.

Where

A YAML file passed to the proxy

Verified on

2026-09-20 against the official documentation

model_list:
  - model_name: cog-pro
    litellm_params:
      model: openai/cog-pro
      api_base: https://api.cognitivers.com/v1
      api_key: os.environ/COGNITIVERS_API_KEY
  - model_name: cog-fast
    litellm_params:
      model: openai/cog-fast
      api_base: https://api.cognitivers.com/v1
      api_key: os.environ/COGNITIVERS_API_KEY

# Serve an Anthropic-shaped surface for Claude Code on port 4000
general_settings:
  master_key: os.environ/LITELLM_MASTER_KEY

• The openai/ prefix on the model string is what tells LiteLLM to use an OpenAI compatible endpoint.
• Do not add a path to api_base beyond /v1, or requests 404.
• Start it with litellm --config ./cognitivers.yaml. It listens on port 4000 by default.