ISMS Copilot

Last updated: 2026-08-25 · Audience: engineers wiring coding agents and automation pipelines

Give your coding agent a compliance sub-agent

Your coding agent is fluent. It is not grounded. When the work touches access controls, DPIA screening, or a vendor review, the difference between a correct control reference and one that sounds right is the framework edition actually loaded in the prompt. Wire the ISMS Copilot API into your agent as the compliance step, and the framework loads before the model speaks.

The short version

  • A sub-agent is a step, not a persona. Your orchestrator keeps a general model for code and calls this API for compliance questions, from any script or SDK that speaks the OpenAI API.
  • The server grounds it. By default, when a framework is named or pinned, curated modules from a maintained registry of 101+ compliance frameworks are injected at inference, and the response discloses which ones ran.
  • Pin the framework per task. Auto-detection does not read system prompts, so an agent loop pins exact catalog ids and always answers from the framework it meant.

What the sub-agent is for

A sub-agent is a step your orchestrator trusts with one class of question. This one answers compliance questions with a maintained reference, while your main model stays general.

Review work that touches controls

A pull request moves authentication or logging. Ask the sub-agent what ISO 27001:2022 or SOC 2 expects there before a human reviews it. The answer arrives with the framework module already in the prompt, and the response says which module ran.

Draft control mappings and summaries

Map a vendor control set to your framework, draft Annex A statements, summarize what a clause asks for. The sub-agent answers from the curated module, not from whatever the base model remembers about an edition it may never have seen.

Triage steps in automation

DPIA screening questions, NIS 2 applicability checks, GDPR lawfulness first passes inside a pipeline. Each step is one completion with the right module pinned, so the pipeline stays explicit about the framework edition it used.

Policy pre-checks before an auditor does

Run draft policies past the sub-agent before the real review. It is guidance, not an audit opinion, but it can flag control-number and edition issues for human review.

The pattern that always works: a sub-agent step

One honest constraint first: the endpoint is text-only and rejects tool and function definitions. Tool-using agent modes cannot run on it directly. So the universal shape is the one below: your agent keeps its tools and its general model, and calls the compliance step with plain messages, pinning the frameworks for the task.

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)

The three facts every OpenAI-compatible client needs: base URL https://api.ismscopilot.com/v1, key sk-isms from platform.ismscopilot.com/keys, model alias isms-fast or isms-thinking (plus -eu twins). Wrap that call in a script your harness can run, and the 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. Where a tool works without function calling, this is the fastest setup. 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. 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. Create a key at platform.ismscopilot.com/keys, export it as ISMS_API_KEY, and add this to opencode.jsonc:

{
  "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" }
      }
    }
  }
}

Continue

Add the endpoint as a chat model in Continue's 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 alias as a custom model, and disable the override before switching back to Cursor-hosted models. The sub-agent step is the more reliable shape.

Claude Code cannot point directly at an OpenAI-compatible endpoint for its model backend; see the FAQ for the two real options. Harness settings move; the three facts above and the docs guide stay current.

Pin the framework, do not hope for detection

Auto-detection scans the user messages and the last assistant turn, not the system prompt. In a harness, your instructions live in the system prompt, so auto can miss. 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"]}
  }'

Verified on 2026-08-25, that request returns the right control (A.5.10) with the disclosure on the response: 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.

The knowledge is maintained, and the catalog is public

The registry behind the injection is a maintained artifact, not a one-time corpus. Modules are added and re-verified by scheduled workflows, modules carry version metadata, and the public catalog endpoint is generated from the same registry the API injects from. The catalog listed 101 modules on 2026-08-25, from ISO 27001, 27002, 27701 and 42001 through SOC 2, the NIST families, CMMC and FedRAMP, to GDPR, DORA, the EU AI Act, TISAX, HDS, SecNumCloud, and per-country NIS 2 transpositions. Treat the live endpoint as authoritative; counts move as modules ship.

That is the whole trade: your side of the bargain is a base URL and a pinned id. Amendments, editions, and new jurisdictions are the vendor's scheduled work.

Honest limits

  1. 1.Text in, text out

    The endpoint speaks the OpenAI chat completions subset: text messages, streaming, usage. It does not accept tool or function definitions, JSON mode, logprobs, n above 1, or multimodal parts. The sub-agent gets grounded generation, not tool use. Your harness keeps its own tools.

  2. 2.Detection is name-level, and it does not read your system prompt

    Auto mode scans the user messages and the last assistant turn. A bare control id like 5.23 injects nothing. Harness instructions usually live in the system prompt, which auto does not scan at all. In an agent loop, pin the frameworks explicitly.

  3. 3.Thinking has a floor

    Thinking aliases are for harder questions and floor max_tokens at 1024 when a lower value is sent, surfaced in response headers. Fast answers cost the same unit rate and are usually enough for a review step.

  4. 4.Guidance, not an audit opinion

    Answers are educational compliance guidance with the module disclosed. Risk acceptance and anything a regulation assigns to a person or a management body stay with you.

Get started

  1. 1. Create a key. Sign in at platform.ismscopilot.com/keys, top up prepaid credits, and set a per-key spend cap if the agent runs unattended.
  2. 2. List the catalog. GET https://api.ismscopilot.com/v1/frameworks is public. Pick the ids your agent will pin.
  3. 3. Wire the compliance step. Use the sub-agent pattern or a config above; the docs guide has step-by-step settings per tool.
  4. 4. Pin, do not guess. Start every compliance step with an explicit ismscopilot.frameworks pin and log the disclosure headers. That log is your evidence of which framework grounded each step.

Frequently asked questions

Is the framework knowledge built into the model?

No. Nothing here is fine-tuned or baked into model weights. Curated framework modules are injected into the prompt at inference time, before generation, and the response discloses which modules ran. Grounding you can verify beats recall you cannot see.

Can Claude Code use it as its model?

Not directly. Claude Code speaks the Anthropic API shape for its model backends, and this is an OpenAI-compatible chat completions endpoint. Real options: have Claude Code call the API as a sub-agent step (curl or SDK inside a script it runs), or use ISMS Copilot for Agents, the account MCP product, which is a different plane (your account and chat subscription, not model inference).

Can my coding agent be the primary model on this endpoint?

Only for text-only flows. The endpoint rejects tool and function definitions, so tool-using agent modes (Cline agents, Cursor Agent, opencode's default agents) cannot run on it directly. Two working shapes: call it as a sub-agent step from a script, or configure a harness chat mode that sends plain messages without tools.

Do I need to build retrieval for this?

No. That is the point. The service selects and injects the framework module server-side, from a maintained registry, and you can pin exact catalog ids per call. You do not maintain a chunker, an embedding store, or a version watch.

What does it cost to run as a sub-agent?

Prepaid credits on the platform console, separate from any chat subscription, with optional per-key spend caps so a runaway loop cannot burn the balance. Rates are listed in the console, which stays the source of truth for numbers.

Is there an EU path?

Yes. The isms-fast-eu and isms-thinking-eu aliases route to the EU path with Mistral under EU data-protection terms, and responses carry the processing region in a header.

Where do my prompts and outputs go?

Nowhere as customer records. The API layer stores no prompts or model outputs; usage history is metadata only (tokens, cost, model, status). Upstream paths on both global and EU aliases are configured for zero retention of request content. Details live in the Zero Data Retention docs.

Primary sources

  • ISMS Copilot API documentation (live product truth: endpoint, keys, credits, models). docs.ismscopilot.com (checked 2026-08-25).
  • Use the API in coding agents (docs guide: sub-agent pattern, configs, pinning, limits). docs.ismscopilot.com (checked 2026-08-25).
  • API framework knowledge (what is injected, auto/none/pin, honest limits). docs.ismscopilot.com (checked 2026-08-25).
  • Public frameworks catalog on the model API (GET /v1/frameworks; count verified on this page's last-updated date). api.ismscopilot.com (checked 2026-08-25).
  • Why the ISMS Copilot API instead of any model (the full developer argument). www.ismscopilot.com (checked 2026-08-25).

Written and maintained by the ISMS Copilot team for engineers wiring coding agents. Last reviewed 2026-08-25.

This is a product argument, not legal advice and not a pricing quote. Capabilities, retention posture, and commercial terms are defined by live docs, the Trust Center, and the platform console. Where this page summarises those surfaces, the live surface wins on drift.