# CarMaker (pypi · carmaker-mcp)

Drive IPG CarMaker for Simulink: run test runs, read results, edit vehicle data and parameters.

- Trust score: 90/100 (high trust)
- Change this week: +3
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- pypi · `carmaker-mcp`: 90/100 (this document), [markdown](https://verifymcp.io/servers/dimitr-io-carmaker-mcp/carmaker-mcp.md), [page](https://verifymcp.io/servers/dimitr-io-carmaker-mcp/carmaker-mcp)

## Channel facts

- Registry: `pypi`
- Package: `carmaker-mcp`
- Version: `0.3.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 1 of 16 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 100/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to dimitr-io/carmaker-mcp).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 3 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 78/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 8019 tokens (~138/item across 58 items; 54 tools + 4 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 57/100
  - Stability observed for 17 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (93% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - All 2 tool(s) whose name or description implies an irreversible operation declare an MCP destructiveHint annotation.
  - An AI judge read all 56 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

## Install

### How do I install the CarMaker MCP server?

CarMaker runs locally as a PyPI package, launched with uvx carmaker-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add dimitr-io-carmaker-mcp -- uvx carmaker-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "dimitr-io-carmaker-mcp": {
      "command": "uvx",
      "args": [
        "carmaker-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "dimitr-io-carmaker-mcp": {
      "command": "uvx",
      "args": [
        "carmaker-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add dimitr-io-carmaker-mcp -- uvx carmaker-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "dimitr-io-carmaker-mcp": {
      "type": "local",
      "command": [
        "uvx",
        "carmaker-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add dimitr-io-carmaker-mcp --command uvx --arg carmaker-mcp
```

### Hermes

```yaml
mcp_servers:
  dimitr-io-carmaker-mcp:
    command: "uvx"
    args: ["carmaker-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "dimitr-io-carmaker-mcp": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "carmaker-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add dimitr-io-carmaker-mcp -t stdio -c uvx -a carmaker-mcp
```

### Other

```json
{
  "mcpServers": {
    "dimitr-io-carmaker-mcp": {
      "command": "uvx",
      "args": [
        "carmaker-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-05 (score 90, +16)

- [security improvement] Malware scan: unverified → pass

### 2026-11-04 (score 74, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-02 (score 89, +1)

No change was recorded against any check on this day. Stability & Change Management went from 43 to 47. That category is still filling its 30-day observation window: 13 days of observed history at the previous scan, 14 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-11-01 (score 88, 0)

- [security regression] Stability: 0.40 → unverified
- [security regression] Tool safety: pass → unverified
- [functional regression] Schema quality: 106 → 138
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Schema quality: 100 → unverified
- [functional] Package version: 0.2.2 → 0.3.0

### 2026-10-30 (score 88, +1)

No change was recorded against any check on this day. Stability & Change Management went from 33 to 37. That category is still filling its 30-day observation window: 10 days of observed history at the previous scan, 11 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-27 (score 87, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-25 (score 86, +1)

No change was recorded against any check on this day. Stability & Change Management went from 17 to 20. That category is still filling its 30-day observation window: 5 days of observed history at the previous scan, 6 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-23 (score 85, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

## MCP tools (54)

### `cm_session_start` (~247 tokens)

Start the CarMaker for Simulink session

Bring up a CarMaker for Simulink session as far as it is missing: start MATLAB (visible, in the
project's src_cm4sl folder, engine shared), run cmenv, open the Simulink model and open the CarMaker
GUI. Nothing is restarted or closed. Returns ready=true, or ready=false with what it is waiting
for: call again until ready. Without a model it opens none and lists models_loaded and
models_found to choose from. Many projects need their own setup script before the model compiles:
if init_scripts_found lists one, pass it as init.

Input parameters:

- `init`: The project's own MATLAB setup script, run once per MATLAB session before the model is opened (default: CM_MATLAB_INIT). A name from init_scripts_found, or a full path
- `max_wait_s` (number): Longest time to wait in s, at most 50 (larger values are cut to 50); call again if not finished
- `model`: Simulink model to open: a name on the MATLAB path, a path as listed in models_found, or a full path (default: CM_MODEL)

### `cm_doctor` (~68 tokens)

Check the setup

Check the setup: CarMaker install, Python version, MATLAB release and engine, shared MATLAB
session, GUI, project folder. Each failed check comes with its fix. ok: at least one mode is ready
(see ready); all_checks_passed: everything, the MATLAB session included.

### `cm_status` (~124 tokens)

Simulation status

The MATLAB session (CarMaker for Simulink) only; standalone work needs none of it (cm_doctor).
Simulation state (sim_status; sim_status_code is CarMaker's raw value, -2 idle, 0 or more running),
matlab_simstate (Simulink's model state: 'terminated' is normal when idle), active model, project
directory, last end status, the GUI's storage mode (save_mode) and gui_all_saved (false: the GUI
holds unsaved data and will ask before a load; true is no guarantee).

Output parameters:

- `active_model`
- `connected` (boolean)
- `details` (object)
- `end_status`
- `gui_all_saved` (boolean)
- `matlab_simstate`
- `project_dir`
- `save_mode` (string)
- `session_id`
- `sim_status` (string)
- `sim_status_code`
- `standalone_note` (string)

### `cm_load_testrun` (~89 tokens)

Load a test run

Load a test run into the CarMaker GUI. Requires an idle simulation. Find names with
cm_list('testrun').

Input parameters:

- `force` (boolean): Do not let the GUI ask about unsaved data; that data is discarded
- `name` (string, required): Test run relative to Data/TestRun, e.g. 'Examples/BasicFunctions/Driver/BackAndForth'

### `cm_start_sim` (~200 tokens)

Start the simulation

Start the loaded test run. Returns once it is running; fails at once, with Simulink's error,
if the model does not compile. Then call cm_wait_end until it reports finished.

Input parameters:

- `save` (string): save: write a result file (GUI storage mode becomes 'Save all', cm_revert_all puts it back). collect: buffer only. keep: leave the GUI setting alone
- `save_logs` (boolean): Also save what Simulink logged in this run to a MAT file next to the result file (a Simulink Dataset, for MATLAB; for Python call cm_model_logs_save(format='struct', file=...)); cm_wait_end returns l…
- `speed`: x real time; omit for CarMaker's maximum. Slower only if the user asks
- `start_timeout_s` (number): How long the start may take (a Simulink model may compile first)

Output parameters:

- `after_s` (number)
- `carmaker_project_restored` (object)
- `matlab_folder_restored` (object)
- `note` (string)
- `popups` (array)
- `save_mode`
- `started` (boolean)
- `state` (string)

### `cm_stop_sim` (~51 tokens)

Stop the simulation

Stop the running simulation. With wait_s > 0 it returns what cm_wait_end returns.

Input parameters:

- `wait_s` (number): Wait this long for the simulation to become idle (0: do not wait)

Output parameters:

- `distance_m` (number)
- `elapsed_s` (number)
- `end_status`
- `finished` (boolean)
- `live` (object)
- `log_errors` (array)
- `log_warnings` (array)
- `logs_error` (string)
- `logs_file` (string)
- `note` (string)
- `poll_errors` (integer)
- `popups` (array)
- `result_file`
- `sim_time_s` (number)
- `simulink_error` (string)
- `state` (string)
- `stop_requested` (boolean)
- `testrun` (string)
- `waited_s` (number)

### `cm_wait_end` (~113 tokens)

Wait for the simulation to end

Wait until the simulation is idle again. finished=true: end status, simulation time and
distance, result_file, new log errors and warnings (settings CarMaker ignored show up there) and
pop-ups. finished=false: current state and live values;
call again to keep waiting.

Input parameters:

- `poll_s` (number): Seconds between status polls
- `timeout_s` (number): Longest time to wait in s, at most 50 (larger values are cut to 50); call again if not finished

Output parameters:

- `distance_m` (number)
- `elapsed_s` (number)
- `end_status`
- `finished` (boolean)
- `live` (object)
- `log_errors` (array)
- `log_warnings` (array)
- `logs_error` (string)
- `logs_file` (string)
- `note` (string)
- `poll_errors` (integer)
- `popups` (array)
- `result_file`
- `sim_time_s` (number)
- `simulink_error` (string)
- `state` (string)
- `stop_requested` (boolean)
- `testrun` (string)
- `waited_s` (number)

### `cm_log` (~65 tokens)

Read the CarMaker session log

Last lines of the newest CarMaker session log of the project. Use it when a run aborts or does
not start.

Input parameters:

- `level` (string): warning: warnings and errors only; error: errors only
- `lines` (integer): Number of lines from the end

### `cm_live` (~46 tokens)

Read live quantities

Current values of CarMaker quantities during a run (or the last values after it).

Input parameters:

- `quantities` (array, required): CarMaker quantity names, e.g. ['Time', 'Car.v']

### `cm_dva_write` (~98 tokens)

Overwrite a quantity (DVA)

Overwrite a quantity during a run via Direct Variable Access.

Input parameters:

- `duration_ms` (integer): How long the override lasts in ms (-1: until released or the run ends)
- `mode` (string): Absolute value, offset or factor; Ramp variants blend in
- `name` (string, required): Quantity to overwrite, e.g. 'DM.Gas'
- `value` (number, required): Value, offset or factor, depending on mode

### `cm_dva_release` (~18 tokens)

Release DVA overrides

Release all quantities from DVA control.

### `cm_popups` (~125 tokens)

Read GUI pop-ups

Pop-up messages the CarMaker GUI raised for this server's commands (type info/warn/err/question,
text, index of the answer given) and the current pop-up timeout. Also the "Internal Debugger" dialog
that the GUI or IPGMovie shows after an error of its own (type 'internal error', with the program
and the call stack): it is read and then closed. Reading empties the GUI's buffer (it keeps five).
cm_load_testrun, cm_start_sim and cm_wait_end already return new ones as 'popups'.

### `cm_popup_timeout` (~125 tokens)

Let GUI pop-ups answer themselves

Let GUI pop-ups raised by this server's commands answer themselves with their DEFAULT choice, so
that a question such as 'Vehicle not saved. All changes will be lost. OK to continue?' cannot block
a run. The default answer there discards the unsaved changes. Read what was answered with
cm_popups. Stays until set back, cm_revert_all or a GUI restart.

Input parameters:

- `seconds` (number, required): Seconds until a pop-up answers itself; 0 = never shown; -1 = wait for a click in the GUI (the normal setting)

### `cm_results_list` (~48 tokens)

List result files

Newest .erg result files under the project's SimOutput folder, CM_RESULT_DIRS and the folders
this session's runs wrote to.

Input parameters:

- `limit` (integer): Maximum number of files

Output parameters:

- `result` (array)

### `cm_results_summary` (~103 tokens)

Summarise a result file

First / last / min / max / mean and unit of quantities in a result file, plus rows and duration.

Input parameters:

- `erg` (string, required): Result file (.erg): absolute path, or relative to the project
- `quantities`: Quantities to summarise (default: Time, Car.v)
- `search`: Instead of a summary, list the quantity names that contain this text ('PT.') or match this wildcard pattern ('Car.v*'; '*' lists all)

### `cm_results_read` (~111 tokens)

Read time series from a result file

Time series from a result file, decimated to at most max_points samples.

Input parameters:

- `erg` (string, required): Result file (.erg): absolute path, or relative to the project
- `max_points` (integer): Samples are thinned to at most this many per quantity
- `quantities` (array, required): CarMaker quantity names, e.g. ['Time', 'Car.v']
- `t_max`: End of the time window in s
- `t_min`: Start of the time window in s

### `cm_results_export` (~172 tokens)

Export a result file

Write quantities of a result file at full resolution (no thinning) to a MAT file (one double
variable per quantity, dots as underscores, plus quantity_names and units) or a CSV file (header
'Time [s],Car.v [m/s],...': name and unit), in any folder of this computer. Never overwrites.

Input parameters:

- `erg` (string, required): Result file (.erg): absolute path, or relative to the project
- `file`: Target .mat or .csv (absolute, or relative to the result file's folder); default next to it
- `format` (string): When file is not given
- `quantities`: Default: all
- `t_max`: End of the time window in s
- `t_min`: Start of the time window in s

### `cm_results_plot` (~159 tokens)

Plot result files in IPGControl

Plot quantities of result files in IPGControl, IPG's plotting program; needs no MATLAB. The window
stays open for the user (the next plot replaces it) and a picture comes back as an image. This
server has no MATLAB evaluation: for MATLAB figures use a MATLAB server, or cm_results_export.

Input parameters:

- `ergs` (array, required): Result files (.erg), absolute or relative to the project; several are overlaid
- `picture` (boolean): Also return a picture of the plot
- `quantities` (array, required): Quantities to plot, e.g. ['Car.ay', 'Car.YawRate']
- `x`: Quantity for the x axis (default: Time), e.g. 'Car.Distance'

### `cm_driver_adaption` (~294 tokens)

Driver adaption

Let IPGDriver learn the car (basic) or the car on this circuit (race), and save the knowledge.
It takes minutes (basic about 2 standalone, 5 to 20 with MATLAB; race as long as the test run allows):
run it only when the car changed noticeably, the race driver lacks knowledge, or the user asks, and
tell the user the duration first. Start returns at once; then 'wait' until state is done/failed.

Input parameters:

- `action` (string, required): wait: until it ends or timeout_s. close: end the CarMaker GUI the server opened for standalone adaptions (it stays open for the next one; it ends with the server)
- `kind` (string): basic: learn the car (needed first); race: laps of a closed circuit
- `knowledge`: Knowledge set to learn into (default: the active one, else DefaultDriverKnowledge)
- `learning_rate` (number): race: 0 sensitive .. 1 aggressive
- `mode` (string): auto: the MATLAB session if connected
- `save` (boolean): Save the knowledge (template file or test run; backed up)
- `testrun`: Load this test run first (needed standalone)
- `timeout_s` (number): Longest time to wait in s, at most 50 (larger values are cut to 50); call again if not finished

### `cm_guide` (~51 tokens)

Read a section of the guide

A section of this server's guide (the same text as the resource carmaker://guide).

Input parameters:

- `topic`: e.g. 'ipgdriver', 'driver', 'parameters'; none lists the topics

Output parameters:

- `result` (string)

### `cm_results_crossings` (~152 tokens)

Times at which a quantity reaches values

Interpolated times at which a quantity crosses each value, and the time between the first
crossings of consecutive values (lap or sector times from distance gates); with `at`, the values of
other quantities there (the speed at 75 m).

Input parameters:

- `at`: Other quantities to read at each first crossing, e.g. ['Car.v', 'Car.ax']
- `direction` (string): Which crossings
- `erg` (string, required): Result file (.erg): absolute path, or relative to the project
- `quantity` (string, required): e.g. 'Car.Distance' for gates along the course
- `values` (array, required): Values to find, e.g. gate distances in m

### `cm_output_quantities` (~73 tokens)

Read the output quantities

The quantities the next run writes to its result file, per storage rate (names may hold
wildcards), with the sample times. movie_replay says whether such a result file can be replayed in
IPGMovie. What a finished result file holds: cm_results_summary(erg, search='*').

### `cm_output_quantities_edit` (~160 tokens)

Change the output quantities

Add quantities to, or remove them from, the project's output-quantities file (backed up first,
logged, restored by cm_revert_all). Applies from the next start. Requires an idle simulation. Find
names with cm_live (it reads any quantity) or in another result file.

Input parameters:

- `add`: Quantities to store as well, e.g. ['Car.az', 'PT.Motor*.Trq']; wildcards * and ? allowed
- `preset`: movie: add what IPGMovie needs to replay the vehicle from a result file
- `rate` (string): Storage rate for added quantities (sample times: cm_output_quantities)
- `remove`: Entries to take out, spelled as they are listed

### `cm_movie_open` (~111 tokens)

Open IPGMovie

Open IPGMovie, CarMaker's 3D animation window (or take over one that is open). Open it BEFORE a
run: it records a run only while it is open, and cm_movie_snapshot can then show any moment of it.
Needs the MATLAB session; without it use cm_standalone_launch(movie=true).

Input parameters:

- `restart` (boolean): Close a running IPGMovie and start it anew: the way out when its pictures fail with an internal error. It then holds no run

### `cm_movie_snapshot` (~285 tokens)

Take a picture in IPGMovie

A picture of IPGMovie's 3D view, returned as an image. After a run it shows any moment of the last
run (time_s), provided IPGMovie was open during that run. During a run, without time_s, it shows the
IPGMovie window as it is at that moment (in the window's own size). With erg it replays a saved
result file, which must hold the vehicle's motion (cm_output_quantities_edit(preset='movie') before
that run). Do not pass time_s during a run: that makes IPGMovie stop following the run. Needs the
MATLAB session's IPGMovie (cm_movie_open); a standalone IPGMovie (movie=true) has no pictures.

Input parameters:

- `camera`: Camera view: 'DEFAULT', "Bird's Eye View", 'Left Side', 'Right Side', 'Sitting In Vehicle (A)', or one from the project (default: keep the view)
- `erg`: Replay this result file instead of the last run (absolute path, or relative to the project)
- `height` (integer): Picture height in pixels (not during a run)
- `time_s`: Simulation time of the picture in s (default: the latest moment IPGMovie holds)
- `width` (integer): Picture width in pixels (not during a run)

### `cm_list` (~81 tokens)

List project data files

Names of project data files of one kind (test runs, vehicles, drivers, tyres...).

Input parameters:

- `include_hidden` (boolean): Also list names starting with a dot
- `kind` (string, required): Kind of project data; selects the folder below <project>/Data
- `pattern`: Wildcard filter on the name, e.g. '*Brak*'

### `cm_read` (~194 tokens)

Read a project data file

Key / value pairs of a CarMaker infofile, 300 at a time: filter by keys, prefix or search, or page
with offset. For a test run first `driver` (its template or 'TestRun', knowledge, main limits) and,
also for a vehicle, `standalone`: false names the vehicle's Simulink parts (runs need the MATLAB
session).

Input parameters:

- `keys`: Only these keys
- `kind` (string, required): Kind of project data; selects the folder below <project>/Data
- `name` (string, required): File name relative to the kind's folder, as cm_list returns it
- `offset` (integer): Skip this many keys (paging: next_offset)
- `prefix`: Only keys starting with this, e.g. 'Vehicle' or 'DrivMan.'
- `search`: Only keys containing this, any case, e.g. 'Control.Kind'

### `cm_diff` (~96 tokens)

Compare two project data files

Keys only in a, only in b, and those whose values differ ([a, b]), e.g. two vehicles or a test
run and its clone.

Input parameters:

- `a` (string, required): First file, relative to the kind's folder
- `b` (string, required): Second file
- `kind` (string, required): Kind of project data; selects the folder below <project>/Data
- `prefix`: Only keys starting with this

### `cm_edit` (~139 tokens)

Edit a project data file

Change keys in a project file in place (backed up first, logged; only the edited lines change).
Requires an idle simulation; load the test run again afterwards. Driver parameters belong in the
driver template (kind 'driver', 'Template/<name>'), which other test runs share: say which changed.

Input parameters:

- `kind` (string, required): Kind of project data; selects the folder below <project>/Data
- `name` (string, required): File name relative to the kind's folder
- `overrides` (object, required): Keys to set, e.g. {'Road.FName': 'SKIDPAD.rd5'}; a null value removes the key

### `cm_clone` (~97 tokens)

Copy a project data file

Copy a project file to a new name in the same kind's folder. Never overwrites. A copied test run
keeps the source's driver and knowledge (`driver`): check them for another vehicle.

Input parameters:

- `base` (string, required): Existing file to copy
- `kind` (string, required): Kind of project data; selects the folder below <project>/Data
- `new_name` (string, required): Name of the copy (must not exist)

### `cm_create` (~125 tokens)

Create a project data file

Write a new project file, for example a tyre property file that differs from an existing one.
Never overwrites; the file is logged and cm_revert_all moves it to the trash folder. To change a
file that exists use cm_edit, to copy one cm_clone.

Input parameters:

- `content` (string, required): The whole text of the file, at most 2 MB
- `kind` (string, required): Kind of project data; selects the folder below <project>/Data
- `name` (string, required): Name of the new file relative to the kind's folder (must not exist)

### `cm_list_workspace_vars` (~92 tokens)

List workspace variables

Variables (name, class, size) of the MATLAB base workspace or of a Simulink model's workspace.
Controller parameters usually live in the model workspace.

Input parameters:

- `pattern`: Wildcard filter on the name, e.g. 'Kp_*'
- `scope` (string): 'base' for the MATLAB base workspace, or the name of a loaded Simulink model for that model's workspace

### `cm_get_workspace_var` (~84 tokens)

Read a workspace variable

Value of a variable or field. MATLAB objects are described, not converted: read their fields.

Input parameters:

- `name` (string, required): Variable or field, e.g. 'Kp_12' or 'Table.Value'
- `scope` (string): 'base' for the MATLAB base workspace, or the name of a loaded Simulink model for that model's workspace

### `cm_set_workspace_var` (~147 tokens)

Set a workspace variable

Set a variable or field. The old value is logged and cm_revert_all restores it. Model-workspace
changes live in memory until cm_model_save. Requires an idle simulation. overruled_by in the answer:
the model has a variable of that name in its own workspace and uses that one, so set it there.

Input parameters:

- `name` (string, required): Variable or field, e.g. 'Kp_12' or 'Table.Value'
- `scope` (string): 'base' for the MATLAB base workspace, or the name of a loaded Simulink model for that model's workspace
- `value` (required): Number, string, list or nested list (matrix)

### `cm_model_get` (~58 tokens)

Read a Simulink parameter

get_param on a loaded Simulink model or block.

Input parameters:

- `param` (string, required): Parameter name, e.g. 'Gain'
- `path` (string, required): Model or block path, e.g. 'MyModel/Controller/Gain'

### `cm_model_set` (~85 tokens)

Set a Simulink parameter

set_param on a loaded Simulink model or block. Logged; cm_revert_all restores the old value.

Input parameters:

- `param` (string, required): Parameter name
- `path` (string, required): Model or block path
- `save` (boolean): Also back up and save the model file
- `value` (required): New value (numbers are converted to text as Simulink expects)

### `cm_model_save` (~43 tokens)

Save a Simulink model

Save a loaded Simulink model. The file must be inside the project; it is backed up first.

Input parameters:

- `model` (string, required): Name of the loaded model

### `cm_model_logs_save` (~300 tokens)

Save Simulink's logged data to a MAT file

After a CarMaker for Simulink run: write what Simulink logged (signals marked for logging and
To Workspace blocks) to a MAT file, with the base workspace and the model workspace as one struct
each (variables: signals, base_workspace, model_workspace, info); the answer lists signal_names.
Requires an idle simulation. The result file (.erg) holds CarMaker's quantities, this the Simulink
side. To see whether a signal is logged, run with save_logs=true and read signal_names.

Input parameters:

- `base_workspace` (boolean): Include the base workspace's variables
- `file`: MAT file to write, inside the project (default: next to the last result file, with the same name)
- `format` (string): dataset: a Simulink.SimulationData.Dataset. struct: plain arrays (name, time, values, units, block) that load without Simulink
- `logs` (string): inspector: every signal the Simulation Data Inspector holds for the last run (logged signals and To Workspace blocks, complete). workspace: the logging variables in the base workspace as they are
- `model`: Loaded Simulink model (default: the active one)
- `model_workspace` (boolean): Include the model workspace's variables
- `overwrite` (boolean): Replace the file if it exists
- `timeout_s` (number): Longest time MATLAB may take to write the file

### `cm_standalone_servers` (~47 tokens)

List running CarMaker programs

CarMaker simulation programs running on this machine (pid, description, whether this server
manages it). A CarMaker Office window you opened shows up once its application is started.

Output parameters:

- `result` (array)

### `cm_standalone_launch` (~287 tokens)

Launch a standalone CarMaker run

Start a NEW independent CarMaker simulation program (not connected to MATLAB) and run a test run
on it. Only for test runs whose vehicle does not need a Simulink controller. Results go to the
project's SimOutput; see cm_standalone_results. start=false only opens CarMaker (and IPGMovie).

Input parameters:

- `driver`: Driver template values for this program only, in a copy removed when it closes
- `executable`: CarMaker executable (default: the stock one of the install)
- `movie` (boolean): Show the run in IPGMovie (the program has no window; IPGMovie closes with it)
- `overrides`: Test-run keys to change in memory only, e.g. {'Vehicle': 'Car_B'} for another car. Vehicle keys (Body.mass) do not reach a standalone run: clone the vehicle
- `quantities`: Quantities to store (default: Time, Car.v, Car.YawRate, Car.ax, Car.ay, Car.Distance)
- `speed`: x real time; omit for CarMaker's maximum. Slower only if the user asks
- `start` (boolean): Start the run at once
- `stop_after_s`: Safety stop at this simulation time in s (null: none)
- `testrun` (string, required): Test run relative to Data/TestRun

### `cm_standalone_attach` (~175 tokens)

Attach to a running CarMaker program

Attach to a CarMaker simulation program that is already running, for example one started from a
CarMaker Office window.

Input parameters:

- `overrides`: Test-run keys to change in memory only, e.g. {'Vehicle': 'Car_B'} for another car. Vehicle keys (Body.mass) do not reach a standalone run: clone the vehicle
- `pid` (integer, required): Process id from cm_standalone_servers
- `quantities`: Quantities to store
- `speed`: x real time; omit for CarMaker's maximum. Slower only if the user asks
- `start` (boolean): Start the run at once (needs testrun)
- `stop_after_s`: Safety stop at this simulation time in s
- `testrun`: Test run to configure (needed to start a run)

### `cm_standalone_status` (~60 tokens)

Standalone instance status

State of a standalone instance plus live values.

Input parameters:

- `instance`: Standalone instance id such as 'sa1' (may be omitted while there is only one)
- `quantities`: Live quantities to read (default: Time, Car.v)

### `cm_standalone_control` (~94 tokens)

Control a standalone run

Start, pause, resume or stop the simulation of a standalone instance, or open its IPGMovie. A
study with movie=true runs on one instance: cm_standalone_status shows it.

Input parameters:

- `action` (string, required): movie: (re)open IPGMovie for the program
- `instance`: Standalone instance id such as 'sa1' (may be omitted while there is only one)

### `cm_standalone_wait_end` (~103 tokens)

Wait for a standalone run to end

Wait until the instance's simulation has finished. finished=true: simulation time and distance,
error flag and log errors. finished=false: call again to keep waiting.

Input parameters:

- `instance`: Standalone instance id such as 'sa1' (may be omitted while there is only one)
- `timeout_s` (number): Longest time to wait in s, at most 50 (larger values are cut to 50); call again if not finished

### `cm_standalone_dva_write` (~92 tokens)

Overwrite a quantity in a standalone run (DVA)

Overwrite a quantity in a running standalone simulation (Direct Variable Access).

Input parameters:

- `duration_ms` (integer): How long the override lasts in ms (-1: until the run ends)
- `instance`: Standalone instance id such as 'sa1' (may be omitted while there is only one)
- `name` (string, required): Quantity to overwrite
- `value` (number, required): Absolute value

### `cm_standalone_results` (~56 tokens)

Result files of a standalone run

Result .erg files of the instance's run (read them with cm_results_summary / cm_results_read).

Input parameters:

- `instance`: Standalone instance id such as 'sa1' (may be omitted while there is only one)

### `cm_standalone_close` (~50 tokens)

Close a standalone instance

Disconnect; for instances this server launched, also stop the CarMaker process.

Input parameters:

- `instance`: Standalone instance id such as 'sa1' (may be omitted while there is only one)

### `cm_study_start` (~757 tokens)

Start a parameter study

Run one test run several times with different parameter values, one after another, in the
background. Returns a study id at once; wait with cm_study_wait. Nothing is written to project files.
The answer names values that will change nothing: keys_not_found, workspace_not_found and
workspace_overruled (use scope=<model>); Driver.* keys that a driver template overrides are refused
(use 'driver'). Rows give valid and wall_s, the clock time of the run. A study stops at the first
run that finds no CarMaker licence.

Input parameters:

- `close_open` (boolean): standalone: first close the CarMaker programs this server left open (each holds a licence)
- `gates`: 'markers': each row gets 'sectors', the times CarMaker's lap timing takes at the test run's trigger point markers, each from the last reference marker (a lap on a skid pad). Or road positions in m: '…
- `grid`: Every combination of value lists, added to variations: {'driver': {'Driver.Acc.ayMax': [12, 14]}, 'driver_scale': {'Driver.Acc.GGExp': [1, 2, 4]}, 'keys': {...}, 'workspace': {...}}. driver_scale mul…
- `keep_open` (boolean): With movie: leave the last run in IPGMovie (close it with cm_standalone_close)
- `keys`: Keys for every run, e.g. {'Vehicle': 'Car_B'}; a variation's own keys win
- `max_run_s` (number): A run is stopped after this wall time in s
- `mode` (string): cm4sl: the MATLAB-connected session. standalone: CarMaker without MATLAB (no 'workspace' values). auto: cm4sl if MATLAB is connected
- `movie` (boolean): mode standalone: show the runs in IPGMovie
- `quantities`: Quantities to summarise per run (default: Time, Car.v). Standalone they are also all its result file stores, besides what timing needs: list every quantity to plot later
- `rerun`: Runs of an earlier study again: {'study': id, 'labels': ['best']}, e.g. with movie and keep_open to show the best run; an IPGMovie window kept open is reused
- `save_logs` (boolean): After every run, save what Simulink logged and the workspaces as that run used them to a MAT file next to its result file (mode cm4sl; logs_file per row)
- `scope` (string): 'base' for the MATLAB base workspace, or the name of a loaded Simulink model for that model's workspace
- `speed`: x real time; omit for CarMaker's maximum. Slower only if the user asks
- `testrun`: Test run relative to Data/TestRun (with rerun: default its study's)
- `variations`: One entry per run: {'label': 'heavy', 'keys': {'Body.mass': 320}, 'workspace': {'Kp_yaw': 1.5}, 'driver': {'Driver.Acc.ayMax': 14, 'Driver.Acc.GGExp': '10 1.5 1.5\n90 5 5'}}. 'keys': infofile keys in…

### `cm_study_status` (~215 tokens)

Parameter study progress and results

State of a study (running, done, cancelled, failed) and one row per finished run, which also maps
every label to its result file. The ranking names each run's result file. To wait use
cm_study_wait.

Input parameters:

- `detail` (string): brief: per run label, valid, end status, sector or split times, abort reason. compact: also time, distance, result file and min / max / mean / last of the quantities. full: also every run's keys, wor…
- `labels`: Only these rows
- `rank_by`: Rank the valid runs: 'sectors' (mean sector time), 'splits' (their sum), 'sim_time', or a quantity statistic such as 'Car.v.max'; '-' first for largest first
- `study`: Study id (default: the latest)
- `top`: Only the best N of the ranking
- `with_studies`: Rank these studies' runs together with this one's

### `cm_study_wait` (~199 tokens)

Wait for a parameter study

Wait until another run of the study has finished or the study has ended, at most timeout_s, and
return the rows no earlier call returned (cm_study_status has the whole table and rank_by). Call it
again while state is 'running'. Use this for studies instead of cm_wait_end.

Input parameters:

- `detail` (string): brief: per run label, valid, end status, sector or split times, abort reason. compact: also time, distance, result file and min / max / mean / last of the quantities. full: also every run's keys, wor…
- `study`: Study id (default: the latest)
- `timeout_s` (number): Longest time to wait in s, at most 50 (larger values are cut to 50); call again if not finished
- `until_done` (boolean): Return only when the study has ended (or at timeout_s)

### `cm_study_cancel` (~70 tokens)

Cancel a parameter study

Stop the run in progress, skip the remaining ones and restore the changed workspace values. Only
cancel a study this conversation started.

Input parameters:

- `study` (string, required): Id of the study to cancel, as cm_study_start returned it. It must be named: a study is not cancelled by default

### `cm_changelog` (~62 tokens)

Change log

Recorded changes (file keys, workspace variables, model parameters, GUI settings) with old and
new values.

Input parameters:

- `limit` (integer): Newest entries to return
- `session`: Session id (default: this session; 'all' for every session)

Output parameters:

- `result` (array)

### `cm_revert_all` (~47 tokens)

Undo this session's changes

Undo every change made in this server session: workspace values and model parameters in reverse
order, backed-up files put back (created files go to a trash folder), GUI settings restored.

### `cm_restore` (~37 tokens)

Restore files of an earlier session

Restore project files from the backups of an earlier session. Files only.

Input parameters:

- `session` (string, required): Session id as shown by cm_changelog

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/dimitr-io-carmaker-mcp/carmaker-mcp#diagnostics

## Score history

- 2026-11-05: 90
- 2026-11-04: 74
- 2026-11-03: 89
- 2026-11-02: 89
- 2026-11-01: 88
- 2026-10-31: 88
- 2026-10-30: 88
- 2026-10-29: 87
- 2026-10-28: 87
- 2026-10-27: 87
- 2026-10-26: 86
- 2026-10-25: 86
- 2026-10-24: 85
- 2026-10-23: 85
- 2026-10-22: 84
- 2026-10-21: 84
- 2026-10-20: 83
- 2026-10-19: 83

## Common questions

### What is the CarMaker MCP server?

CarMaker is an MCP server listed in the public MCP registry as io.github.dimitr-io/carmaker-mcp. Drive IPG CarMaker for Simulink: run test runs, read results, edit vehicle data and parameters. This page covers its PyPI package (carmaker-mcp).

### Is the CarMaker MCP server safe to use?

CarMaker scores 90 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the CarMaker MCP server expose?

CarMaker exposes 54 tools: cm_session_start, cm_doctor, cm_status, cm_load_testrun, cm_start_sim, and 49 more. Their descriptions and schemas cost roughly 6,980 tokens of context every time the server is loaded.

### Is the CarMaker MCP server still maintained?

CarMaker is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the CarMaker MCP server under?

CarMaker declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- PyPI project: https://pypi.org/project/carmaker-mcp/
- Socket report: https://socket.dev/pypi/package/carmaker-mcp
- Repository: https://github.com/dimitr-io/carmaker-mcp
- Changelog RSS feed: https://verifymcp.io/servers/dimitr-io-carmaker-mcp/carmaker-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/dimitr-io-carmaker-mcp/carmaker-mcp.json
- HTML version of this page: https://verifymcp.io/servers/dimitr-io-carmaker-mcp/carmaker-mcp