Polyspace Agentic Toolkit

Run Polyspace® as You Code™ static code analysis on your C/C++ code using AI applications with the official Polyspace® Agentic Toolkit from MathWorks®.

What It Does

The Polyspace Agentic Toolkit gives your agent the knowledge and context to work with Polyspace efficiently. With the Polyspace MCP Server and its companion skills, you can ask your AI assistant to perform Polyspace as You Code and Polyspace Test workflows. For example:

• "Make this file compliant with <coding standard>" — Run a Polyspace as You Code analysis, fix violations, and re-run analysis until the file is clean.
• "Check that my changes are compliant" — Analyze a modified file and address any new findings.
• "Fix these findings" — Understand each finding, apply a code fix, and re-run analysis to confirm.
• "Justify this finding" — Insert a correctly formatted Polyspace annotation comment, optionally using pre-approved texts from a team justification catalog.
• "Set up <coding standard> checking" — Create or modify the checkers XML file to enable specific coding standards.
• "Configure build options for my project" — Generate a build options file from a build command or compile_commands.json.
• "What does the -target option do?" — Look up documentation for any Polyspace option, checker, or coding rule.
• "Generate unit tests for this function" — Write tests using the Polyspace XUnit framework (PSTUnit).

How It Works

                        +-------------------+
                        |    AI Assistant   |
                        |  (Claude, Copilot,|
                        |   Amp, Cursor...) |
                        +--------+----------+
                                 |
                    reads skills |  calls tools
                    (markdown)   |  (MCP protocol)
                                 |
          +----------------------+----------------------+
          |                                             |
          v                                             v
  +----------------+                         +--------------------+
  | skills-catalog/|                         | Polyspace MCP      |
  | SKILL.md files |                         | Server (binary)    |
  +----------------+                         +--------+-----------+
                                                      |
                                                      v
                                             +------------------+
                                             | Polyspace as You |
                                             | Code (binary)    |
                                             +------------------+

The AI assistant reads skills (instructional markdown files) for domain knowledge and calls MCP tools for execution. Skills work with or without the MCP server. Each skill includes both the MCP tool path and a direct binary fallback.

Supported Platforms

Polyspace as You Code R2026a recommended. Previous versions back to R2024b are supported.

The Polyspace Agentic Toolkit is supported on Linux, macOS, and Windows operating systems.

Quick Start

Prerequisites:

• Polyspace as You Code R2024b or later
• Supported AI coding agent
• Git™

The Polyspace Agentic Toolkit helps you install and configure the Polyspace MCP Core Server, or can be configured to use your existing installation.

Full Setup (recommended)

Clone the repository to a permanent location.

git clone https://github.com/mathworks/polyspace-agentic-toolkit.git
cd polyspace-agentic-toolkit

Launch your agent from the toolkit directory, and ask it to set up the toolkit.

Set up the Polyspace Agentic Toolkit

The agent:

• Reads the setup skill
• Detects your platform
• Locates your Polyspace installation
• Detects which Polyspace products you have installed (as You Code, Bug Finder, Code Prover, Test)
• Downloads and registers the MCP server binary with your agent
• Installs only the skills for the products you have — you confirm the set before anything is installed

Why selective? The toolkit ships skills for every Polyspace product, but agents trigger the right skill more reliably when fewer are loaded. Setup therefore installs only the skill groups matching your installed products (plus the always-on polyspace-core, and the shared polyspace-static-core whenever any static-analysis product is present). To add or remove products later, just re-run setup ("Set up the Polyspace Agentic Toolkit") and adjust the confirmed set.

Claude Code — no clone required: If you already have the MCP server binary configured, you can add the skills directly without cloning. Always install polyspace-core. For static analysis (Polyspace as You Code, Bug Finder, or Code Prover), also install the shared polyspace-static-core plugin plus the product plugin(s) you have. Add only the plugins matching your installed Polyspace products:

claude plugin marketplace add "https://github.com/mathworks/polyspace-agentic-toolkit"
claude plugin install polyspace-core@polyspace-agentic-toolkit          # always
claude plugin install polyspace-static-core@polyspace-agentic-toolkit   # shared review/fix/justify — with any static-analysis product
claude plugin install polyspace-as-you-code@polyspace-agentic-toolkit   # Polyspace as You Code (file-level analysis)
claude plugin install polyspace-bug-finder@polyspace-agentic-toolkit    # Polyspace Bug Finder (multi-file / component)
claude plugin install polyspace-code-prover@polyspace-agentic-toolkit   # Polyspace Code Prover (prove absence of run-time errors)
claude plugin install polyspace-test@polyspace-agentic-toolkit          # Polyspace Test

Already Have the MCP Server Binary?

If you installed the binary manually, you just need skills. Clone this repo and ask your agent: "Set up the Polyspace Agentic Toolkit" to skip the download and configure skills only.

Verify

Ask your agent:

Run Polyspace on a sample file and show me the results.

The agent searches the current directory for a C or C++ file to run an analysis on. If no file is found, the agent creates a sample file with some existing defects, runs an analysis on the file, and displays Polyspace results.

MCP Tools

The Polyspace Agentic Toolkit provides the following tools:

Code Prover–specific tools are registered only when a Code Prover analysis is active.

Agent Skills

Skills are instructional markdown guides in skills-catalog/ that teach the AI assistant how to perform Polyspace workflows. Each skill has a SKILL.md with step-by-step instructions and a manifest.yaml with metadata.

Skills are organized into groups. Automated setup installs only the groups you need — the mapping below is what it applies, and what to install by hand if you prefer:

Two invariants: polyspace-core is always installed, and polyspace-static-core is installed as soon as any static-analysis product (as You Code, Bug Finder, or Code Prover) is present — it holds the review/fix/justify workflow those products share. polyspace-test drives dynamic testing and does not require polyspace-static-core. Install only the groups for the products you actually have: agents trigger the right skill more reliably when fewer are loaded. In Claude Code the invariant is enforced for you — each product plugin declares polyspace-static-core as a dependency, so installing polyspace-as-you-code, polyspace-bug-finder, or polyspace-code-prover pulls it in automatically.

Polyspace Core

Always installed.

Polyspace Static Core

Shared static-analysis skills. Install alongside any static-analysis product (Polyspace as You Code, Bug Finder, or Code Prover).

Polyspace as You Code

Install if you have Polyspace as You Code. File-level analysis of the file you are editing.

Polyspace Bug Finder

Install if you have Polyspace Bug Finder. Multi-file / whole-component analysis.

Polyspace Code Prover

Install if you have Polyspace Code Prover. Prove the absence of run-time errors.

Polyspace Test

Install if you have Polyspace Test.

Setup

The setup skill is read in place from the cloned repository during installation — it is not installed as a plugin.

Polyspace Configuration Files

Several Polyspace MCP Server tools accept paths to configuration files that are typically shared across a team or organization. These files can live anywhere accessible to the AI assistant. For example, they can be checked into the repository alongside the source code, stored on a shared network drive, or maintained in a central location by your team.

To have your AI assistant use these files automatically, create an agent instructions file at the root of your project. Most AI applications support a project-level instructions file that the assistant reads at the start of every conversation:

Add instructions like the following to your project's instructions file, replacing the paths with the actual locations of your team's configuration files:

## Polyspace Configuration

When running Polyspace analysis on C/C++ files, always use these team configuration files:

- Checkers: /path/to/checkers.xml
- Build options: /path/to/build_options_file.txt
- Options: /path/to/options_file.txt

When querying the justification catalog for pre-approved texts, use:
- Catalog: /path/to/justification_catalog.json

Arguments

Customize the behavior of the server by providing arguments in the args array when configuring your AI application.

Arguments can also be set via environment variables: POLYSPACE_ROOT.

Data Collection

The Polyspace MCP Server may collect fully anonymized information about your usage of the server and send it to MathWorks. This data collection helps MathWorks improve products and is on by default. To opt out of data collection, set the argument --disable-telemetry to true.

Contributing

We welcome feedback through GitHub Issues. Pull requests are reviewed for ideas and feedback but are not merged from external contributors. See CONTRIBUTING.md for details.

Security Considerations

When using the Polyspace Agentic Toolkit and Polyspace MCP Server, you should thoroughly review and validate all tool calls before you run them. Always keep a human in the loop for important actions and only proceed once you are confident the call will do exactly what you expect. For more information, see User Interaction Model (MCP) and Security Considerations (MCP).

Licensing and Usage

The license is available in the LICENSE.md file in this GitHub repository.

MCP servers are only permitted to be used with MATLAB and Polyspace in accordance with the MathWorks Software License Agreement, and must not be shared by multiple users. Contact MathWorks if you need to support shared or centralized server use.

Contact Support

MathWorks encourages you to use this repository and provide feedback. To request technical support or submit an enhancement request, create a GitHub issue or contact technical support. For Polyspace as You Code issues and support, see the Polyspace as You Code documentation.

Copyright 2026 The MathWorks, Inc.