How do I install the Cortex M skill?

Run npx skillmds@latest add software-mansion-labs/cortex-m in your terminal (requires Node.js), paste this page's agent-chat prompt into Claude, Cursor, or any MCP-connected agent, or download the SKILL.md file and copy it into your agent's skills directory.

Is Cortex M safe to use?

This skill has not completed SkillMD's automated safety review yet. SkillMD never runs a skill's scripts for you; review the SKILL.md before installing.

Which AI agents work with Cortex M?

This skill is tagged as working with Claude Code, Claude.ai, OpenAI Codex. SKILL.md is an open format, so most agents that read a skills directory can load it too.

Is Cortex M free to use?

Yes. Installing skills from SkillMD is free, and the skill stays under its author's original license.

Who published Cortex M?

software-mansion-labs (@software-mansion-labs) published this skill. Their other Agent Skills are listed on their SkillMD profile.

Cortex M by software-mansion-labs — Agent Skill

Name: Cortex M
Author: software-mansion-labs

File contents

Cortex-M (CMSIS-NN) Backend

Architecture

Not a delegate backend — no partitioner. Custom ops and graph passes replace ATen quantized ops with CMSIS-NN equivalents at the graph level.

Pipeline

Uses standard PT2E quantization (prepare_pt2e / convert_pt2e), then CortexMPassManager rewrites quantized ops to cortex_m:: equivalents.

from executorch.backends.cortex_m.quantizer.quantizer import CortexMQuantizer
from executorch.backends.cortex_m.passes.cortex_m_pass_manager import CortexMPassManager
from torch.export import export
from torchao.quantization.pt2e.quantize_pt2e import convert_pt2e, prepare_pt2e
from executorch.exir import to_edge_transform_and_lower, EdgeCompileConfig

quantizer = CortexMQuantizer()
captured = export(model, example_inputs).module()
prepared = prepare_pt2e(captured, quantizer)
prepared(*example_inputs)  # calibration
quantized = convert_pt2e(prepared)

exported = export(quantized, example_inputs)
edge = to_edge_transform_and_lower(
    exported,
    compile_config=EdgeCompileConfig(_check_ir_validity=False),
)
edge._edge_programs["forward"] = CortexMPassManager(
    edge.exported_program(), CortexMPassManager.pass_list
).transform()
et_program = edge.to_executorch()

In tests, CortexMTester wraps this pipeline:

from executorch.backends.cortex_m.test.tester import CortexMTester

tester = CortexMTester(model, example_inputs)
tester.quantize().export().to_edge().run_passes().to_executorch()

Key Files

File	Purpose
`backends/cortex_m/quantizer/quantizer.py`	`CortexMQuantizer` — quantizes model for CMSIS-NN
`backends/cortex_m/passes/cortex_m_pass_manager.py`	`CortexMPassManager` — rewrites ATen ops → `cortex_m::` ops
`backends/cortex_m/test/tester.py`	`CortexMTester` — test harness with `test_dialect()` and `test_implementation()`
`backends/cortex_m/ops/operators.py`	Python op definitions and reference implementations (`cortex_m::` namespace)
`backends/cortex_m/ops/operators.yaml`	C++ kernel registration schemas (used by build system)

C++ kernels calling CMSIS-NN APIs live under backends/cortex_m/ops/.

Testing

Toolchain setup (required for test_implementation tests):

./examples/arm/setup.sh --i-agree-to-the-contained-eula
source ./examples/arm/arm-scratch/setup_path.sh

Run all tests:

source ./examples/arm/arm-scratch/setup_path.sh
pytest backends/cortex_m/test/

test_dialect_* tests verify graph correctness (pure Python, no toolchain needed). test_implementation_* tests verify numerical accuracy on the Corstone-300 FVP (requires toolchain on PATH).

Baremetal build:

backends/cortex_m/test/build_test_runner.sh

Adding a New Op

Define the op schema, meta function, and reference implementation in operators.py
Write the C++ kernel in backends/cortex_m/ops/ calling CMSIS-NN APIs
Register the .out kernel in operators.yaml
Add a pass to rewrite the ATen op → cortex_m:: op
Test with CortexMTester.test_dialect() (graph correctness) and test_implementation() (numerical accuracy on FVP)

---name: cortex-mdescription: Build, test, or develop the Cortex-M (CMSIS-NN) backend. Use when working on backends/cortex_m/, running Cortex-M tests, or exporting models for Cortex-M targets.---# Cortex-M (CMSIS-NN) Backend## ArchitectureNot a delegate backend — no partitioner. Custom ops and graph passes replace ATen quantized ops with CMSIS-NN equivalents at the graph level.## PipelineUses standard PT2E quantization (`prepare_pt2e` / `convert_pt2e`), then `CortexMPassManager` rewrites quantized ops to `cortex_m::` equivalents.```pythonfrom executorch.backends.cortex_m.quantizer.quantizer import CortexMQuantizerfrom executorch.backends.cortex_m.passes.cortex_m_pass_manager import CortexMPassManagerfrom torch.export import exportfrom torchao.quantization.pt2e.quantize_pt2e import convert_pt2e, prepare_pt2efrom executorch.exir import to_edge_transform_and_lower, EdgeCompileConfigquantizer = CortexMQuantizer()captured = export(model, example_inputs).module()prepared = prepare_pt2e(captured, quantizer)prepared(*example_inputs) # calibrationquantized = convert_pt2e(prepared)exported = export(quantized, example_inputs)edge = to_edge_transform_and_lower( exported, compile_config=EdgeCompileConfig(_check_ir_validity=False),)edge._edge_programs["forward"] = CortexMPassManager( edge.exported_program(), CortexMPassManager.pass_list).transform()et_program = edge.to_executorch()```In tests, `CortexMTester` wraps this pipeline:```pythonfrom executorch.backends.cortex_m.test.tester import CortexMTestertester = CortexMTester(model, example_inputs)tester.quantize().export().to_edge().run_passes().to_executorch()```## Key Files| File | Purpose ||------|---------|| `backends/cortex_m/quantizer/quantizer.py` | `CortexMQuantizer` — quantizes model for CMSIS-NN || `backends/cortex_m/passes/cortex_m_pass_manager.py` | `CortexMPassManager` — rewrites ATen ops → `cortex_m::` ops || `backends/cortex_m/test/tester.py` | `CortexMTester` — test harness with `test_dialect()` and `test_implementation()` || `backends/cortex_m/ops/operators.py` | Python op definitions and reference implementations (`cortex_m::` namespace) || `backends/cortex_m/ops/operators.yaml` | C++ kernel registration schemas (used by build system) |C++ kernels calling CMSIS-NN APIs live under `backends/cortex_m/ops/`.## Testing**Toolchain setup (required for `test_implementation` tests):**```bash./examples/arm/setup.sh --i-agree-to-the-contained-eulasource ./examples/arm/arm-scratch/setup_path.sh```**Run all tests:**```bashsource ./examples/arm/arm-scratch/setup_path.shpytest backends/cortex_m/test/````test_dialect_*` tests verify graph correctness (pure Python, no toolchain needed).`test_implementation_*` tests verify numerical accuracy on the Corstone-300 FVP (requires toolchain on PATH).**Baremetal build:**```bashbackends/cortex_m/test/build_test_runner.sh```## Adding a New Op1. Define the op schema, meta function, and reference implementation in `operators.py`2. Write the C++ kernel in `backends/cortex_m/ops/` calling CMSIS-NN APIs3. Register the `.out` kernel in `operators.yaml`4. Add a pass to rewrite the ATen op → `cortex_m::` op5. Test with `CortexMTester.test_dialect()` (graph correctness) and `test_implementation()` (numerical accuracy on FVP)

Frequently asked questions

Cortex M