Advance Minimax M3 Cursor Rules

MiniMax M3 Cursor Rules

A durable execution spine for repo-scale engineering on M3 + Cursor 3.7 — with frontier-agent coding judgment and reasoning protocols distilled into rules any model can run.

[](https://github.com/madebyaris/advance-minimax-m3-cursor-rules/stargazers) [](LICENSE) [](https://cursor.com/changelog) [](https://platform.minimax.io) [](https://platform.minimax.io) [](https://platform.minimax.io) [](#-model-compatibility)

Tuned for MiniMax M3 (1M-token MSA context, native multimodal input) and Cursor 3.7 (Agents Window, canvases, Design Mode, /worktree, /best-of-n, Await, MCP Apps). Written to stay useful across model changes.

[Quick Start](#-quick-start) · [Non-Dev Guide](docs/FOR-NON-DEVELOPERS.md) · [Why This Repo](#-why-this-repo-exists) · [Architecture](#-rule-architecture) · [Runtime Modes](#-m3-runtime-modes) · [Solver Loop](#-the-solver-loop) · [Evaluate It](#-evaluate-it-yourself) · [References](#-references)

---

At A Glance

| | What you get | |---|---| | Lean always-on core | Two durable rules carry the execution spine — reasoning protocol, solver loop, scope control, code discipline, M3 long-context discipline, M3 multimodal input discipline, and a strict proof contract. No persona bloat. | | Frontier craft, distilled | The fable5-* craft rules transfer the judgment behind SWE-Bench-class agents — locate-before-write, root-cause method, simplicity taste, test integrity, hypothesis ledgers, stuck-strategy ladder — to M3 and any open model. | | Progressive depth | 18 requestable rules + 7 skill packs load only when the task needs them, so context stays clean. | | M3 long-context discipline | 1M-token MSA context is a real lever, but the failure mode shifts to "kept too much raw output." A dedicated skill (minimax-m3-long-context) teaches the retention and compression cadence. | | M3 multimodal-native | Image and video inputs ground visual claims (multimodal-grounded). A dedicated skill (minimax-m3-multimodal-input) teaches the design-parity and screenshot-triage workflow. | | Cursor 3.7 surface | Explicit guidance for the Agents Window, canvases, Design Mode, /worktree, /best-of-n, Await, MCP Apps structured content, and Composer 2.5. | | Honest tool use | The agent works the current runtime — no invented tools, no stale wrappers, no promises before the path is confirmed. | | Evidence-backed closeouts | Explicit status labels (verified / unverified / blocked / multimodal-grounded), minimum-proof rules per change type, and red → green proof for bug fixes. | | Portable | docs/AGENTS.md carries the same behavior to non-Cursor IDEs and CLIs. | | Model-resilient | Tuned for M3 first, compatible with any Cursor-supported model. |

> The bet: MiniMax doesn't get better from persona text. It gets better from cleaner context, smaller proving slices, better tool routing, honest verification — and the same judgment habits frontier agents use: fix the broken invariant, not the symptom; never game a test; update the plan after every tool result. Every rule here optimizes for that.

---

Quick Start

> Not a developer? You can still use these rules. Read the plain-language Non-Developer Guide — what the rules do for you, how to install them with no terminal, and how to write good prompts in everyday words. Available in [English](docs/FOR-NON-DEVELOPERS.md) and [Bahasa Indonesia](docs/FOR-NON-DEVELOPERS.id.md).

For Cursor

git clone https://github.com/madebyaris/advance-minimax-m3-cursor-rules.git
cp -r advance-minimax-m3-cursor-rules/.cursor your-project/.cursor

That's it. Two rules are always on:

• .cursor/rules/minimax-m3-core.mdc — reasoning protocol, execution behavior, code discipline, M3 long-context discipline, M3 multimodal input discipline
• .cursor/rules/minimax-m3-status-verification.mdc — status & proof contract (multimodal-grounded visual proof, red → green for bug fixes)

Everything else is requestable and narrower by design — it loads when the task or file globs call for it. The two fable5-* craft rules load for non-trivial coding and reasoning work; the rest attach by runtime or domain.

> The official docs recommend Anthropic-compatible access for MiniMax text models, and also support OpenAI-compatible access paths. See MiniMax text generation docs · MiniMax API overview.

For Other IDEs and CLIs

Copy docs/AGENTS.md into the target repo root as AGENTS.md. It lives under docs/ here on purpose, so Cursor does not auto-activate it while you edit these rules.

---

Repository Layout

.cursor/
├── rules/                         # 20 rules (2 always-on + 18 requestable)
│   ├── minimax-m3-core.mdc                  ★ always-on · execution spine + reasoning protocol + M3 disciplines
│   ├── minimax-m3-status-verification.mdc   ★ always-on · proof contract (+ multimodal-grounded, red → green)
│   ├── fable5-coding-craft.mdc              requestable · frontier coding judgment distillation
│   ├── fable5-reasoning.mdc                 requestable · frontier thinking protocols
│   └── …                                    requestable: runtime + domain
├── agents/                        # subagents (/debugger, /verifier)
│   ├── debugger.md                          root-cause analysis: hypothesis ledger, bisection, fix-at-the-owner
│   └── verifier.md                          adversarial validation: claim-gaming hunt, proof execution
└── skills/                        # 7 deep, structured skill packs
    ├── anti-slop-design/
    ├── 3d-web-experiences/
    ├── deep-research/
    ├── incident-triage-harness/
    ├── minimax-multimodal-toolkit/
    ├── minimax-m3-long-context/             # new · 1M-context retention/compression
    └── minimax-m3-multimodal-input/         # new · native image/video input workflow
docs/
├── AGENTS.md                      # portable agent contract (non-Cursor)
└── FOR-NON-DEVELOPERS.md          # plain-language guide for non-programmers
examples/
└── agent-teams-product-prototype.md
harness/                           # evaluation harness — run the rules against a real model
├── agent.py                                 minimal tool-using agent loop (rules as system prompt)
├── quiz.py · intent_test.py                 no-tool knowledge + intent probes
└── seeds/                                   visible+hidden tasks (calc, roman, tally)

---

Why This Repo Exists

This repo makes MiniMax M3 feel strong exactly where the M3 release puts its emphasis:

• 1M-token MSA context — and the discipline to use it without bloating
• native multimodal input (image, video) — and the discipline to ground visual claims in the actual file
• higher agentic and coding benchmarks — leveraged through role separation and explicit verification
• frontier coding judgment — the fable5-* craft rules distill the habits behind SWE-Bench-class scores (root-cause method, test integrity, interleaved thinking) into a form open models can follow
• agent harnesses and multi-agent collaboration, including /best-of-n as a first-class team pattern
• long skill packs and detailed tool contracts that load only when relevant
• dynamic tool discovery in changing environments (Cursor 3.7's evolving MCP + plugin surface)

The goal is not to make MiniMax imitate another provider's tone. It is to transfer the judgment — where to change code, how to prove a fix, when to switch strategy — while M3 keeps its own voice. A durable execution spine that complements its official positioning around real-world engineering, complex skills, agent workflows, long context, and multimodal grounding.

Why M3-native (and what that optimizes for)

MiniMax positions M3 as a generational shift: 1M-token MSA context, native multimodal input, and higher agentic and coding benchmarks (model page).

So this repo optimizes for:

• explicit retention and compression decisions on 1M tokens (not "fit it all and hope")
• grounding every visual claim in the actual attached image/frame (multimodal-grounded)
• bounded repo exploration instead of reading everything
• smallest proving slices for large tasks
• explicit role and handoff discipline for multi-agent work, including /best-of-n for high-stakes choices
• strong skill contracts instead of vague long prompts
• truthful runtime and verification reporting

The MoE / MSA note — what you can and cannot control

These rules do not assume you can steer a model's internal routing through persona text. M3 swaps full attention for MiniMax Sparse Attention (MSA), which selects KV-blocks per query — and the controllable levers are still external:

• cleaner context (with explicit retention decisions)
• better decomposition
• better tool routing (including the Cursor 3.7 surface)
• better verification loops, including multimodal-grounded visual proof
• clearer definitions of done

If M3 performs better after a rule change, the likely reason is improved external problem structure — not magic access to hidden experts.

---

The Solver Loop

The single most important behavior this repo transfers into M3:

1. Define the outcome in operational terms.
2. Inspect the repo and runtime before deciding.
3. Find the spine: entry points, data flow, state, persistence, user-visible behavior.
4. Build the smallest vertical slice that proves the feature works.
5. Verify at the surface where the user experiences the change.
   - For visual claims: re-read the actual post-change frame (multimodal-grounded).
6. Expand scope only after the core slice works.

For app-building, that means: don't start with a pile of components — resolve key flows first, prove one end-to-end slice early, then add polish.

| New-app proving loop | | |---|---| | 1 | install / setup succeeds | | 2 | dev server or health check starts | | 3 | production build succeeds | | 4 | one primary happy-path flow works | | 5 | promised integrations (styling, routing, persistence, auth) are actually verified | | 6 | any visual claims are multimodal-grounded (re-read the post-change frame) |

> Example — for "build a task app", prioritize create → list → complete → persist → reload. Delay filters, collaboration, settings, and animations until the core path works.

---

Execution Guarantees

A few behaviors the repo treats as non-negotiable:

• New packages, frameworks, and toolchains are checked against current authoritative sources before they are recommended or installed.
• Scaffolding uses the framework's official CLI / create / init path when one exists.
• Scaffold output is inspected before continuing.
• Runnable work is not "done" until there is runnable proof, not just static confidence.
• Bug fixes are proven red → green: the reproduction fails before the change and passes after. A check that was never red proves nothing.
• Tests are never weakened, skipped, or special-cased to reach green — the test is the spec; if the spec looks wrong, that goes to the user.
• Fixes land at the root cause (the broken invariant), not at the symptom site; shipped workarounds are labeled as workarounds.
• Stubs, mocks, and hardcoded placeholders are declared in the closeout — never presented as finished behavior.
• Visual work is not "done" until the post-change frame is re-read (multimodal-grounded).
• If a required check fails or is skipped, the agent reports blocked or implemented but unverified — never a false completion.
• Browser or user-surface verification is required for UI and interaction claims.
• Tool-based promises wait until the runtime path is confirmed.
• 1M-token context does not free the agent from compressing; it raises the cost of failing to compress.

---

Rule Architecture

The system is layered: a tiny always-on core, craft rules that carry frontier judgment, runtime rules that load on demand, and domain rules that attach via file globs. Depth lives in skills.

★ Always-On Core

| File | Purpose | |------|---------| | minimax-m3-core.mdc | Durable execution behavior: reasoning protocol (intent-first, interleaved thinking, explicit hypotheses, end-to-end ownership), solver loop, scope control, code discipline (root-cause-first, boundary validation, test integrity), M3 long-context discipline, M3 multimodal input discipline, truthful tool use, scaffold discipline, concise progress | | minimax-m3-status-verification.mdc | Status & proof contract: exact claim labels, proof matching, red → green for bug fixes, multimodal-grounded visual proof, evidence-first closeouts |

Craft Rules (Fable 5 Distillation)

Frontier-agent judgment distilled into requestable rules — the habits behind SWE-Bench-class scores, made transferable to M3 and any open model:

| File | Purpose | |------|---------| | fable5-coding-craft.mdc | The craft hierarchy, locate-before-write, root-cause method (broken-invariant chain), simplicity taste, error-handling philosophy, test integrity, refactoring discipline, LLM failure modes and counters | | fable5-reasoning.mdc | Three-readings task interpretation, risk-first decomposition, approach selection, interleaved thinking loop (surprise rule, stale-plan rule), hypothesis ledgers, premortems, calibration, stuck-strategy ladder |

Runtime Rules

| File | Purpose | |------|---------| | model-compatibility.mdc | Prompt hierarchy, M3-first model selection, tool discipline, context control across models | | cursor-tools-mastery.mdc | Cursor 3.7 tool-selection patterns: Agents Window, canvases, Design Mode, /worktree, /best-of-n, Await, Composer 2.5 | | cursor-mcp-optimization.mdc | Browser, Figma, Cloudflare tools, MCP Apps structured content, direct action patterns | | cursor-agent-orchestration.mdc | Multi-environment planning, /best-of-n as an orchestration primitive, Await for long-running branches | | agent-teams.mdc | Role boundaries, multi-environment handoffs, /best-of-n as a team pattern, escalation, serial vs parallel | | tool-discovery.mdc | Runtime tool inventory, MCP/schema discovery, MCP Apps structured content, safe fallbacks | | minimax-mcp-tools.mdc | Current-doc retrieval, direct-tool preference, version-aware lookups, MCP Apps structured content | | minimax-m3-verification.mdc | Proportional verification playbook (shell + browser + multimodal-grounded checks, test integrity during verification) | | minimax-m3-self-evolution.mdc | Iterative refinement loops, compress-before-iterate, autonomous debugging | | skill-authoring.mdc | When to use skills, how to structure them, how to declare model_assumptions | | clarify-first-prompting.mdc | Ask only on real forks, after inspecting first |

Domain Rules

Requestable rules for cross-cutting domains — not per-language cookbooks. Language-specific idioms come from reading the repo, official docs, and the always-on Code Discipline section.

| File | Purpose | |------|---------| | language-agnostic-patterns.mdc | Pattern judgment (when not to apply), SOLID, design patterns, change discipline, code-review heuristics | | design-systems.mdc | Tokens, shadcn/ui, Tailwind v4 mechanics → aesthetics via anti-slop-design | | 3d-graphics.mdc | Three.js / R3F syntax, container sizing, import traps → quality via 3d-web-experiences | | devops-infrastructure.mdc | Docker, k8s, Terraform, CI/CD — validate-before-apply, infra traps (lean) | | mobile-cross-platform.mdc | Flutter / RN / Expo — CLI-first, architecture, mobile verify (lean) |

Skills

Skills keep deep, domain-specific procedures out of the always-on core, then deliver large structured guidance through progressive disclosure (SKILL.md + optional reference.md).

| Skill | Purpose | |------|---------| | anti-slop-design/ | Brand-vs-product register, co

…

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: madebyaris
• Source: madebyaris/advance-minimax-m3-cursor-rules
• License: MIT

Install and usage instructions live in the source repository linked above.