Connect coding agents with MCP

KlaritiQ runs an MCP server that coding agents such as Claude Code and Cursor can call. An agent can read the current version of an AI system, record a part after changing it, run the release check and see which parts still need a sign-off. It gets what a deploy pipeline gets and nothing more.

MCP is an open protocol many tools speak. This page describes what KlaritiQ's server offers, not any one agent's product.

What an agent can and cannot do

An agent connected here:

• works for one initiative's AI system, the one the key belongs to. No tool takes an initiative or organization id, so a key cannot be pointed anywhere else
• can only report the part types the key allows
• can read the version and sign-off status of that system, and record one part at a time
• cannot sign anything off, and cannot write free text of its own into the record

It never reads evidence, decisions, notes, change notes or anyone's details. Sign-offs appear only as counts and statuses, never as who gave them.

Endpoint and key

The endpoint is https://klaritiq.in/api/mcp, the same address you see on the Coding agents (MCP) card under Integrations. It answers POST only. It offers no event stream and keeps no sessions.

The credential is a pipeline key, the same kind a deploy pipeline uses.

1. Open the initiative that governs the AI system. On its Governance tab, click Sources on the AI system card, and create a key under Add a source. Limit it to the part types the agent should report.
2. Set it as KLARITIQ_PIPELINE_KEY in the agent's environment. Do not paste the key into a file you commit.
3. Add the server to your agent.

Claude Code, command line

claude mcp add --transport http klaritiq https://klaritiq.in/api/mcp \
  --header "Authorization: Bearer $KLARITIQ_PIPELINE_KEY"

Claude Code, project file .mcp.json

{
  "mcpServers": {
    "klaritiq": {
      "type": "http",
      "url": "https://klaritiq.in/api/mcp",
      "headers": { "Authorization": "Bearer ${KLARITIQ_PIPELINE_KEY}" }
    }
  }
}

Cursor, .cursor/mcp.json

{
  "mcpServers": {
    "klaritiq": {
      "url": "https://klaritiq.in/api/mcp",
      "headers": { "Authorization": "Bearer ${env:KLARITIQ_PIPELINE_KEY}" }
    }
  }
}

The snippets read the key from an environment variable, so the key is never written into the file.

The four tools

What record_system_component writes is the same few fields a deploy pipeline sends. The change note on the version is fixed text saying it was recorded by a coding agent through the KlaritiQ MCP server, so an agent's own wording never enters the record. If you do not say where the part came from, it is shown as reported through MCP. Every version recorded this way names the key that wrote it.

record_system_component never removes a part that KlaritiQ's own feeds report: vendors from the vendor register and permissions from Microsoft Entra are kept. To drop a register vendor, unlink it in the register. If the agent names the same part, its value wins. Near the limit of 40 parts a part the feeds report may be left out of the recorded version, and the change note names it, starting "Not carried forward (limit of 40 parts)". If another tool records a version between the moment the agent reads and the moment it writes, KlaritiQ plans again, up to 3 times. If it still cannot, the call fails with a message saying nothing was recorded and to try again.

A change to a part that was signed off means people must review it again, like any other change. The agent can see that through list_pending_signoffs, but cannot do the review.

Limits and protections

• A request body can be at most 64 KB, and nested no deeper than 16 levels. Anything larger or deeper is refused.
• Each key can make 600 requests an hour to the MCP server. That allowance is separate from the 200 an hour the same key has for deploy pipeline calls, so an agent cannot use up the allowance a release check needs. Use one key per agent, so one busy agent does not use another's allowance and you can revoke one without the rest.
• A request that comes from a web page is refused. Coding agents send no web page origin.
• Errors come back as standard JSON-RPC errors that carry a message and never a stack trace. A refused key is a JSON-RPC error with HTTP status 401 and a WWW-Authenticate header.
• A key limited to some part types cannot record other types. get_ai_system_status lists the types the key may report.

Stop an agent

Revoke its key on the initiative, from the same Sources place where it was created. The agent's next call is refused.

What this does not do

• It does not detect a change by itself. An agent records what it is told or what it observes, and KlaritiQ compares what is recorded.
• It does not check that a version an agent records is true.
• It does not sign anything off, and it does not replace the sign-off. A person still reviews the version and signs.

For what a version is, see Which AI Version Did You Approve?. For what each connection can access, see How KlaritiQ Integrations Work.

Was this article helpful?

Community Questions (0)

Still have questions?