Use the API in coding agents

Coding agents can call the ISMS Copilot API as a fixed compliance step, from any script or SDK that speaks the OpenAI chat completions API: base URL https://api.ismscopilot.com/v1, key sk-isms-…, alias isms-fast or isms-thinking (plus -eu twins for the EU path).

By default, when a framework is named in the conversation or pinned by the caller, completions are grounded in the same maintained framework knowledge registry the chat product uses, and every response discloses which modules were injected. Pin modules when you need deterministic grounding.

Where the sub-agent fits

Your orchestrator keeps a general model for code and calls this API only for the compliance step. Typical steps:

• Review work that touches controls: ask what ISO 27001:2022 or SOC 2 expects where a pull request moves authentication or logging, before a human reviews it.
• Draft control mappings, Annex A statements, and clause summaries.
• Triage steps in automation: DPIA screening questions, NIS 2 applicability checks, lawfulness first passes, each with the right module pinned.
• Policy pre-checks before an auditor sees the draft.

The pattern that always works: a sub-agent step

Tool-using agent modes cannot run on this endpoint directly, because the endpoint rejects tool and function definitions. The universal shape is a plain completion your agent triggers from a script:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.ismscopilot.com/v1",
    api_key="sk-isms-...",
)

resp = client.chat.completions.create(
    model="isms-thinking",
    messages=[
        {"role": "user", "content": "Does this PR description affect ISO 27001 Annex A access controls? Name the controls."}
    ],
    extra_body={"ismscopilot": {"frameworks": ["ISO_27001"]}},
)
print(resp.choices[0].message.content)

Wrap that call in a script your harness can run (a tool, a command, a sub-agent step), and the compliance sub-agent exists.

Direct model configs (text-only, no tools)

Some harnesses can also use the endpoint as a model directly, for plain chat or review flows that send no tool definitions. Tool-dependent modes (Cline agents, Cursor Agent, opencode's default agents) should use the sub-agent step above instead.

opencode

Register an OpenAI-compatible provider in opencode.jsonc. Do not set it as the global model: opencode's built-in agents send tool definitions this endpoint rejects. Use the alias for plain chat turns, or point a custom agent with tools disabled at it:

{
  "provider": {
    "ismscopilot": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "ISMS Copilot",
      "options": {
        "baseURL": "https://api.ismscopilot.com/v1",
        "apiKey": "{env:ISMS_API_KEY}"
      },
      "models": {
        "isms-fast": { "name": "ISMS Copilot Fast" },
        "isms-thinking": { "name": "ISMS Copilot Thinking" }
      }
    }
  }
}

Export the key first: export ISMS_API_KEY=sk-isms-….

Continue

Add the endpoint as a chat model in your Continue config. Agent mode relies on tool calling and is not supported on this endpoint; use the chat role:

name: ISMS Copilot
version: 0.0.1
schema: v1

models:
  - name: ISMS Copilot Fast
    provider: openai
    model: isms-fast
    apiBase: https://api.ismscopilot.com/v1
    apiKey: ${{ secrets.ISMS_API_KEY }}
    roles:
      - chat

Aider

Aider routes OpenAI-compatible providers through LiteLLM and does not need function calling for its edit formats, so it can run directly on the endpoint:

export OPENAI_API_BASE=https://api.ismscopilot.com/v1
export OPENAI_API_KEY=sk-isms-...

aider --model openai/isms-fast

Cursor (caveated)

Cursor exposes an OpenAI API key setting with an Override OpenAI Base URL option. It is a global override with compatibility limitations, not a verified integration for arbitrary OpenAI-compatible endpoints, and tool-using Agent mode will not work. If you use it: enter the key, enable the override, set it to the base URL above, add the exact isms-fast or isms-thinking id as a custom model, and disable the override before switching back to Cursor-hosted models. The sub-agent step is the more reliable shape.

Pin the framework in agent loops

Auto-detection scans the user messages and the last assistant turn. It does not scan system or developer messages, and harness instructions usually live in the system prompt, so auto can miss in an agent loop. A bare control id like 5.23 also injects nothing.

Pin instead: send the ismscopilot extension with exact catalog ids, up to eight per call.

curl https://api.ismscopilot.com/v1/chat/completions \
  -H "Authorization: Bearer sk-isms-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "isms-fast",
    "messages": [
      {"role": "user", "content": "Which ISO 27001:2022 Annex A control covers acceptable use of information and assets? One line."}
    ],
    "ismscopilot": {"frameworks": ["ISO_27001"]}
  }'

The response discloses what ran: header x-isms-frameworks: ISO_27001 and an ismscopilot object listing the injected modules and their knowledge size. Log the disclosure per request as evidence of which modules grounded each step. Valid ids come from GET /v1/frameworks.

Full control surface: Framework knowledge.

Claude Code

Claude Code cannot point directly at this endpoint for its model backend: it speaks the Anthropic API shape, and this is an OpenAI-compatible chat completions endpoint. Two real options:

1. Call the API as a sub-agent step. Claude Code runs a script (curl or SDK, shapes above) and works with the grounded answer.
2. Use ISMS Copilot for Agents for the account plane. Account MCP (pat-isms-…) connects Claude Code to your chat account, conversations, and memories under the chat subscription. It is a different product plane from model inference. See Agents and Set up the model API from Claude Code or Grok.

Limits

• Text in, text out. No tool or function calling, no JSON mode, no logprobs, n is 1, multimodal parts are rejected. Streaming is supported.
• Thinking has a floor. Thinking aliases floor max_tokens at 1024 when a lower value is sent; headers disclose requested vs effective.
• Context preflight. Requests whose assembled prompt would exceed the context window are rejected locally with context_length_exceeded before billing. Pinning several large modules can trigger this. Successful responses disclose the selected ids and knowledge size; the public catalog supplies valid ids and metadata, not knowledge sizes.
• Guidance, not an audit opinion. Answers are educational compliance guidance. Risk acceptance stays with you.
• Grounded, not fine-tuned. Curated modules are injected at inference and disclosed per response; see Framework knowledge.

Costs and safety rails

Prepaid credits, separate from the chat subscription; rates are listed in the console. If the agent runs unattended, set a per-key spend cap (hour, day, week, or month) so a runaway loop cannot burn the balance. Details: Credits, pricing, and spend limits. Prompts and outputs are not stored as customer records: Zero Data Retention.

Marketing guide with the full argument: Give your coding agent a compliance sub-agent.