• 運算
  • 客戶
  • 價格
登入
More Blog Posts
XDiscordLinkedInYouTube

產品

  • GPU
  • MaaS
  • Studio

開發者

  • 模型總覽
  • 技術文件
  • 詞彙表

公司

  • 關於我們
  • 部落格
  • 活動
  • 合作夥伴
  • 新創計劃
  • 職涯
  • 大使計畫
  • 使命與願景

熱門模型

    掌握 AI 最新動態

    提交即表示您瞭解我們會收集並使用您提交的資訊,其中可能包含個人資訊。

    XDiscordLinkedInYouTube

    Copyright ©2026 All rights reserved.

    隱私政策使用條款法律文件
    More Blog Posts
    Research

    MiniMax M3.1 Flash Narrates with Audio Description for the Blind

    Narrator is a small server and 1 page. The server listens to a clip's soundtrack to find the silences and pulls frames at 1 per second plus every scene cut. Both go to MiniMax M3.1 Flash on GMI Cloud with a word budget for each silence. The model answers with 1 line per gap, the browser speaks each line as its gap opens, and the same lines go out as a WebVTT descriptions file. On the Sintel clip in the video, 27 gaps and 209 frames, a medium-depth run wrote 159 words in 27 lines for $0.0187. This post covers the parts the video does not: the silence and frame math, the cast sheet that keeps names stable, the budget rule, what low and medium thinking changed, and where the tokens go.

    2026年11月11日

    The video shows an audio description track being spoken into the gaps of a 3-minute clip. Below I go through the gap detection and the cast sheet. A later section compares what low and medium thinking depth cost.

    The model, briefly

    M3.1 Flash has been out since October 19, 2026. It is a mixture-of-experts model, reported at roughly 428B parameters with 23B active per token, with MiniMax's own sparse attention, a native visual encoder, and a 1M-token context. On GMI Cloud it is $0.15 per million input tokens and $0.60 per million output, with cached input at $0.015, half of what M3 costs on GMI Cloud ($0.30 in, $1.20 out). The price does not step up for long prompts.

    MiniMax M3.1 Flash on GMI Cloud

    Model id

    MiniMaxAI/MiniMax-M3.1-Flash

    Inputs

    text, image, video

    Context

    1,000,000 tokens

    Thinking

    cannot be turned off; reasoning_effort takes low, medium, high, xhigh or max and defaults to max

    Price

    $0.15 in, $0.60 out, $0.015 cached input, per million tokens

    Published scores

    DeepSWE v1.1 73.7 and OSWorld V2 61.7 (MiniMax), Artificial Analysis Intelligence Index 42 at max effort

    M3.1 Flash is half the price of M3 on GMI Cloud, in and out

    Both facts in the Thinking row matter for the price of a job like this. A request that never sets reasoning_effort thinks at max depth; this clip sends 8 requests, and a library sends hundreds. I set it per request, and the 2 runs below are what low and medium did with the same frames.

    Step 1: find the silences

    Audio description goes in the gaps between dialogue, so the first job is to find the gaps. The server runs ffmpeg's silencedetect over the soundtrack with a threshold of -30 dB and a minimum of 1 second. Any 2 silences closer than 0.3 s are merged.

    On the 2:58 Sintel clip that is 27 gaps totaling 67 seconds. Then each gap gets a word budget: 2.6 words per second of the gap after 0.3 s is trimmed from each end, rounded down, with a floor of 2 words. The trim keeps the voice off the dialogue.

    27 silences, 67 s in total: most are 1 to 3 s, and the word budget follows the gap

    19 of the 27 gaps are under 3 seconds, which means a budget of 2 to 5 words, enough for "Embers drift." 4 more sit between 3 and 4 seconds with budgets of 6 to 8. The 4 long gaps, 4 to 5.5 seconds, get a full sentence of 8 to 12 words. Without a budget the model writes paragraphs that cannot be spoken before the next line of dialogue.

    Step 2: pull the frames

    Frames are sampled at 1 per second and at every scene cut, resized to at most 512 px wide, and encoded as JPEG. The cut times come from ffmpeg's scene-change detector.

    For this clip that is 178 time-sampled frames plus 31 cut frames, 209 in all. They go to the model as image_url data URLs with a [t=12.0s] text label in front of each one so the model can line a picture up with a gap.

    MiniMax documents a video_url input. I send frames because each frame has a known token count and a timestamp, and I pick which moments the model sees. Measured across the run, the frames came to about 38,000 input tokens, roughly 180 per 512 px frame, which at $0.15 per million is about half a cent.

    Step 3: a cast sheet before the first line

    My first prompt stopped making sense within 3 batches, because the same character changed names from batch to batch. The fix is a separate first request. It sends 12 frames spaced across the clip with 1 instruction: name every recurring character and place with a short label and 1 line on how they look.

    The October 21 run produced 3 character labels: the red-haired woman, the old man and the baby dragon. Every later request carries that sheet, and the system prompt says to use the labels verbatim. The names stay the same from the hut to the market because every batch is given the same labels.

    Step 4: batches in order, with memory

    The 209 frames are grouped by scene, the stretches between those 31 cuts, into batches of at most 36 frames: 7 batches for this clip, plus the cast sheet, 8 requests. The batches are sequential, and each prompt includes the cast sheet and the 6 most recent lines. I tried parallel batches first. They were quicker, but each batch described its scene as if the clip had just started. Sequential batches with the last 6 lines in the prompt fixed that.

    Here is the request for 1 batch, with the system prompt abridged:

    {
      "model": "MiniMaxAI/MiniMax-M3.1-Flash",
      "reasoning_effort": "medium",
      "max_completion_tokens": 12000,
      "stream": true,
      "stream_options": {"include_usage": true},
      "messages": [
        {"role": "system", "content": "You write audio description for blind viewers. Present tense. Visible facts only. Who, where, what changed, in that order. Use the cast labels verbatim. Never exceed the word budget. Answer in JSON lines, one per gap."},
        {"role": "user", "content": [
          {"type": "text", "text": "Cast sheet (use these labels exactly): ...\nAlready spoken (for continuity; do not repeat): [1.3s] ... [8.3s] ...\ngap 12: t=49.63 dur=2.38 budget=4 words\ngap 13: t=53.78 dur=3.48 budget=7 words\n..."},
          {"type": "text", "text": "[t=32.8s · scene cut]"}, {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}},
          {"type": "text", "text": "[t=33.0s]"}, {"type": "image_url", "image_url": {"url": "data:image/jpeg;base64,..."}}
        ]}
      ]
    }

    The model answers 1 JSON line per gap, then a title line per scene and a notes line. The page parses them as they stream, so a line appears on the timeline while the model is still writing the next one. The output lines look like this, with the timestamps of gaps 6 and 7:

    {"t": 30.05, "dur": 3.84, "text": "The red-haired woman gazes into a steaming bowl.", "words": 8, "extended": false}
    {"t": 35.21, "dur": 1.26, "text": "Embers drift.", "words": 2, "extended": false}

    The extended flag is the one place the model is allowed to break the budget. Some facts, like a change of place or a character's first appearance, land in a gap too short to hold them. Professional describers pause the picture for 1 sentence in that case. The page does the same: when the line cannot fit even at the top speech rate, it pauses the video, speaks the line, then resumes. The rule in the prompt allows it on at most 1 gap in 5; the medium run used it 4 times in 27.

    Step 5: speech and the VTT file

    Web Speech reads each line 0.3 s into its gap, after the margin. The rate is fitted to the gap, words / (2.6 * usable seconds), clamped between 1.0 and 1.3, and the film's volume drops to a quarter while the voice speaks. The same lines are written out as a WebVTT file with Kind: descriptions, which is what a player or a captioning workflow would take.

    The timeline after a run: gray is dialogue, lime is a gap with a line in it

    What low and medium changed

    Both runs used the same clip, 209 frames, 27 gaps and 8 requests, 7 scene batches plus the cast sheet; only reasoning_effort and the day differ. The table has the counts and speeds; the chart under it has the words, time and cost.

    Low (Oct 20, 2026)

    Medium (Oct 21, 2026)

    Descriptions written

    27 of 27

    27 of 27

    Image tokens, all batches

    about 38,000

    about 38,000

    Output tokens, including thinking

    5,400

    19,800 (17,800 of it thinking)

    Output speed

    122 tokens per second

    103 tokens per second

    Thinking depth: medium writes 29% more words for 2x the cost and 10x the wall time

    Both runs covered every gap. The sentences differ. At low, gaps with room for a sentence still came back as fragments. At medium a 4-second gap gets "The red-haired woman gazes into a steaming bowl." I would ship the medium track. Low is useful while you are iterating on the prompt, because the whole clip comes back in under half a minute.

    Where the 66K tokens of a medium run go: frames in, thinking out, 2K of description

    Here is where the tokens go. Input is the frames plus about 8,000 tokens of rules, gaps, cast sheet and memory across 8 requests, about 46,000 tokens at $0.15 per million, under a cent. Output at medium is about 19,800 tokens at $0.60 per million, and 90% of that is thinking. The visible output, the JSON lines plus the cast sheet, is about 2,000 tokens. The medium run costs 2x the low run because of thinking: 19,800 output tokens, 17,800 of them thinking, against 5,400 at low. That thinking is where the longer sentences come from.

    The same rate on a library

    A feature film is 76 cents; 1,000 titles are $758

    At the medium run's rate, $0.0187 for 2:58, an hour of video is about 38 cents and a 2-hour feature about 76 cents. 1,000 features come to about $758. Dialogue density changes the gap count, so a quiet documentary has more to describe than an action film, but the order of magnitude holds.

    Where to be careful

    • The default thinking depth is max. For many small requests, pick the lightest depth that still writes well, and measure output tokens per finished clip before trusting the price list.

    • Budget in words, because the speech engine reads at a roughly fixed pace. A per-second word budget keeps lines inside their gaps, and the 0.3 s margins at each end are what stop the voice from overlapping dialogue.

    • The cast sheet should come first. Any job that spans many requests over 1 story needs it, and 12 frames plus 1 extra request did it here.

    • Run the batches in order. Memory of the last few lines is cheap in tokens and stops every batch from starting the story over.

    • Frames are the right input when you need control over what the model sees and what it costs.

    • Treat the track as a first draft. The model does not know what matters to the story, and at low depth its sentences go flat. A human describer still edits for the story. The first draft, from finding the gaps to writing the lines, costs about 2 cents.

    A note on the numbers. Every number in this post comes from the GMI Cloud MaaS inference engine on a Tier 5 account, so your cost and wait times will vary with your account tier, queue load on the day, and the provider's own capacity. If you need faster or more predictable turnaround, a dedicated endpoint runs your model on reserved capacity and removes the queue wait.

    Three takeaways

    1. Silence detection, frame sampling and word budgets are ffmpeg and arithmetic. No model is involved until the writing, and M3.1 Flash wrote the 27 lines, 4 of them marked extended.

    2. The cast sheet and the sequential memory fixed the naming without changing the model or the depth.

    3. Low ran in 23 s for 0.9 cents. Medium took 4 minutes for 1.9 cents and wrote the better track. Both cost far less than an hour of a describer's time, so I would pick the depth on output quality and not on price.

    Where I Land

    43 million people are blind, and most video has no description track for them, because a describer has to watch, write, time and record every line of it. The video shows the track being spoken. The part I wanted to write down is the work around the model. The server finds the 67 seconds the voice may use. The cast sheet gives the model the names before it starts. The budget caps each line. With that in place, a 15-cent-per-million model wrote a track a listener can follow for 2 cents. The describer's time can go to editing it.

    Ready to build? Get Started

    Grace Deng

    DevRel @ GMI Cloud

    Build AI Without Limits

    GMI Cloud helps you architect, deploy, optimize, and scale your AI strategies

    Ready to build?

    Explore powerful AI models and launch your project in just a few clicks.

    Get Started