MCP integration, in pilot
EN 18031 and CRA documentation, drafted with your coding agent
Much of what EN 18031 and the CRA ask about your product is answered in your code, not in a document. Connect the coding agent your developers already use: RedComply asks the standard's questions, your agent answers from the repository with file and line references, and RedComply drafts the tables. You review every one.
Both open the contact form. We reply by email.
Works with the coding agent you already use
- Claude Code
- Codex
- Cursor
- GitHub Copilot
- Any agent that supports MCP
RedComply connects through the Model Context Protocol (MCP), an open protocol. The agents shown are examples of agents that support it. The integration is in pilot, and we have not tested it with each of them.
One request, three tables drafted from your code
You ask in one sentence. Your coding agent calls RedComply's tools, answers the compliance agent's questions from the files it can read, and asks you only what the code does not say. RedComply writes the tables; your agent never does.
- You: Fill the EN 18031 technical documentation tables that are ready.
- Tool call: list_
technical_ documentation_ tables 3 tables ready - Tool call: start_
technical_ documentation_ table_ job AUM-5, SUM-2, AUM-6 in parallel - RedComply asks (SUM-2): How does the device check an update before installing it?
- Searching src/ota/ and docs/
- Answer: The Ed25519 signature of the image is verified before it is written to flash.
src/ota/verify.c:88-104if (!ed25519_verify(sig, digest, pubkey)) return OTA_REJECT; - Not in the code, asking you: Who is allowed to start an update on the device?
- You: Only our service tool, after it authenticates.
- Tool call: submit_
job_ answers sent as your statement - Tool call: confirm_
job_ draft draft checked against the code, confirmed - 3 tables drafted via MCP. They are waiting for your review in RedComply.
Illustrative session. File names and answers are examples; the tool names are the real ones.
Evidence from the code itself
Your agent is asked to back each answer with the file, the lines and a short quote, so a reviewer checks a statement against the source, not against a summary.
A person reviews every table
A table drafted this way counts for a declaration only after someone on your team has reviewed it. RedComply supports your self-assessment; it does not certify the product.
Three tables at a time, no copy and paste
Your agent keeps up to three tables in drafting at once and carries the answers from your repository to RedComply. Nobody pastes text between tools.
It picks up where it stopped
Jobs and answers are kept in RedComply, not in your terminal. When your agent starts again it sees where each table stands. A job waits 20 minutes for an answer, then ends. When your agent starts the table again, the answers already given are handed to the new job.
How the MCP server works with your coding agent
Your coding agent runs the session and finds the evidence in your code. RedComply does the compliance work: it asks the questions, writes the tables and computes the outcomes.
Connect once per project
In RedComply, open Connected agents in your project and create a connection key. Add RedComply's MCP server to your coding agent's configuration.
Ask your agent to fill the tables
One sentence is enough. Your agent lists the technical documentation tables with their state and starts a drafting job for each table that is ready, up to three in parallel. A table is ready when the tables it draws on are filled. One job drafts one table.
RedComply asks, your agent answers from the code
RedComply's compliance agent knows the standard and asks precise questions about your product. Your agent searches the repository and your local documents and answers with a file reference and a short quote. What it cannot find, it asks you.
RedComply drafts the table
The compliance agent writes the rows and their justifications. The outcome of a row is not written by an agent: RedComply computes it from the row's answers with the decision tree of the requirement, the same calculation as in the table editor. Your agent checks the draft against the code and confirms it or sends it back with a note.
You review
The table is saved and marked “Drafted via MCP, not yet reviewed”. A person opens it in RedComply and marks it as reviewed, or reverts it to the version it replaced (possible until the table is saved again). It counts for the declaration of conformity only after that review.
What stays where
RedComply has no tool that opens a file on your machine. Whatever it learns from your machine arrives in an answer from your agent, and an answer is limited to text, file references and short quotes.
Stays on your machine
- Your repository and source files
- Build files, configuration and credential files
- The documents you keep locally
- The search itself: your agent reads the files, RedComply does not
What RedComply receives
- The answers your agent gives to RedComply's questions
- File references: path, lines and commit
- Short quotes from the cited lines, at most 500 characters per reference
- What you state yourself, recorded as a user statement
- A short note your agent may add when it starts a job or sends a draft back
What stays under your control
- Each connection key opens one project, is valid 30 days at most and can be revoked at any time
- A job on a table that already has content starts only after your agent states that you approved it; that statement is recorded on the job. (An MCP draft not yet marked as reviewed can be drafted again without it.)
- Every draft is marked as not yet reviewed until a person reviews it
- Revert restores the version a draft replaced, until the table is saved again or marked as reviewed
The answers and quotes your agent sends are processed by RedComply's AI providers to draft the tables. They are kept with the job record for as long as your project exists, and they stay in the drafting agent's conversation history at those providers for as long as that agent exists. Your agent is instructed never to send keys, passwords or the content of credential files. RedComply also refuses references to credential files and text containing a private key or a token in a known format. It does not detect other secrets. What your coding agent sends to its own model provider, including the table content it reads from RedComply, is governed by your agreement with that provider.
What your agent can do in RedComply, now and next
The integration is in pilot. Technical documentation tables are the first workflow. The others are planned on the same connection and are not available yet.
Technical documentation tables (Available in the pilot)
EN 18031 and CRA
List every table of the project with its state, start drafting jobs for the tables that are ready, answer the questions and confirm the drafts, for the regulations of your project. A person reviews each table afterwards.
Test plan assessments (Coming next)
EN 18031
Planned: the assessments of the test plan worked through the same way, starting with the conceptual assessment.
Risk assessment (Coming next)
CRA
Planned: the cybersecurity risk assessment of Article 13 reached from your coding agent, with facts about architecture and design taken from the repository.
Risk register (Coming next)
CRA
Planned: read the risks and their countermeasure tasks from your editor, so the work the register asks for sits next to the code that implements it.
More project actions (Coming next)
EN 18031 and CRA
Planned: further RedComply actions on the same connection, with the same rule: RedComply writes the compliance content and a person reviews it.
In the browser, or with your coding agent
Both ways work on the same project and the same tables. Use the browser for what lives in documents and the coding agent for what lives in code.
Where the facts come from
- In the browser
- The documents you upload to the project's Knowledge Base
- With your coding agent
- Your repository and local documents, read by your own agent on your machine
Who answers RedComply's questions
- In the browser
- You, in the assistant chat
- With your coding agent
- Your coding agent, asked to give a file reference and a short quote; it asks you what it cannot find
Tables in progress
- In the browser
- The table you have open
- With your coding agent
- Up to three, without you switching between them
Who writes the compliance content
- In the browser
- RedComply's compliance agent
- With your coding agent
- RedComply's compliance agent; your coding agent never writes a table
Review
- In the browser
- The assistant asks you to confirm what it proposes, table by table
- With your coding agent
- Drafts are marked as not yet reviewed until a person reviews them in RedComply
Cost
- In the browser
- The AI credits of your account
- With your coding agent
- The same AI credits, at the same rates
| In the browser | With your coding agent | |
|---|---|---|
| Where the facts come from | The documents you upload to the project's Knowledge Base | Your repository and local documents, read by your own agent on your machine |
| Who answers RedComply's questions | You, in the assistant chat | Your coding agent, asked to give a file reference and a short quote; it asks you what it cannot find |
| Tables in progress | The table you have open | Up to three, without you switching between them |
| Who writes the compliance content | RedComply's compliance agent | RedComply's compliance agent; your coding agent never writes a table |
| Review | The assistant asks you to confirm what it proposes, table by table | Drafts are marked as not yet reviewed until a person reviews them in RedComply |
| Cost | The AI credits of your account | The same AI credits, at the same rates |
Connect Claude Code, Codex or Cursor in three steps
This is the whole setup once the pilot is on for your account.
Not in the pilot yet? Request early access
Create a key
Project → Connected agents → Connect a coding agent. The key is shown once.
Add the server
Point your agent at https://redcomply.com/mcp with the key as a Bearer token.
Ask
“Fill the technical documentation tables that are ready.”
# shell
export REDCOMPLY_MCP_KEY="rcmcp_xxxxxxxx_your-key"
# .mcp.json
{
"mcpServers": {
"redcomply": {
"type": "http",
"url": "https://redcomply.com/mcp",
"headers": {
"Authorization": "Bearer ${REDCOMPLY_MCP_KEY}"
}
}
}
}The shape of the configuration for an agent that reads a JSON MCP file. File name and format differ per agent: Connected agents in RedComply shows the snippet for Claude Code, Codex and Cursor. The key in this example is a placeholder.
- The key is shown once; RedComply stores only its hash
- It opens one project and nothing else in your account
- It is accepted only on the MCP address, not by the rest of RedComply
Frequently asked questions
Does RedComply get access to my source code?
Not to your repository. RedComply never reads it and has no tool that opens a file on your machine. Your coding agent reads the files locally and sends only its answers, file references (path, lines, commit) and short quotes from the lines it cites, at most 500 characters each. So a few lines of code can reach RedComply as a quote; the files do not. These answers and quotes are processed by RedComply's AI providers to draft the tables; they are kept with the job record in your project and stay in the drafting agent's conversation history at those providers. Your agent is instructed never to send keys, passwords or the content of credential files, and RedComply refuses text that contains a private key or a token of a known format.
Which coding agents does it work with?
With coding agents that support the Model Context Protocol (MCP) and can connect to a remote MCP server. Claude Code, Codex, Cursor and GitHub Copilot are examples of such agents. RedComply shows the setup for Claude Code, Codex and Cursor in the dashboard. The integration is in pilot: we have not tested it with each of these agents, nor with every version. RedComply is not affiliated with or endorsed by the vendors of these tools.
What is an MCP server?
The Model Context Protocol is an open protocol that lets an AI agent use the tools of another system. RedComply's MCP server gives your coding agent a small set of tools: list the tables of a project and read their rows, start a drafting job, read its questions, send answers, confirm or reject a draft and cancel a job. Through this connection the agent cannot do anything in RedComply outside these tools.
What can my agent do in RedComply today?
Draft the technical documentation tables of a project, for EN 18031 and for the CRA requirements, one drafting job per table and up to three in parallel. Test plan assessments, the CRA risk assessment and the risk register are planned on the same connection and are not available yet.
Does my coding agent write the compliance documentation?
No. Your coding agent runs the session and collects evidence. RedComply's own compliance agent, which works from the texts of the standards and RedComply's templates, writes the rows, and RedComply computes the outcome of each row with the decision tree of the requirement. Through this connection your agent can confirm a draft or send it back; it has no tool to write a table itself or to mark one as reviewed. That is done by a person in RedComply.
What if the agent gets something wrong?
Expect it to happen, and check. Your agent is asked to give the file, the lines and a quote for each answer, so the reviewer opens the source and compares. The outcome of a row is computed by RedComply with the decision tree of the requirement, not written by a model. The table stays marked “Drafted via MCP, not yet reviewed” until a person has reviewed it, and Revert restores the version the draft replaced until the table is saved again or marked as reviewed.
Who is responsible for the content?
You, the manufacturer. Every table drafted through the integration is marked “Drafted via MCP, not yet reviewed” and does not count for a declaration of conformity until a person has reviewed it in RedComply. RedComply supports your self-assessment and does not certify products; the conformity route of your product does not change.
Does it cost extra?
No separate fee. Drafting through the integration uses the AI credits of your RedComply account, at the same rates as the assistant in the browser. What your coding agent consumes on its side is billed by its own provider.
What happens when the agent cannot find an answer?
It is instructed to ask you. What you tell it is sent as your statement and recorded as such. If nobody knows, the agent says where it looked; RedComply asks again while it can, then drafts what the evidence supports, leaves the rest empty and lists it as an open point. Neither agent is meant to guess, which is one reason a person reviews every table.
Can it overwrite tables we already reviewed?
Not silently. RedComply refuses to start a job on a table that already has content until your agent confirms that you approved it. The one exception is an MCP draft that nobody has marked as reviewed yet, even if someone edited it: a new job starts from its current rows. The agent is instructed to ask you first and never to decide this on its own, and the approval is recorded in the job history. The table then goes back to “not yet reviewed” and blocks the declaration until a person reviews it again. Revert restores the version the draft replaced until the table is saved again or marked as reviewed.
How do I get access?
The integration is in pilot and open to a limited number of manufacturers. Use “Request early access” on this page: it opens the contact form with the message filled in. We reply by email, ask about your product and the coding agent your team uses, and tell you whether the pilot fits. You need a RedComply account with a project.
Claude Code, Codex, Cursor and GitHub Copilot are shown as examples of agents that support the Model Context Protocol. These names and logos, and the Model Context Protocol mark, belong to their respective owners. Showing them does not imply endorsement or partnership.