Documentation›AI agents over MCP
Integrations

AI agents over MCP

Give any MCP-capable AI agent four CertOne tools: a confidential scan, the fixes from CertOne's sealed LLM agents, the release gate and the signed attestation.

Before you start

  • Python 3.10 or later on the machine where the agent runs.
  • A member API key.

In the CertOne console, open Developer Hub, then API keys. Name the key, choose the member role and select New key.

  • Copy the secret right away: it is shown only once.
  • Keys start with ck_ and expire after at most 365 days.
  • Creating keys requires the admin role in your organization.
  • A viewer key can read results but cannot submit scans.

Install the CertOne MCP server, certone-mcp, and make the key available to it:

Terminal
pip install "certone-sdk[mcp]"
export CERTONE_API_KEY=ck_...        # PowerShell: $env:CERTONE_API_KEY = "ck_..."
ToolWhat it does
certone_scanConfidential scan of a project folder in a hardware-attested sandbox: the verdict and each finding with the law it breaks, its file and line.
certone_fixesThe fixes CertOne's sealed LLM agents propose, with the independent verifier's review. While they are still working it says so, and the agent calls again.
certone_release_gateAllows a release only for a passing verdict with a signed attestation.
certone_attestationThe signed attestation of a passing report, bound to its exact version.

Claude Code

Register the server once, then ask in plain language, for example Use CertOne to check this service before release.

Terminal
claude mcp add certone --env CERTONE_API_KEY=$CERTONE_API_KEY -- certone-mcp
claude

Claude Desktop

Add the server to claude_desktop_config.json (Settings, Developer, Edit Config), then restart Claude Desktop. certone-mcp must be on the PATH, or give its full path as command.

claude_desktop_config.json
{
  "mcpServers": {
    "certone": {
      "command": "certone-mcp",
      "env": { "CERTONE_API_KEY": "ck_..." }
    }
  }
}

VS Code with GitHub Copilot

Add .vscode/mcp.json to the workspace. VS Code asks for the key once and keeps it in its secret storage. Open the chat in Agent mode and select Start above the server in mcp.json.

.vscode/mcp.json
{
  "inputs": [
    { "type": "promptString", "id": "certone-key", "description": "CertOne API key", "password": true }
  ],
  "servers": {
    "certone": {
      "type": "stdio",
      "command": "certone-mcp",
      "env": { "CERTONE_API_KEY": "${input:certone-key}" }
    }
  }
}
A model that follows multi-step instructions well gives the most complete reports. Copilot can also use your own Anthropic or OpenAI key through Manage Language Models.

GitHub Actions

On every pull request, an agent scans the change, commits CertOne's fix to the branch, scans again and posts the verdict and the attestation as a comment. Add two repository secrets, CERTONE_API_KEY and ANTHROPIC_API_KEY, and this workflow:

.github/workflows/certone-mcp.yml
name: CertOne AI agent (MCP)
on:
  pull_request:
    branches: [main]
permissions:
  contents: write        # commit CertOne's fix to the pull request branch
  pull-requests: write   # post the report
jobs:
  certone-agent:
    # branches of this repository only: forks never run the agent or reach the secrets
    if: github.event.pull_request.head.repo.full_name == github.repository
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
        with:
          ref: ${{ github.head_ref }}
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - name: Install Claude Code and the CertOne MCP server
        run: |
          curl -fsSL https://claude.ai/install.sh | bash
          echo "$HOME/.local/bin" >> "$GITHUB_PATH"
          pip install "certone-sdk[mcp]"
      - name: Certify the AI system with CertOne
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
          CERTONE_API_KEY: ${{ secrets.CERTONE_API_KEY }}
        run: |
          claude -p "Use CertOne to check my-model/ before release. If it fails, apply CertOne's patch and scan again. Write the full report to certone-report.md. Do not run git." \
            --mcp-config '{"mcpServers":{"certone":{"command":"certone-mcp"}}}' \
            --allowedTools "mcp__certone,Read,Edit,Write,Glob,Grep" --permission-mode acceptEdits
      - name: Commit CertOne's fix to the pull request
        run: |
          git config user.name "certone-agent"
          git config user.email "certone-agent@users.noreply.github.com"
          git add my-model
          git diff --cached --quiet || { git commit -m "Apply CertOne's fix" -m "[skip ci]"; git push; }
      - name: Post the report on the pull request
        env:
          GH_TOKEN: ${{ github.token }}
        run: gh pr comment ${{ github.event.pull_request.number }} --body-file certone-report.md
  • Replace my-model with the folder of your AI system.
  • The if: line keeps forks away from the agent and the secrets.
  • [skip ci] keeps the fix commit from starting the workflow again.

Other MCP clients and your own agents

Any MCP client that runs local servers can use CertOne: the command is certone-mcp (stdio), with CERTONE_API_KEY in its environment. CERTONE_API_URL points it at another CertOne deployment.

With the OpenAI Agents SDK (pip install openai-agents), for OpenAI models:

Python
import asyncio, os
from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async def main():
    async with MCPServerStdio(params={
        "command": "certone-mcp",
        "env": {"CERTONE_API_KEY": os.environ["CERTONE_API_KEY"]},
    }) as certone:
        agent = Agent(name="Release checker", mcp_servers=[certone],
                      instructions="Use CertOne before every release of an AI system.")
        result = await Runner.run(agent, "Use CertOne to check ./my-model before release.")
        print(result.final_output)

asyncio.run(main())

With the Claude Agent SDK (pip install claude-agent-sdk):

Python
import asyncio, os
from claude_agent_sdk import ClaudeAgentOptions, query

options = ClaudeAgentOptions(
    mcp_servers={"certone": {"command": "certone-mcp",
                             "env": {"CERTONE_API_KEY": os.environ["CERTONE_API_KEY"]}}},
    allowed_tools=["mcp__certone", "Read", "Edit"],
)

async def main():
    async for message in query(prompt="Use CertOne to check ./my-model before release.",
                               options=options):
        print(message)

asyncio.run(main())
The ChatGPT app connects only to hosted MCP servers, so it cannot run certone-mcp yet. Use the OpenAI Agents SDK above with the same OpenAI models.

Notes

  • The server never approves or applies a fix on the platform: the agent applies it in its own working tree, where your team reviews it, and a new scan decides.
  • The sealed LLM agents take a few minutes after the verdict; the agent waits and calls certone_fixes again.
  • Keep the API key in the agent's secret storage or environment, never in the repository.