Multimodaalinen hinnoittelu: mitä kuvat, ääni ja video todella laskuttavat

Transformer ottaa sisäänsä vektorijonon. Sillä ei ole mielipidettä siitä, mistä ne tulivat. Luku 8 syötti sille token id:n perusteella haettuja embeddings; mikään arkkitehtuurissa ei vaadi hakua.

Siis: leikkaa kuva kiinteisiin neliöihin, litistä jokainen neliö numerolistaksi ja työnnä kukin lista yhden opitun lineaarisen kerroksen läpi, jotta saat modelin leveyden mukaisen vektorin. Väripikseleistä koostuva 32 × 32 patch on $32 \times 32 \times 3 = 3072$ numeroa; projektio $E \in \mathbb{R}^{d \times 3072}$ muuttaa sen yhdeksi $d$-ulotteiseksi vektoriksi, täsmälleen samaan muotoon jossa teksti-token saapuu. Siinä kaikki, ja tästä kertoo paperi jo otsikossaan: kuva on 16 × 16 sanan arvoinen.¹ Lisää sijaintikoodaus, jotta model tietää mikä neliö oli missä, lomita tulokset text embeddingsien kanssa, ja modelin lukema jono on osittain kuvaa ja osittain virkettä.

Kolme paperia teki siitä tuotteen. CLIP koulutti kuvaenkooderin ja tekstienkooderin olemaan samaa mieltä neljästäsadasta miljoonasta kerätystä parista, ja siinä kohtaa ajatus siitä, että pikselit ja sanat voivat jakaa avaruuden, lakkasi olemasta hypoteesi.² Flamingo pulttasi jäädytetyn vision encoderin jäädytettyyn kielimalliin muutamalla koulutetulla siltakerroksella.³ LLaVA osoitti, että silta saattoi olla yksi lineaarinen projektio ja että instruction-following voitiin opettaa generoidulla datalla, minkä vuoksi jokainen avoin vision-language model sen jälkeen näyttää suunnilleen samalta.⁴

Seuraus laskullesi on välitön ja epäglamourinen: patchit ovat sijainteja jonossa, joten ne ovat input tokens, joten maksat niistä input-hinnalla. Kuinka monta niitä on, on aritmetiikkaa, ja jokainen provider tekee sen eri tavalla.

Jokainen alla oleva sääntö on toteutettu providerin omasta dokumentaatiosta ja tarkistettu saman dokumentaation laskettuja esimerkkejä vasten.

OpenAI peittää kuvan 32 × 32 patcheilla ja kertoo määrän model-kohtaisella kertoimella. Jos patchien määrä ylittää kyseisen modelin ja detail-tason budjetin, kuva skaalataan alas, kunnes se mahtuu:

Anthropic peittää sen 28 × 28 patcheilla, yksi visual token kukin, ja rajoittaa sekä pitkän sivun että token-määrän — standard-tier-malleissa 1 568 pikseliä ja 1 568 tokens, high-resolution-tierillä 2 576 ja 4 784. Ylisuuret kuvat skaalataan suurimpaan kokoon, joka mahtuu molempiin.⁵

Google ei laske pikseleitä lainkaan. Kuva, jonka molemmat sivut ovat enintään 384 pikseliä, maksaa kiinteät 258 tokens. Kaikki suurempi leikataan 258 tokenin tileiksi, ja tile-ruudukko tulee crop-yksiköstä $\lfloor \min(w,h) / 1.5 \rfloor$.⁶

export function openaiImageTokens(
  w: number, h: number,
  { maxDim, patchBudget, multiplier }: { maxDim: number; patchBudget: number; multiplier: number },
) {
  const fit = Math.min(1, maxDim / Math.max(w, h));      // never enlarges
  w = Math.floor(w * fit); h = Math.floor(h * fit);
  let patches = Math.ceil(w / 32) * Math.ceil(h / 32);   
  if (patches > patchBudget) {
    const s = Math.sqrt((32 * 32 * patchBudget) / (w * h));
    const adj = s * Math.min(
      Math.floor((w * s) / 32) / ((w * s) / 32),
      Math.floor((h * s) / 32) / ((h * s) / 32));
    patches = Math.ceil(Math.floor(w * adj) / 32) * Math.ceil(Math.floor(h * adj) / 32);
  }
  return Math.ceil(patches * multiplier);                
}

export function anthropicVisualTokens(
  w: number, h: number,
  { maxLongEdge, maxTokens }: { maxLongEdge: number; maxTokens: number },
) {
  const tok = (a: number, b: number) => Math.ceil(a / 28) * Math.ceil(b / 28);
  const long = Math.max(w, h), short = Math.min(w, h);
  for (let L = Math.min(long, maxLongEdge); L >= 1; L--) {     
    const t = tok(L, Math.round((short * L) / long));
    if (t <= maxTokens) return t;                              
  }
  return 0;
}

export function geminiImageTokens(w: number, h: number) {
  if (w <= 384 && h <= 384) return 258;
  const crop = Math.floor(Math.min(w, h) / 1.5);               
  return Math.ceil(w / crop) * Math.ceil(h / crop) * 258;      
}

Aja kukin niitä lukuja vasten, jotka sen oma toimittaja julkaisee:

OpenAI, gpt-5.4 at detail:high (2048 px, 2,500 patches, 1.2x)
  1024x1024 -> 1024 patches -> 1229 tokens   doc says 1229   MATCH
  2048x2048 -> 2500 patches -> 3000 tokens   doc says 3000   MATCH

Anthropic, the published table (one tier per row shown)
  200x200    std   64 @ 200x200     doc   64, not resized    OK
  1000x1000  std 1296 @ 1000x1000   doc 1296, not resized    OK
  1092x1092  std 1521 @ 1092x1092   doc 1521, not resized    OK
  1920x1080  std 1560 @ 1456x819    doc 1560, 1456x819       OK
  2000x1500  std 1564 @ 1269x952    doc 1564, 1269x952       OK
  3840x2160  hi  4784 @ 2576x1449   doc 4784, 2576x1449      OK

Google, the worked example
  960x540 -> crop 360 -> 3 x 2 = 6 tiles     doc says 6      MATCH

Tulostuu yhdeksän täsmäystä; koko ajo tarkistaa viisitoista, koska Anthropicin taulukko antaa molemmat tierit kaikille kuudelle koolle. Säännöt ovat nyt sinun ajettavissasi millä tahansa valokuvallasi, ja se on pointti: nämä ovat tämän luvun ainoat kolme funktiota, joita et saa hintasivulta.

Aja sama 4:3-valokuva kaikkien kolmen läpi kuudessa koossa:

Lue viimeinen sarake alaspäin. Kun kuva on yli 384 pikseliä, luku ei enää koskaan muutu, eikä se ole sattuma eikä katto. Sijoita crop-yksikkö takaisin tile-kaavaan kuvalle, joka on vähintään yhtä leveä kuin korkea:

Koko supistuu pois. Googlen image tokens riippuvat kuvasuhteesta eivätkä mistään muusta. 4:3-valokuva on neljä tileä riippumatta siitä, onko se thumbnail vai juliste. Tuo yksi algebrallinen fakta selittää kokonaan yllä olevan säästötaulukon nollan, eikä yksikään hintasivu sano sitä.

Kaksi muuta saraketta taas leikkaavat kattoon, eri korkeuksissa ja eri syistä — Anthropic ilmoitetussa token-katossa, OpenAI patch-budjetissa pikselirajan jälkeen — ja siksi kolme käyrää risteävät eri kokoisina.

Riko se nyt. Ilmeinen tapa kuluttaa vähemmän vision modeliin on pyytää vähemmän yksityiskohtia, joten lähetä detail: "low":

1600x1200   low = 2280   high = 2280   ratio 1.00
3200x2400   low = 3687   high = 2942   ratio 1.25

Vähemmän detailiä pyytäminen maksoi 25 % enemmän. Tämä ei ole bugi, ja OpenAI sanoo sen yhdellä rivillä kokotaulukossa: tuossa model-perheessä low käyttää 2048 pikselin rajaa ja 6 144 patchin budjettia, kun taas high käyttää samaa pikselirajaa ja 2 500 patchin budjettia, ”joten se voi käyttää enemmän tokens kuin high”.⁷ Sana low nimeää fidelity-asetuksen, ei hintaa: kahdessa viidestä dokumentoidusta model-perheestä se ei tuo säästöä lainkaan, ja toisessa niistä se maksaa enemmän.

Kaikki tähän asti on ollut modelin lukemaa kuvaa. Kuvan tekeminen pyörii mekanismilla, jossa ei ole tokens lainkaan, ja juuri siksi sitä myydään kuvittain eikä sanoittain.

Toimittajat julkaisevat kuvageneroinnin hintana per kuva. Se ei ole sitä. GPT Image -mallit tuottavat erikoistuneita image tokens, joiden määrä riippuu pyydetystä koosta ja laadusta; kerro julkaistut määrät GPT Image 1:n julkaistulla image output -hinnalla $40 per miljoona ja vertaa saman sivun kuvakohtaisiin hintoihin:

Yhdeksän johdettua lukua yhdeksää julkaistua vasten, ja jokainen pari täsmää $0.002 sisään.¹¹ Google on vielä eksplisiittisempi ja tekee muunnoksen puolestasi itse hintasivulla: image output $60 per miljoona tokens, ”output images at 1K (1024x1024px) consume 1120 tokens and are equivalent to $0.067 per image”.¹²

Kuvakohtainen hinta on siis token-kohtainen hinta, jossa määrä on taitettu sisään. Se on ihan ok, ja se piilottaa jotakin. Ota nykyisen sukupolven taulukko ja jaa taaksepäin:

quality   1024x1024            1024x1536
low       $0.006 -> 200 tok    $0.005 -> 167 tok
medium    $0.053 -> 1767 tok   $0.041 -> 1367 tok
high      $0.211 -> 7033 tok   $0.165 -> 5500 tok

Suurempi kuva on halvempi kaikilla laaduilla. 1024 × 1536 canvasissa on 50 % enemmän pikseleitä kuin 1024 × 1024 -kuvassa ja se maksaa medium-tasolla 23 % vähemmän tokens. OpenAI liputtaa sen lauseessa, jonka ohittaisit — ”a larger non-square resolution can sometimes produce fewer output tokens than a smaller or square resolution at the same quality setting” — ja edellisessä model-sukupolvessa se meni toiseen suuntaan: pystykuva maksoi 50 % enemmän kuin neliö.¹¹ Jokainen ennen tuota muutosta kirjoitettu 1024x1024-oletus on nyt kallis vaihtoehto.

Pyydä kolmea tuotetta puhumaan samat 519 merkkiä — noin 38 sekuntia ääntä — ja saat kahdelta toimittajalta kolme yksikköjärjestelmää:

Sama toimittaja myy molempia yksiköitä: OpenAI:n tts-1 hinnoitellaan per miljoona merkkiä, kun taas gpt-4o-mini-tts hinnoitellaan per miljoona tokens, $0.60 sisään ja $12.00 ulos.¹³ Niinpä ”halvin text-to-speech” ei ole kysymys, jolla on vastaus, ennen kuin sanot mitä puhutaan.

Ja kaksi yksikköä ovat sokeita vastakkaisille asioille. Merkkikohtainen hinta ei näe kestoa: valitse hidas, harkitseva ääni tai lisää taukoja, eikä lasku liiku, vaikka audio pitenee. Sekuntikohtainen hinta ei näe sisältöä: kolmekymmentä sekuntia maksaa saman, olipa se tiivis tekninen kappale tai joku laskemassa kymmeneen. Vaihda ääni, ja täsmälleen yksi kahdesta toimittajastasi hinnoittelee uudelleen.

Transkriptio menee toiseen suuntaan ja on koko laskun yksinkertaisin rivi — per minuutti audiota, kiinteästi:

whisper                  $0.005960     ($0.006 / min)
gpt-transcribe           $0.004470     ($0.0045 / min)
gpt-4o-mini-transcribe   $0.002980     ($0.003 / min)
gpt-live-transcribe      $0.016887     ($0.017 / min)

Huomaa viimeinen rivi verrattuna kolmanteen: sen tekeminen livenä, sanojen saapuessa, maksaa 5,7 kertaa enemmän kuin valmiille tiedostolle. Tuo ero on hinta siitä, ettei voi batchata, ja se tekee seuraavasta osiosta kalliin.

Nyt luku, joka päättää onko voice ominaisuus vai tuote.

Puhelu: kymmenen vuoron tukikeskustelu, 149 sanaa, mikä ilmoitetulla 150 sanan minuuttinopeudella on 59,6 sekuntia puhetta — 21,2 soittajan puhumana, 38,4 vastauksena. Token-muunnokset ovat providerien omia. OpenAI: ”audio tokens in user messages are 1 token per 100 ms of audio, while audio tokens in assistant messages are 1 token per 50 ms”.¹⁴ Google: 25 tokens sekunnissa molempiin suuntiin, minkä sen hintasivu vahvistaa julkaisemalla $12.00 per miljoona ja $0.018 per minuutti samalla rivillä.¹²

Keskustelu kertyy täsmälleen kuten luku 16 sanoi, koska mekanismi on sama: ”the entire conversation is sent to the model for each Response... thus turns later in the session will be more expensive”.¹⁴ Vain nyt historia mitataan audio tokens.

Nyt vertailu, joka päättää tuotteen, kaikki neljä normalisoituna minuuttiin:

Kolmekymmentäkahdeksan kertaa. Ei kolmekymmentäkahdeksan prosenttia. Sama vaihto äänessä tekstin sijaan on lähes kaksi kertaluokkaa kalliimpi, eikä mikään tuosta erosta ole marginaali, jonka joku päätti veloittaa — se on muuntosuhde. Yksi sekunti assistant-audiota on kaksikymmentä tokens. Sama sekunti kantaa ilmoitetulla nopeudella 2,5 sanaa, ja mitattu transkripti kulkee 1,26 tokens per sana, joten tekstinä se on 3,15 tokens. Ääni on 6,3 kertaa kömpelömpi paketti samalle merkitykselle, ja jokaista sen tokenia laskutetaan 5,3 kertaa text output -hintaa ja 16 kertaa text input -hintaa enemmän. Kerro bulk-suhde hintasuhteella, ja kertaluokka on jo olemassa ennen kuin kirjanpito alkaa.

Kaksi operatiivista seurausta putoaa suoraan taulukosta.

Audio caching ei ole optimointi, se on liiketoimintamalli. Cached audio input on $0.40 per miljoona verrattuna $32.00 freshiin — 98,75 % alennus, joka puolittaa puhelun. Sääntö on luvun 16 sääntö, muuttumattomana: cache täsmää prefixiin, joten mikä tahansa keskustelun alkuun kesken puhelun lisätty asia tuhoaa sen, ja luonnollinen paikka lauseelle ”soittaja on nyt varmennettu” on juuri siellä.

Eikä mikään clientissä tekemäsi peruuta äänen laskutusta. User puhuu assistantin päälle, koodisi pysäyttää toiston, kaiutin hiljenee. Kaikki, mikä oli jo generoitu, oli jo veloitettu, koska laskutus kertyy, kun response luodaan; ja luvun 16 säännön mukaan kaikki mikä jää keskusteluun lähetetään uudelleen input audiona jokaisella seuraavalla vuorolla. Luku 14 teki tämän huomion tekstistriimin keskeyttämisestä. Äänessä se maksaa kolmekymmentä kertaa enemmän.

Jotkut toimittajat myyvät videota per sekunti ja toiset per klippi, resolution-tasoilla ja joskus kestotasoilla. Nämä kaksi muotoa eivät vain eroa käytännöllisyydeltään; ne risteävät.

Klippikohtainen toimittaja on kalliimpi kuin sekuntikohtainen alle 1,2 sekunnissa ja 16,7 kertaa halvempi kahdessakymmenessä. Näiden kahden modelin järjestys ei selviä klipin pituuden muutoksesta, joten ”mikä video model on halvin” ei ole kysymys malleista.

Viimeinen rivi on pahempi, ja se on luvun rehellinen ydin. mochi laskutetaan todellisia GPU-sekunteja vasten — työn mitattua prediction-aikaa — hintaan $0.001400 sekunnilta A100:lla ja $0.001525 H100:lla, jotka ovat vuokratun koneen hinnat eikä mitään muuta.¹⁵ Se on täysin täsmällinen tariffi eikä se ole hinta, koska määrä jota se kertoo on tuntematon, kunnes olet jo sitoutunut maksamaan sen. Yllä oleva rivi olettaa kaksitoista GPU-sekuntia per output-sekunti; nelinkertaista oletus, ja se poistuu halvimmasta kaistasta, ja vasta kuusinkertaisena se päätyy taulukon keskelle. Se on tämän sivun ainoa tariffi, jota et voi laittaa tarjoukseen.

Siis: tokens, image tokens, merkit, minuutit, videosekunnit, kokonaiset klipit, GPU-sekunnit, kiinteät yksiköt. Kahdeksan määrää, ja ainoa tapa laittaa ne samalle akselille on julistaa workload ja hinnoitella se.

Se on laajennus luvun 16 funktioon computeCost — sama tier-koneisto, nyt kriteereillä jotka eivät ole promptin pituutta:

export interface MediaCriteria {
  resolution?: string[]; quality?: string[];
  hasAudio?: boolean; maxDurationSeconds?: number;
}
export interface MediaTier { when?: MediaCriteria; price: number }
export type MediaRate = number | MediaTier[];

const matches = (when: MediaCriteria, u: Usage) => {
  const inList = (l?: string[], v?: string) => !l || (v !== undefined && l.includes(v));
  if (!inList(when.resolution, u.resolution)) return false;
  if (!inList(when.quality, u.quality)) return false;
  if (when.hasAudio !== undefined && when.hasAudio !== (u.hasAudio ?? false)) return false;
  if (when.maxDurationSeconds !== undefined
      && (u.videoSeconds ?? 0) > when.maxDurationSeconds) return false;   
  return true;
};

const mediaPrice = (rate: MediaRate | undefined, u: Usage): number => {
  if (rate === undefined) return 0;
  if (typeof rate === "number") return rate;
  for (const t of rate.filter((t) => t.when)) if (matches(t.when!, u)) return t.price;
  return rate.find((t) => !t.when)?.price ?? 0;      // the tier with no criteria is the default
};

export function computeCost(p: Pricing, u: Usage): number {
  let c = textCost(p, u);                             // Chapter 16, unchanged
  if (p.imageInputToken || p.imageOutputToken) {
    c += (u.imageInputTokens ?? 0) * (p.imageInputToken ?? 0)
       + (u.imageOutputTokens ?? 0) * (p.imageOutputToken ?? 0);
  } else if (p.imageUnit !== undefined) c += (u.images ?? 1) * mediaPrice(p.imageUnit, u);  
  if (p.videoSecond !== undefined) c += (u.videoSeconds ?? 0) * mediaPrice(p.videoSecond, u);
  if (p.videoUnit   !== undefined) c += (u.videoCount ?? 1)   * mediaPrice(p.videoUnit, u);
  c += (u.audioInputTokens ?? 0)       * (p.audioInputToken ?? 0)
     + (u.cachedAudioInputTokens ?? 0) * (p.cachedAudioInputToken ?? p.audioInputToken ?? 0)
     + (u.audioOutputTokens ?? 0)      * (p.audioOutputToken ?? 0)
     + (u.computeSeconds ?? 0)         * (p.computeSecond ?? 0)
     + (u.chars ?? 0)                  * (p.perChar ?? 0)
     + (u.minutes ?? 0)                * (p.perMinute ?? 0);
  return c;
}

Kaksi merkittyä riviä ovat kohta, jossa se rikkoutuu. Per yksikkö noteerattu tariffi kertoo u.images ?? 1; per token noteerattu tariffi kertoo jotakin, jonka oletus on nolla. Syötä molemmille tyhjä usage — muoto, jonka saat kun mittaus epäonnistui — ja katso:

per image (nano-banana-pro)     empty usage => $0.1500
per clip  (hailuo-02)           empty usage => $0.1500
per unit  (a cloned voice)      empty usage => $3.0000
per token (gpt-image-2)         empty usage => $0.0000
per second (veo-3.1)            empty usage => $0.0000
per GPU-second (mochi)          empty usage => $0.0000

Mitään ei tapahtunut kuusi kertaa, ja se maksoi kerran kolme dollaria ja viidesti ei mitään. Se ei ole pyöristysero; se on päätös siitä, mitä puuttuva numero tarkoittaa, erikseen jokaiselle yksikölle tehtynä eikä koskaan ylös kirjoitettuna. Järkevä sääntö on, että kenttä, jota kukaan ei mitannut, pysyy poissa, koska ”ei mitattu” ja ”mitattu ja tulokseksi tuli nolla” ovat eri asioita. Tämä funktio on hiljaa eri mieltä.

Toinen epäonnistuminen on kesto. Klippihinnoiteltu tariffi valitsee tierinsä vertailulla maxDurationSeconds vastaan u.videoSeconds ?? 0, joten usage, joka ei koskaan kirjannut kestoa, täsmää lyhimpään tieriin:

duration recorded    ->  $0.45
duration missing     ->  $0.27

Neljäkymmentä prosenttia alennusta siitä, ettei tiedä kuinka pitkä video oli. Molemmilla bugeilla on sama juuri: mukavuuden vuoksi valittu oletus funktion sisällä, jonka koko tehtävä on olla täsmällinen.

Kun kustannukset ovat laskettavissa, vertailu tarvitsee toisen puolikkaan — julistetun edustavan workloadin, yhden per engine, julkisesti sanottuna, jotta lukija voi olla siitä eri mieltä:

export const representative = {
  text:   { blend: [[{ promptTokens: 1e6 }, 0.25], [{ completionTokens: 1e6 }, 0.75]] },
  image:  { images: 1, imageInputTokens: 50, imageOutputTokens: 1500 },
  video:  { videoSeconds: 5, videoCount: 1, resolution: "1080p", hasAudio: true, computeSeconds: 60 },
  voice:  { chars: 1000, computeSeconds: 10 },
  stt:    { minutes: 1 },
};

Jokainen noista riveistä on argumentti. Teksti sekoittaa neljänneksen inputia ja kolme neljännestä outputia, koska todellinen käyttö painottuu outputiin; fifty-fifty-sekoitus järjestää mallit toisin. Kuvaworkload olettaa 1 500 output tokens, OpenAI:n medium-neliön 1 056:n ja medium-pystyn 1 584:n väliin. Video olettaa viisi sekuntia 1080p:tä, ja olemme juuri nähneet kahden toimittajan vaihtavan paikkaa 1,2 sekunnissa. Compute-merkintä olettaa kuusikymmentä GPU-sekuntia, koska muuta oletettavaa ei ole.

Tämä on menetelmä, ja se on ainoa rehellinen saatavilla oleva: et voi verrata hintoja eri yksiköissä; voit verrata vain ylös kirjoittamasi workloadin kustannusta. Jokainen taulukko, joka rankkaa multimodaalisia malleja tulostamatta workloadiaan, rankkaa omia oletuksiaan.

Nyt voit hinnoitella kaiken, mitä model voi tuottaa, missä tahansa yksikössä sitä myydään, ja sanoa ääneen minkä workloadin vertailusi oletti. Se sulkee laskun, jonka luku 16 avasi, ja se sulkee osan III: kaikki luvusta 14 tähän asti on koskenut yhtä kutsua — miten se tehdään, mitä siihen laitetaan, miten sitä samplataan, mitä se palauttaa, mitä se maksaa.

Luku 22 vaihtaa analyysin yksikön, ja muutos on kallis. Agent ei ole yksi kutsu; se on silmukka, joka päättää itse montako kutsua tehdä, ja kahden viime luvun aritmetiikka muuttaa sen arkkitehtuurikaaviosta budjetiksi. Se alkaa kysymällä samalta modelilta saman kysymyksen kahdesti, lisäämällä toisella kerralla yhden toolin katalogiin ja mittaamalla mitä tuo yksi tool teki: yhdestä kutsusta tuli kaksi, kolmestakymmenestäyhdeksästä input tokenista tuli 420.

Riippuu siitä, kumman kahdesta julkaistusta määritelmästä avaat, tekeekö se siitä agentin, eivätkä ne ole samaa mieltä. Toinen niistä ei ole samaa mieltä itsensä kanssa.

Jokainen tämän luvun hinta, kaava ja muuntosuhde luettiin providerin omalta sivulta 7. syyskuuta 2026 ja siteerataan sillä päivämäärällä, koska ne kaikki liikkuvat. Token-määrät, kustannukset ja vertailut laskettiin tuosta datasta yllä tulostetulla koodilla yhdellä koneella ilman yhtäkään maksullista API-kutsua — mikä on myös rehellinen syy siihen, ettei tässä luvussa ole yhtäkään latency-väitettä.

Image-token-funktiot, kustannustaulukot, voice-call-erittely ja empty-usage-tulokset tuotettiin tässä luvussa tulostetulla TypeScriptillä, ajettuna Node 22:lla. Voice-vertailussa käytetty dialogi on 149 sanaa ja se tokenisoitiin mallilla tiktoken encodingilla o200k_base 188 tokeniksi; sen kesto seuraa julistetusta 150 sanan minuuttinopeudesta, joka on vertailun parametri eikä mittaus. Jokaisella provider-luvulla on alaviite, joka nimeää sivun jolta se tuli.