Before you start
- Python 3.10 or later on the machine where the agent runs.
- A
memberAPI 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
adminrole in your organization. - A
viewerkey can read results but cannot submit scans.
Install the CertOne MCP server, certone-mcp, and make the key available to it:
pip install "certone-sdk[mcp]"
export CERTONE_API_KEY=ck_... # PowerShell: $env:CERTONE_API_KEY = "ck_..."| Tool | What it does |
|---|---|
certone_scan | Confidential 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_fixes | The 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_gate | Allows a release only for a passing verdict with a signed attestation. |
certone_attestation | The 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.
claude mcp add certone --env CERTONE_API_KEY=$CERTONE_API_KEY -- certone-mcp
claudeClaude 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.
{
"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.
{
"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}" }
}
}
}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:
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-modelwith 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:
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):
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())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_fixesagain. - Keep the API key in the agent's secret storage or environment, never in the repository.