MiniMax H3 Max : est-il vraiment en temps réel ?

MiniMax H3 Max peut être plus rapide que le temps réel selon une définition précise : fal rapporte avoir généré un clip de cinq secondes en moins de trois secondes sur sa pile de diffusion optimisée. Cela ne signifie pas que chaque requête de cinq secondes arrive à l'écran de l'utilisateur en trois secondes, ni que le modèle diffuse en continu les images terminées. La mise en file d'attente, l'expansion de l'invite, le traitement de la sortie, le sondage et le téléchargement restent tous en dehors d'une mesure d'inférence étroite.^[1]

Cette distinction est visible dans les chiffres de première partie. MiniMax Design déclare qu'une vidéo H3 Max de cinq secondes prend environ 15 secondes là et une vidéo de 15 secondes environ 40 secondes, avec un temps réel variable selon les paramètres et les conditions du service.^[2] Les deux affirmations peuvent être vraies. Elles décrivent des systèmes et des limites de mesure différentes.

Réponse rapide

• Le temps réel "plus rapide que" signifie que la génération s'achève avant la fin de la lecture du clip ; il ne signifie pas la diffusion d'images en direct.
• Le résultat de fal en moins de trois secondes mesure sa propre pile H3 Max optimisée, pas une promesse API universelle.^[1]
• MiniMax Design estime une attente plus longue sur sa surface, c'est pourquoi une application doit mesurer séparément file, génération, transfert et téléchargement.^[2]
• Rapportez le temps par clip accepté. Un résultat rapide rejeté n'ajoute aucun débit utilisable.

Ce que le temps réel signifie pour une vidéo générée

Utilisez un ratio avant d'utiliser l'étiquette. Le calcul pratique standard est :

facteur temps réel (RTF) = temps de génération / durée de lecture de la sortie

Pour une sortie de cinq secondes :

La formule est simple ; le numérateur ne l'est pas. Le "temps de génération" peut signifier inférence GPU, durée murale du fournisseur, durée de POST à tâche achevée, ou durée jusqu'à ce qu'un lecteur dispose de l'intégralité du MP4. Étiquetez le numérateur chaque fois que vous publiez un RTF.

Ce sont quatre mesures différentes :

1. RTF d'inférence : exécution du modèle divisée par durée de sortie.
2. RTF du fournisseur : admission du fournisseur à travers sortie finalisée, si le fournisseur publie cette limite.
3. RTF API observée : client POST jusqu'à première réponse terminale.
4. RTF prête à la lecture : client POST jusqu'à fichier téléchargé ou mis en tampon avec succès.

Seuls les deux derniers décrivent l'attente dans votre application. Le RTF d'inférence est toujours utile pour comparer le travail de diffusion, mais il ne peut pas tenir compte d'une file que le client ne peut pas voir.

La génération plus rapide que le temps réel n'est pas la même que la diffusion

Le modèle courant d'API H3 Max est asynchrone : soumettez un travail, recevez un ID, attendez un MP4 achevé. Un clip peut s'achever plus rapidement que sa propre durée sans livrer l'image un en avance. C'est une génération par lots rapide, pas une preuve de diffusion vidéo progressive.

Un système de lecture continu peut plutôt générer les clips à venir pendant la lecture d'un clip approuvé et maintenir une file d'attente en avant. C'est un pipeline mis en tampon. Il peut sembler continu même quand chaque génération arrive sous forme de fichier complet.

Pourquoi fal et MiniMax Design publient des temps H3 Max différents

fal a développé la variante H3 Max post-entraînée et optimisé son système d'inférence en parallèle. Son annonce de lancement rapporte un clip de cinq secondes en moins de trois secondes de durée murale et environ 35 fois le débit du point de terminaison H3 officiel de MiniMax dans l'évaluation de fal.^[1] Le résultat appartient à la combinaison modèle-et-diffusion de fal.

MiniMax Design donne une estimation face à l'utilisateur pour une surface différente : environ 15 secondes pour cinq secondes de sortie et 40 secondes pour 15 secondes de sortie. Sa page avertit explicitement que le temps réel varie avec les paramètres et les conditions du service.^[2]

L'écart peut contenir plusieurs étapes :

POST envoyé
  -> authentification et validation
  -> admission en file d'attente
  -> traitement d'invite optionnel
  -> inférence du modèle
  -> codage et vérifications de sécurité
  -> stockage et publication des résultats
  -> sondage client suivant
  -> téléchargement MP4 ou mise en tampon du lecteur

Les différents fournisseurs peuvent également exécuter du matériel différent, des règles de traitement par lot, des limites de concurrence, l'expansion d'invite et les implémentations de point de terminaison. Même au sein d'un fournisseur, 480P et 768P ne doivent pas avoir la même distribution de latence. Il n'existe aucun moyen valable de convertir un nombre de lancement en une promesse pour une autre route.

Mesurez MiniMax H3 Max de bout en bout sur la route que vous expédierez

Un test de latence utile commence avant le POST et se termine quand la sortie est réellement utilisable. Gardez l'invite, la durée, la résolution, l'élément source, le compte et la région fixes lors de la mesure d'une base de référence. Modifiez une variable à la fois après cela.

Enregistrez ces horodatages :

Le sondage signifie que le moment exact d'achèvement se situe entre t2 et t3. Ne rapportez pas t3 - t0 à la précision milliseconde comme si le serveur exposait un horodatage d'achèvement précis. Si vous sondez toutes les trois secondes, l'observation peut arriver près de trois secondes après le changement d'état ; la mise en cache peut élargir cette incertitude.

L'API Tasks de reAPI recommande un cycle de sondage de deux à trois secondes et note que les réponses de tâches en transit sont mises en cache pendant cinq secondes. Le sondage plus rapide augmente la pression des demandes sans accélérer la fin de la vidéo.^[4]

Un harnais de synchronisation Node.js pour reAPI

Le script ci-dessous soumet un travail de 480P de cinq secondes unique et payant, mesure le temps visible du client et télécharge le fichier renvoyé en mémoire. Il ne prétend pas mesurer le noyau d'inférence de fal. Vérifiez la page de modèle en direct et votre compte avant de l'exécuter.^[5]

const API_BASE = 'https://reapi.ai/api/v1';
const API_KEY = process.env.REAPI_API_KEY;

if (!API_KEY) throw new Error('Set REAPI_API_KEY');

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function readJson(response) {
  const body = await response.json().catch(() => ({}));
  if (!response.ok) {
    const message = body.error?.message ?? response.statusText;
    throw new Error(`HTTP ${response.status}: ${message}`);
  }
  return body;
}

const t0 = performance.now();

// Submit once. Do not automatically repeat this POST after an ambiguous
// network failure: the first request may already have created a paid task.
const submission = await readJson(
  await fetch(`${API_BASE}/videos/generations`, {
    method: 'POST',
    headers,
    body: JSON.stringify({
      model: 'minimax-h3-max',
      prompt:
        'One continuous shot of a red paper boat moving through a shallow rain gutter while the camera tracks beside it; natural rain and street ambience, no dialogue.',
      aspect_ratio: '16:9',
      duration: 5,
      resolution: '480P',
    }),
  }),
);

const t1 = performance.now();
let lastProcessingAt = t1;
let task;
const deadline = Date.now() + 30 * 60 * 1000;

while (Date.now() < deadline) {
  await sleep(3000);
  task = await readJson(
    await fetch(`${API_BASE}/tasks/${submission.id}`, {
      headers: { Authorization: `Bearer ${API_KEY}` },
    }),
  );

  const observedAt = performance.now();

  if (task.status === 'processing') {
    lastProcessingAt = observedAt;
    continue;
  }

  if (task.status === 'failed') {
    throw new Error(
      `${task.error?.code ?? 'FAILED'}: ${task.error?.message ?? 'Unknown error'}`,
    );
  }

  if (task.status === 'completed') {
    const t3 = observedAt;
    const videoUrl = task.output?.video_urls?.[0];
    if (!videoUrl) throw new Error('Completed task has no video URL');

    const download = await fetch(videoUrl);
    if (!download.ok) {
      throw new Error(`Download failed: HTTP ${download.status}`);
    }
    const bytes = (await download.arrayBuffer()).byteLength;
    const t4 = performance.now();

    console.table({
      task_id: submission.id,
      output_seconds: 5,
      submit_round_trip_ms: Math.round(t1 - t0),
      completion_after_ms_lower_bound: Math.round(lastProcessingAt - t0),
      completion_after_ms_upper_bound: Math.round(t3 - t0),
      playback_ready_ms: Math.round(t4 - t0),
      observed_api_rtf: Number(((t3 - t0) / 5000).toFixed(2)),
      playback_ready_rtf: Number(((t4 - t0) / 5000).toFixed(2)),
      downloaded_bytes: bytes,
    });
    break;
  }
}

if (!task || task.status === 'processing') {
  throw new Error(
    `Local polling deadline reached for ${submission.id}; resume GET requests instead of submitting again.`,
  );
}

Exécutez le même harnais sur des fenêtres de temps séparées plutôt que de tirer une grande salve qui change la file que vous essayez d'observer. Enregistrez chaque résultat, y compris les échecs. Un petit pilote peut rapporter la médiane et la plage complète ; réservez un percentile de queue comme p95 pour un échantillon assez grand pour le soutenir.

Comparez la latence sans modifier accidentellement le travail

Les paramètres correspondants sont nécessaires mais insuffisants. Utilisez la même URL source, les mêmes octets d'invite, le même rapport d'aspect, la même durée et la même résolution. Si un fournisseur étend l'invite et un autre non, enregistrez cette différence plutôt que de prétendre que les demandes étaient identiques en interne.

Pour chaque exécution, conservez :

• ID de modèle, fournisseur, point de terminaison, région du compte et date d'observation ;
• Mode T2V ou I2V et hachage de chaque élément d'entrée ;
• durée et résolution;
• temps d'aller-retour de soumission, limites d'achèvement et temps de téléchargement ;
• état terminal et code d'erreur ;
• si le clip a réussi le contrôle d'acceptation créative.

Ne mélangez pas un brouillon H3 Max 480P de cinq secondes avec un clip H3 de base 768P de 15 secondes et appelez la différence un benchmark de modèle. De même, un temps d'inférence fal et un temps d'interface utilisateur MiniMax Design ne doivent pas être dans une colonne "gagnant" sauf si le tableau étiquette leurs limites de mesure.

Le débit, la concurrence et les clips acceptés sont des nombres distincts

La latence est l'attente d'un travail. Le débit est la quantité de travail qu'un système achève au fil du temps. Un fournisseur peut avoir d'excellentes inférences par tâche unique et limiter néanmoins les demandes simultanées ; un autre peut prendre plus longtemps par travail tout en terminant plus de travaux en parallèle.

Pour un canal mis en tampon qui doit lire un clip après l'autre, une estimation approximative de travailleur est :

travailleurs concurrents requis ~= ceil(
  queue secondes de fin à fin
  / (clip secondes × taux d'acceptation créative)
)

Ceci est une approximation de planification, pas une garantie de capacité. Si un clip de 10 secondes prend 20 secondes à la latence de queue choisie et que seule la moitié des sorties réussissent, un travailleur fournit 0,5 clips acceptés toutes les 20 secondes. Garder un créneau de lecture de dix secondes rempli nécessiterait environ quatre travailleurs avant d'ajouter de la marge de sécurité, des défaillances de modération ou un examen éditorial.

Le tampon compte aussi. Générez plusieurs clips approuvés avant le début de la lecture, puis continuez à produire les emplacements suivants pendant que les spectateurs regardent l'actuel. Si le tampon atteint zéro, le flux s'arrête indépendamment d'une médiane impressionnante.

Un chronomètre ne peut pas noter le son ou l'histoire

H3 Max préserve la génération audio-vidéo conjointe de H3 selon l'annonce de lancement de fal.^[1] Cela rend l'examen d'acceptation partie de toute affirmation en temps réel. Un clip achevé n'est pas utilisable si le mauvais caractère parle, le dialogue traverse entre les voix, un signal sonore se pose sur la mauvaise action, ou le coup suivant oublie le cadre précédent.

Classez chaque clip selon les exigences qui importent pour l'application :

Ensuite, rapportez à la fois le débit de fin d'achèvement brut et le débit d'achèvement accepté. Ce dernier est le nombre qui peut garder une application en vie.

FAQ

MiniMax H3 Max est-il plus rapide que le temps réel ?

fal rapporte une vidéo de cinq secondes en moins de trois secondes sur sa pile optimisée, ce qui est plus rapide que le temps réel pour cette mesure. Testez la route que vous avez l'intention d'utiliser ; le chiffre ne garantit pas la latence de bout en bout ailleurs.

Pourquoi MiniMax Design dit-il environ 15 secondes pour un clip de cinq secondes ?

C'est une surface de livraison différente et une estimation face à l'utilisateur. MiniMax dit que le temps varie avec les paramètres et les conditions du service. La mise en file d'attente et le traitement en dehors de l'inférence du modèle peuvent également faire partie de l'attente observée.

H3 Max en temps réel génère-t-il un flux en direct image par image ?

Pas sur la base des points de terminaison asynchrones standard. Ils retournent des fichiers vidéo achevés. Une expérience continue peut être construite en générant des clips ultérieurs pendant la lecture des clips approuvés et en maintenant un tampon en avant.

La résolution affecte-t-elle la vitesse MiniMax H3 Max ?

Elle peut affecter le travail effectué, mais aucun multiplicateur unique ne doit être supposé. Comparez les deux 480P et 768P sur le point de terminaison choisi si les deux importent. Les contrats H3 Max directs et reAPI MiniMax actuels n'offrent pas de 2K.^[3]

Puis-je comparer la valeur timings.inference fal de fal avec mon chronomètre reAPI ?

Seulement si le tableau les étiquette comme des métriques différentes. L'un est un champ d'inférence backend sur fal ; l'autre est un chemin observé par client qui peut inclure admission, mise en file d'attente, sondage, stockage et temps réseau.

Combien de tests suffisent ?

Il n'y a pas de compte universel. Exécutez suffisamment pour couvrir les invites, les modes, les paramètres et les fenêtres de temps que vous expédierez. Avec un petit pilote, publiez la médiane et la plage complète plutôt qu'un p95 instable, et gardez les rejets créatifs dans le dossier.

Publiez l'attente que l'utilisateur ressent réellement

"MiniMax H3 Max en temps réel" n'est défendable qu'avec une horloge nommée. Le résultat de fal montre ce que sa pile co-optimisée peut faire. L'estimation de MiniMax Design montre qu'une surface de produit différente peut exposer une attente plus longue. Votre application a besoin de son propre numéro POST-to-playback, mesuré sur sa propre route et associé à un taux d'acceptation.

Gardez le RTF d'inférence, le RTF API observé, le RTF prêt à la lecture et les clips acceptés par heure comme des champs distincts. Ensuite, une réclamation de vitesse devient un nombre d'exploitation reproductible au lieu d'une phrase empruntée à un message de lancement.

Références

1. fal. Introducing H3 Max by fal. Published August 26, 2026. fal.ai
2. MiniMax Design. MiniMax H3 Max—Fast AI Video Generator. Retrieved September 7, 2026. design.minimax.io
3. MiniMax API. Create Video Generation Task V2. Retrieved September 7, 2026. platform.minimax.io
4. reAPI. Tasks API: polling, status, and output. Retrieved September 7, 2026. reapi.ai
5. reAPI. MiniMax H3 Max model page and request controls. Retrieved September 7, 2026. reapi.ai

Lecture supplémentaire

• MiniMax H3 Max vs MiniMax H3
• Guide API MiniMax H3
• Tarification de l'API de génération vidéo IA