Token Plan Deprecated! MiniMax Launches M Plan: Unified Multimodal Quota, H3 Video Unlocked, and Native Claude Code & Cursor Integration

Core Executive Summary: If you thought AI subscription models were still stuck in pay-per-token metering with anxiety over every background agent test run, MiniMax M Plan will fundamentally rewrite your understanding of agentic multimodal developer workflows!

• The Legacy Token Plan Deprecated: On October 1, 2026, MiniMax officially launched M Plan, retiring its legacy Token Plan from new sales. M Plan introduces three structured tiers—Go, Explore, and Build—eliminating fragmented billing across text, video, speech, and image models by combining them into one cohesive, shared quota pool;
• Flagship H3 Video Generation Unlocked: For the first time in an individual developer subscription, MiniMax's acclaimed third-generation cinematic video model H3 (Hailuo architecture) is directly accessible in the Explore and Build tiers, removing costly pay-per-render barriers;
• Dual-Track Adoption: Native Client & Third-Party Agents: M Plan provides two zero-friction routes—sign directly into the official MiniMax Code (MCode) application with no API key needed, or generate an M Plan API Key to connect natively with Claude Code, Cursor, OpenCode, Codex, and Cline via a 100% compatible Anthropic protocol gateway;
• Elementary-School Everyday Analogies: To make complex quota pooling and protocol gateways effortless to understand, this post uses intuitive metaphors including "Single-Ride Carnival Tickets vs All-Inclusive Wristband", "Separate Utility Meters vs Central Water Reservoir", and "Direct Flagship Store vs Courier Lockers";
• Double Launch Promotions: From October 1 through October 14, 2026, all new subscriptions and upgrades enjoy a 50% discount on the first month; plus an "Unlimited Week" (Oct 1 - Oct 7) granting unlimited M3.1-Flash-Preview usage inside MiniMax Code;
• Zero-Dependency Cross-Platform Automation Toolkit: Say goodbye to configuration errors! We provide production-ready, zero-dependency automation scripts for Windows 11 (PowerShell 7), Ubuntu 26.04 (Bash), and macOS 26 (Zsh), supporting both interactive terminal setup and headless AI Agent declarative orchestration.

1. Background: The Era of Long-Horizon Agents and MiniMax M Plan's Debut

As the industry steps into October 2026, generative AI has evolved far beyond single-turn conversational chatbots. Modern software engineering relies heavily on long-horizon autonomous agents—autonomous software entities capable of executing dozens or hundreds of sequential tool calls, analyzing entire code repositories, writing comprehensive regression suites, and iteratively resolving runtime exceptions.

However, running persistent coding agents like Claude Code or Cursor has historically introduced serious developer friction under pay-as-you-go token pricing. A single refactoring session across complex microservices can burn through millions of tokens in minutes, creating persistent "bill shock anxiety." Furthermore, creators seeking to combine code with speech, graphics, and video have had to juggle disparate subscriptions and API credits across fragmented platforms.

To eliminate these roadblocks, MiniMax unveiled its next-generation subscription infrastructure on October 1, 2026: M Plan!

Key pillars of this milestone release include:

• Retirement of Token Plan: The previous Token Plan is no longer sold to new users. Existing auto-renew subscribers can continue on their current plans or upgrade at any time to unlock new features;
• Three Progressive Tiers: Structured into Go, Explore, and Build, scaled specifically for hobbyists, full-stack engineers, and multi-agent development teams;
• Unified Multimodal Quota Pool: Text generation (M3.1-Flash-Preview / M3), cinematic video (H3 / Hailuo), speech synthesis (Speech-01), and vision understanding all draw from a single shared credit reserve;
• Inclusion of H3 Video: The Explore and Build tiers unlock direct access to MiniMax's frontier H3 video generation model;
• Launch Promotions: A 50% discount on the first month for new subscriptions or upgrades through October 14, 2026, alongside an "Unlimited Week" (October 1 to 7) for M3.1-Flash-Preview in MiniMax Code.

2. Problems & Developer Pain Points: Token Anxiety and Multi-Key Hell

Before examining M Plan's architecture, let us review the three major pain points that plagued the developer ecosystem prior to this release:

Pain Point 1: Metered Token Anxiety and Flow Interruption

When an engineer tasks an agent with debugging a difficult distributed race condition, the agent loops continuously: inspecting dependency trees, reading source files, running compilers, diagnosing errors, and synthesizing patches. Under metered billing, every loop drains funds. Developers find themselves constantly checking dashboards, breaking their psychological flow state out of fear that an unexpected infinite retry loop will deplete their credit balance.

Pain Point 2: Modality Fragmentation and Key Management Hell

Modern applications frequently combine multiple modalities: code generation for backend APIs, speech synthesis for interactive voice responses, image generation for UI placeholders, and video rendering for feature teasers. Previously, this required managing four distinct API portals, four credit balances, and four separate authentication keys. A service disruption in any one provider ground the entire workflow to a halt.

Pain Point 3: Configuration Pitfalls in Third-Party Agent Gateways

Integrating third-party tools like Claude Code with compatible third-party gateways frequently produced frustrating errors:

• Base URL Trailing Path Mismatches: Appending /v1/messages to ANTHROPIC_BASE_URL, causing the client to query /v1/messages/v1/messages and returning 404 Not Found;
• Regional Endpoint Conflicts: Routing requests to api.minimax.cn from overseas instances or using api.minimax.io behind restrictive firewalls;
• Conflicting Environment Variables: Lingering ANTHROPIC_API_KEY values overriding custom gateways and causing 401 Unauthorized errors;
• Lack of Diagnostic Telemetry: No automated probe to verify streaming time-to-first-token (TTFT) or SSL handshakes before kicking off massive builds.

3. Elementary-School Everyday Analogies: Demystifying the Concepts

To ensure anyone—from junior students to experienced engineering leads—can immediately grasp the benefits of M Plan, here are three everyday life analogies:

Analogy 1: [Pay-Per-Ride Carnival Tickets vs The VIP Wristband]

The old pay-as-you-go token model was like visiting a carnival where every ride requires individual ticket purchases. Riding the merry-go-round (simple code edit) costs $1, the bumper cars (unit test run) cost $5, and the giant roller coaster (deep reasoning refactor) costs $30. Parents and kids spend the whole day looking at their wallets in stress. In contrast, MiniMax M Plan is like buying an all-inclusive VIP wristband! Once you put on the wristband for the month, you can ride the bumper cars (M3.1 fast coding) as many times as you like, and higher-tier wristbands (Explore / Build) let you board the flagship drop tower (H3 video generation) whenever inspiration strikes!

Analogy 2: [Separated Utility Meters vs The Central Water Reservoir]

In older platforms, your AI quotas resembled a shared apartment with three separate meters: a water meter for text tokens, an electric meter for graphics, and a gas meter for video render minutes. If you coded heavily, you might have surplus water tokens you never used, while running out of gas just when you needed to render a quick demo video. M Plan introduces a central smart reservoir: whether you turn on the kitchen tap for coding or scoop out water for video synthesis, it all pulls from one unified reservoir. Your resources adapt dynamically to whatever you are building on a given day.

Analogy 3: [Brand Flagship Store vs Neighborhood Package Locker]

Why does M Plan support both MiniMax Code and Claude Code? Think of MiniMax Code as MiniMax's official brand flagship store. You walk in, scan your account face (direct login), and all shelves and tools unlock automatically with zero key management. Claude Code is like your local neighborhood courier locker: it handles the footwork, but needs an authorized pickup code (M Plan API Key) stored in its configuration. Once provided, it picks up compute from MiniMax's backend just as seamlessly!

4. Technical Deep Dive: M Plan Tier Matrix and Quota Pooling Engine

Let us examine the architecture, tier specifications, and quota consumption models that govern M Plan.

1. Tier Comparison Matrix

M Plan is structured into three distinct tiers tailored to different workload volumes:

Note: With the 50% launch discount through October 14, 2026, the Explore tier drops to approximately $27.50 for the first month.

2. The Dynamic Quota Weighting Engine

How does MiniMax balance lightweight text generation against resource-heavy video rendering within the same quota pool?

• Text & Code Weighting: Leveraging the newly optimized M3.1-Flash-Preview, daily code generation incurs minimal credit deductions. Running continuous agent sessions with hundreds of tool calls will only consume a modest fraction of your monthly capacity;
• Video Rendering Weighting: Because diffusion-based temporal video synthesis demands extensive GPU cluster time, generating a 4K H3 video consumes credits equivalent to several thousand text tokens. Both the console and API return transparent quota balances;
• 5-Hour Rolling Window Protection: To safeguard accounts from runaway loops or accidental spikes, the API gateway implements a 5-hour rolling rate-limiting window. If sudden traffic exhausts the short-term window, requests throttle gracefully and resume as the window advances, avoiding permanent account lockouts.

5. Hands-On Setup: Official MiniMax Code vs Third-Party Agent Gateways

Adopting M Plan in your daily routine is streamlined across both official and third-party environments:

1. Official Client: MiniMax Code (MCode)

For a completely turnkey experience, download MiniMax Code for desktop or web. Sign in with your registered credentials, and the client automatically activates your M Plan subscription without touching any API keys:

Within MCode's multi-agent architecture (General, Coder, Verifier), the Coder Agent binds directly to M3.1-Flash-Preview, delivering sub-300ms initial response latency and streaming throughput exceeding 126 tokens per second.

2. Third-Party Agents: Claude Code & Cursor Integration

Developers who prefer the terminal-native claude CLI or Cursor Composer can leverage MiniMax's high-performance Anthropic-compatible gateway:

MiniMax's server-side gateway intercepts standard /v1/messages requests from Claude Code, authenticates the M Plan key, maps tool calling schemas, and streams back standard Server-Sent Events (SSE) without modifying a single line of Claude Code's binary.

In real-world testing, Claude Code successfully refactored a synchronous Redis client into an asynchronous Tokio connection pool across 14 source files, compiling and passing all regression tests in under 15 seconds.

6. Cross-Platform Automation & Self-Healing Diagnostic Toolkits

To eliminate manual configuration errors, we provide zero-dependency, automated setup and diagnostic toolkits for Windows 11, Ubuntu 26.04, and macOS 26:

Toolkit Architecture Highlights

• Zero Third-Party Dependencies: Built purely on native system utilities (PowerShell 7 on Windows 11, Bash + curl on Ubuntu 26.04, Zsh on macOS 26);
• Environment Sanitization: Automatically purges conflicting ANTHROPIC_API_KEY definitions to prevent 401 errors;
• Dual-Region Support: Effortlessly routes between international (api.minimax.io) and mainland China (api.minimax.cn) endpoints;
• Dual-Mode Execution: Supports both guided interactive prompts and headless declarative execution (--headless / -NonInteractive) for autonomous agents.

Windows 11 PowerShell 7+ Automation Script

<#
  Windows 11 Native M Plan Configuration & Health Probe
  Run: pwsh -ExecutionPolicy Bypass .\minimax_mplan_toolkit_windows11.ps1
#>
param (
    [switch]$NonInteractive,
    [string]$ApiKey = $env:MINIMAX_API_KEY,
    [ValidateSet("intl", "cn")]
    [string]$Region = $(if ($env:MINIMAX_REGION) { $env:MINIMAX_REGION } else { "intl" }),
    [string]$Model = "MiniMax-M3.1-Flash"
)

$ErrorActionPreference = "Stop"
Write-Host "=== MiniMax M Plan Toolkit (Windows 11) ===" -ForegroundColor Cyan

if (-not $NonInteractive -and [string]::IsNullOrWhiteSpace($ApiKey)) {
    $r = Read-Host "Select Region: 1) International (api.minimax.io) 2) China (api.minimax.cn) [Default: 1]"
    $Region = if ($r -eq "2") { "cn" } else { "intl" }
    $ApiKey = Read-Host "Enter your MiniMax M Plan Subscription Key (sk-mplan-...)"
}

$BaseHost = if ($Region -eq "cn") { "https://api.minimax.cn" } else { "https://api.minimax.io" }
$AnthropicBaseUrl = "$BaseHost/anthropic"

# Unset conflicting variable
Remove-Item Env:\ANTHROPIC_API_KEY -ErrorAction SilentlyContinue
[Environment]::SetEnvironmentVariable("ANTHROPIC_API_KEY", $null, "User")

# Set clean persistent environment
[Environment]::SetEnvironmentVariable("ANTHROPIC_BASE_URL", $AnthropicBaseUrl, "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_AUTH_TOKEN", $ApiKey, "User")
[Environment]::SetEnvironmentVariable("ANTHROPIC_MODEL", $Model, "User")

# Inject into Claude settings
$ClaudeDir = Join-Path $HOME ".claude"
if (-not (Test-Path $ClaudeDir)) { New-Item -ItemType Directory -Path $ClaudeDir -Force | Out-Null }
$SettingsFile = Join-Path $ClaudeDir "settings.json"
$cfg = @{ env = @{ ANTHROPIC_BASE_URL = $AnthropicBaseUrl; ANTHROPIC_AUTH_TOKEN = $ApiKey; ANTHROPIC_MODEL = $Model } }
$cfg | ConvertTo-Json -Depth 5 | Set-Content -Path $SettingsFile -Encoding UTF8

# Diagnostic Probe
$sw = [System.Diagnostics.Stopwatch]::StartNew()
$payload = @{ model = $Model; max_tokens = 30; messages = @(@{ role = "user"; content = "Ping" }) } | ConvertTo-Json
$headers = @{ "Authorization" = "Bearer $ApiKey"; "x-api-key" = $ApiKey; "anthropic-version" = "2023-06-01"; "Content-Type" = "application/json" }
$res = Invoke-RestMethod -Uri "$AnthropicBaseUrl/v1/messages" -Method Post -Headers $headers -Body $payload
$sw.Stop()

Write-Host "[PASS] Handshake OK! TTFT latency: $($sw.ElapsedMilliseconds) ms" -ForegroundColor Green
Write-Host "Setup complete. Launch your terminal and run 'claude' directly!" -ForegroundColor Yellow

Ubuntu 26.04 LTS Bash Automation Script

#!/usr/bin/env bash
# Ubuntu 26.04 LTS Zero-Dependency M Plan Setup and Probe
set -euo pipefail

INTERACTIVE=true
API_KEY="${MINIMAX_API_KEY:-}"
REGION="${MINIMAX_REGION:-intl}"
MODEL="MiniMax-M3.1-Flash"

while [[ $# -gt 0 ]]; do
  case "$1" in
    --headless|--non-interactive) INTERACTIVE=false; shift ;;
    --api-key) API_KEY="$2"; shift 2 ;;
    --region) REGION="$2"; shift 2 ;;
    *) shift ;;
  esac
done

if [[ "$INTERACTIVE" == true && -z "$API_KEY" ]]; then
  read -r -p "Select Region [1: International / 2: Domestic CN] (Default: 1): " reg_ch
  [[ "$reg_ch" == "2" ]] && REGION="cn" || REGION="intl"
  read -r -p "Enter MiniMax M Plan Subscription Key: " API_KEY
fi

BASE_HOST="https://api.minimax.io"
[[ "$REGION" == "cn" ]] && BASE_HOST="https://api.minimax.cn"
ANTHROPIC_BASE_URL="${BASE_HOST}/anthropic"

# Clean existing profile
unset ANTHROPIC_API_KEY || true
BASHRC="$HOME/.bashrc"
if [[ -f "$BASHRC" ]]; then
  grep -v "export ANTHROPIC_BASE_URL=" "$BASHRC" | \
  grep -v "export ANTHROPIC_AUTH_TOKEN=" | \
  grep -v "export ANTHROPIC_MODEL=" | \
  grep -v "export ANTHROPIC_API_KEY=" > "${BASHRC}.tmp" || true
  mv "${BASHRC}.tmp" "$BASHRC"
fi

cat <<EOF >> "$BASHRC"
export ANTHROPIC_BASE_URL="${ANTHROPIC_BASE_URL}"
export ANTHROPIC_AUTH_TOKEN="${API_KEY}"
export ANTHROPIC_MODEL="${MODEL}"
EOF

# Update ~/.claude/settings.json
mkdir -p "$HOME/.claude"
python3 - <<PY
import json, os
p = os.path.expanduser("~/.claude/settings.json")
d = json.load(open(p)) if os.path.exists(p) else {}
d.setdefault("env", {})
d["env"]["ANTHROPIC_BASE_URL"] = "${ANTHROPIC_BASE_URL}"
d["env"]["ANTHROPIC_AUTH_TOKEN"] = "${API_KEY}"
d["env"]["ANTHROPIC_MODEL"] = "${MODEL}"
with open(p, "w") as f: json.dump(d, f, indent=2)
PY
chmod 600 "$HOME/.claude/settings.json"

# End-to-end verification
STATUS=$(curl -s -o /dev/null -w "%{http_code}" -X POST "${ANTHROPIC_BASE_URL}/v1/messages" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "x-api-key: ${API_KEY}" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d "{\"model\":\"${MODEL}\",\"max_tokens\":20,\"messages\":[{\"role\":\"user\",\"content\":\"Ping\"}]}")

if [[ "$STATUS" == "200" ]]; then
  echo -e "\033[1;32m[PASS] Ubuntu 26.04 environment initialized (HTTP 200). Run 'claude' directly!\033[0m"
else
  echo -e "\033[1;31m[FAIL] Gateway probe returned HTTP ${STATUS}\033[0m" >&2; exit 1
fi

macOS 26 Zsh Automation Script

#!/usr/bin/env zsh
# macOS 26 Native Zero-Dependency M Plan Setup and Probe
set -euo pipefail

INTERACTIVE=true
API_KEY="${MINIMAX_API_KEY:-}"
REGION="${MINIMAX_REGION:-intl}"
MODEL="MiniMax-M3.1-Flash"

while [[ $# -gt 0 ]]; do
  case "$1" in
    --headless|--non-interactive) INTERACTIVE=false; shift ;;
    --api-key) API_KEY="$2"; shift 2 ;;
    --region) REGION="$2"; shift 2 ;;
    *) shift ;;
  esac
done

if [[ "$INTERACTIVE" == true && -z "$API_KEY" ]]; then
  read -r "reg_ch?Select Region [1: International / 2: Domestic CN] (Default: 1): "
  [[ "$reg_ch" == "2" ]] && REGION="cn" || REGION="intl"
  read -r "API_KEY?Enter MiniMax M Plan Subscription Key: "
fi

BASE_HOST="https://api.minimax.io"
[[ "$REGION" == "cn" ]] && BASE_HOST="https://api.minimax.cn"
ANTHROPIC_BASE_URL="${BASE_HOST}/anthropic"

unset ANTHROPIC_API_KEY || true
ZSHRC="$HOME/.zshrc"
if [[ -f "$ZSHRC" ]]; then
  grep -v "export ANTHROPIC_BASE_URL=" "$ZSHRC" | \
  grep -v "export ANTHROPIC_AUTH_TOKEN=" | \
  grep -v "export ANTHROPIC_MODEL=" | \
  grep -v "export ANTHROPIC_API_KEY=" > "${ZSHRC}.tmp" || true
  mv "${ZSHRC}.tmp" "$ZSHRC"
fi

cat <<EOF >> "$ZSHRC"
export ANTHROPIC_BASE_URL="${ANTHROPIC_BASE_URL}"
export ANTHROPIC_AUTH_TOKEN="${API_KEY}"
export ANTHROPIC_MODEL="${MODEL}"
EOF

mkdir -p "$HOME/.claude"
python3 - <<PY
import json, os
p = os.path.expanduser("~/.claude/settings.json")
d = json.load(open(p)) if os.path.exists(p) else {}
d.setdefault("env", {})
d["env"]["ANTHROPIC_BASE_URL"] = "${ANTHROPIC_BASE_URL}"
d["env"]["ANTHROPIC_AUTH_TOKEN"] = "${API_KEY}"
d["env"]["ANTHROPIC_MODEL"] = "${MODEL}"
with open(p, "w") as f: json.dump(d, f, indent=2)
PY
chmod 600 "$HOME/.claude/settings.json"

STATUS=$(curl -s -o /dev/null -w "%{http_code}" -X POST "${ANTHROPIC_BASE_URL}/v1/messages" \
  -H "Authorization: Bearer ${API_KEY}" \
  -H "x-api-key: ${API_KEY}" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d "{\"model\":\"${MODEL}\",\"max_tokens\":20,\"messages\":[{\"role\":\"user\",\"content\":\"Ping\"}]}")

if [[ "$STATUS" == "200" ]]; then
  echo -e "\033[1;32m[PASS] macOS 26 verified (HTTP 200). Run 'claude' in terminal to begin coding!\033[0m"
else
  echo -e "\033[1;31m[FAIL] Gateway probe returned HTTP ${STATUS}\033[0m" >&2; exit 1
fi

Downloads & Verification Manifest

• All-in-One Toolkit Archive: minimax-mplan-toolkit.zip
• Windows 11 Script: minimax_mplan_toolkit_windows11.ps1
• Ubuntu 26.04 Script: minimax_mplan_toolkit_ubuntu2604.sh
• macOS 26 Script: minimax_mplan_toolkit_macos26.zsh
• SHA256 Checksum Manifest: SHA256SUMS.txt

7. Migration Decision Tree & Performance Radar Analysis

Existing Token Plan subscribers face a clear choice: should you maintain your grandfathered plan or transition to M Plan?

Migration Recommendations

• Recommended for Upgrade: If you build with video generation, need multiple concurrent agents, or want unified accounting for voice and imagery, upgrading during the 50% off launch period (Oct 1 - Oct 14) provides dramatic value;
• Maintain Legacy Auto-Renew: If you possess an early-bird annual Token Plan and solely perform low-frequency text chat, ensure your auto-renewal billing remains funded. Cancelling auto-renew will permanently forfeit your legacy plan.

Radar Analysis Summary

• Cost Efficiency (9.5 / 10): Predictable flat monthly subscriptions eliminate runaway token billing;
• Latency & Throughput (9.2 / 10): M3.1-Flash clocks sub-300ms initial token response and 126+ tokens/sec throughput, providing exceptional responsiveness in tool-calling loops;
• Multimodal Breadth (9.5 / 10): Bundling cinematic H3 video alongside code intelligence sets a new standard for developer utility packages.

8. Frequently Asked Questions (Q&A FAQ)

Q1: Will upgrading to M Plan wipe out my remaining Token Plan balance?

No. MiniMax prorates remaining active days and applies them toward your M Plan balance. However, historical early-bird discounts from older Token Plans do not carry over to M Plan renewal pricing.

Q2: Can I share one M Plan API Key across multiple machines?

Yes. You can configure the same M Plan Subscription Key on your workstation (Windows 11), laptop (macOS 26), and cloud runners (Ubuntu 26.04). All requests draw from your shared quota pool up to your tier's concurrency limit (2 for Go, 5 for Explore, 10 for Build).

Q3: Why does Claude Code report 404 Not Found after setting ANTHROPIC_BASE_URL?

Check your URL string. You must use https://api.minimax.io/anthropic or https://api.minimax.cn/anthropic. Do not append /v1/messages. Claude Code automatically appends the endpoint path; adding it manually creates a duplicate /v1/messages/v1/messages route.

Q4: Does the Go tier support H3 video generation?

No. Go is dedicated to text, audio, and image tasks. To access H3 video generation, upgrade to the Explore or Build tier via the account console.

Q5: What causes 401 Unauthorized errors in the terminal?

In almost all cases, a lingering ANTHROPIC_API_KEY environment variable is overriding your configuration. Unset ANTHROPIC_API_KEY and ensure only ANTHROPIC_AUTH_TOKEN holds your MiniMax subscription key.

Q6: Does M Plan support Prompt Caching in third-party agents?

Yes. The MiniMax Anthropic gateway natively detects reusable system prompts and repository structures, caching KV blocks to boost inference speed and reduce quota burn.

9. Conclusion

The progression of generative AI over the last two years has moved from expensive metered tokens to fragmented multi-tool billing, culminating in MiniMax M Plan's unified multimodal subscription.

By bringing together high-speed M3.1-Flash code intelligence, cinematic H3 video rendering, and turnkey integration with tools like Claude Code and Cursor, MiniMax has removed the final barriers to autonomous software engineering. The era of frictionless agentic creation is officially here!