Research › Flagship Study
Artul.ai Research LibraryStudy No. 90Flagship StudyUpdated 2026-09-17

Thinking Is Expensive, Deciding Is Not: 500 Questions per Earnings Call in One Second

By Artul.ai Research Group · n = 174,989 earnings calls · First published 2026-09-17
The study in 30 seconds: the stopwatch race, the bill, the calibration curve. Square MP4 or the 16:9 version.
Abstract

Every earnings call on this site is scored by the same yes/no questions; the scorer was a reasoning LLM at about four minutes per 250 questions. We replaced it with a decision-only model (TypeSafe Jev 1.13) that returns a probability per question and no text: 500 questions in one call in 0.4–1.7 s, calibrated against the stored answers, about $0.001 per transcript, which let us build a 2,600-question battery in a day. Nothing here shows the questions predict returns: the strict out-of-sample test is at chance.

Key findings (all measured in-house, September 2026)
  • 150–500× per call vs the run-log GLM figure (238 s) and union-alpha (217–320 s); 60–250× vs a fresh GLM call at low reasoning effort (89–108 s). Jev: 0.4–1.7 s for all 500 questions in one call.
  • 7× more questions per call: ~1,750 with a 120k-character transcript, 2,800 with none, against 250.
  • 1,579 calls/min in bursts (32 simultaneous in 1.2 s, ~0.8M questions/min) vs 4/min for the free model. Sustained: ~175 calls/min per key, an account limiter.
  • 87.0% agreement with the stored GLM answers (108 transcripts × 500 questions, p ≥ 0.5); 94.1% when confident (67% of answers); 98.0% where GLM's own retest stability is ≥ 0.99.
  • Calibrated: p < 0.2 → GLM said yes 5.3%; 0.2–0.4 → 27.8%; 0.4–0.6 → 54.7%; 0.6–0.8 → 76.3%; p ≥ 0.8 → 93.3%.
  • $620 vs $8,700 (GLM, list price) for 2,600 questions × 175,000 transcripts; GPT-5 mini $45,000, Claude Haiku 4.5 $127,000, GPT-5 $228,000, Claude Sonnet 5 $254,000.
  • 2,600 questions in one day: 3,431 → 2,692 (wording dedupe) → 2,341 (validated on 300 transcripts, 900 calls, 259 s) → 2,600 (fill round).
  • Benchmark, 3 transcripts: Claude Fable 5.1, Sonnet 5, Haiku 4.5, GPT-5, GPT-5 mini, GLM-5.3-Flash, same 250 questions. Jev fastest and cheapest by two to three orders of magnitude; agreement with each 76–85%, while they agree 84–92% with each other (Table 1, Figures 8–11). Spend $7.14.
  • Not proven to predict returns. On 5,820 labelled calls, 447 of 2,600 questions beat the shuffled-label null maximum in-sample; out of sample (top 30 chosen on 2017–2020, tested 2021–2025) the composite spreads −4.5% vs −5.6% for 30 random questions.

1Speed

Method. Jev timed at 100/250/500 questions, across 40 transcripts, and in bursts of 8/16/32 calls; the per-call ceiling is where the API returns 400 max_tokens_exceeded. union-alpha timed at concurrency 4–32. The GLM 238 s is active calls ÷ completions per second from the original run's log (667 steady-state minutes, IQR 226–254 s), not a stopwatch.

2026-09-17T19:56:58.224755 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ 1 10 100 1k 10k 100k 1M Seconds per call Seconds per transcript (same 500 questions) Questions per call Calls per minute (measured burst) Questions per minute 238 s GLM-5.3-Flash 217 s union-alpha 1.0 s Jev 1.13 150–500× per call GLM 238 s (implied, IQR 226–254); union-alpha 217–320 s; Jev 0.4–1.7 s 476 s GLM-5.3-Flash 434 s union-alpha 1.0 s Jev 1.13 260–1,190× per transcript GLM/union: 2 calls of 250; Jev: one call of 500 250 GLM-5.3-Flash 250 union-alpha 1,750 Jev 1.13 7× more per call Jev limit with a 120k-char transcript; 2,800 with none not measured (rate-limited run) 4.0 /min union-alpha 1,579 /min Jev 1.13 395× union-alpha: 16 concurrent max; Jev: 32 simultaneous in 1.2 s not measured (rate-limited run) 1,000 /min union-alpha 789,500 /min Jev 1.13 790× calls per minute × questions per call (250 / 500) The speedup, measured five ways (log scale) Same 500-question battery on one transcript. A Jev call is 150–500× shorter than a GLM or union-alpha call, it accepts 7× as many questions per call, and in bursts it completed 1,579 calls a minute against 4 for the free model. typesafe_test.py (Jev: 100/250/500 questions, bursts of 8/16/32), union_parallel.py (concurrency 4–32), corpus500.log (GLM, implied). Sept 2026.
Figure 1. Five measured speed axes, log scale: per call, per transcript, questions per call, calls per minute in bursts, questions per minute. The GLM run had no burst test; its throughput came from ~1,200 concurrent calls.
2026-09-17T19:53:23.888030 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ 1 s 10 s 100 s 1,000 s GLM-5.3-Flash 250 questions per call stealth/union-alpha (free) 250 questions per call Jev 1.13 500 questions in one call 238 s 217 s 1.0 s provider timeout 317 s Seconds per scoring call, one earnings-call transcript Log scale. Bars are the typical call; whiskers the measured range. GLM range is the interquartile range implied by the corpus run log (active calls ÷ completions per second). Measured in-house, Sept 2026. GLM: corpus500.log, 667 steady-state minutes. union-alpha: 20–250 questions, first token after ~213 s. Jev: 500 questions, 40 transcripts.
Figure 2. Seconds per scoring call, log scale; whiskers are the measured range. The free model's provider cuts every call at 317 s.
2026-09-17T19:53:24.234951 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ 0 30k 60k 90k 120k chars Transcript length passed as state 0 1,000 2,000 3,000 Questions accepted in one call HTTP 400 max_tokens_exceeded 2,800 2,640 1,750 corpus run: 1,300 per call, two calls old battery: 500 How many questions fit in one Jev call The limit is a ~65k input-token budget shared by the transcript and the questions; the line joins the three measured points. typesafe_test.py, Sept 2026. Transcripts are truncated to 120,000 characters in production.
Figure 3. Questions accepted per Jev call against transcript length: a ~65k input-token budget shared by transcript and questions. The corpus run sends two calls of 1,300.
2026-09-17T19:56:58.335859 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ 0.0 0.5 1.0 1.5 2.0 2.5 3.0 hours of logged running time, 17 Sept 2026 (one log line per minute) 0 50 100 150 200 calls completed per minute restart median 176 calls/min (5280 transcripts/h, 2 calls each) 6,698 of 317,997 calls done at the last log line (2.1%) · eta 29 h The live 2,600-question corpus run, minute by minute Two calls of 1,300 questions per transcript; the runner holds 4 concurrent calls per key under the account limiter. Read from the run log; the run itself is untouched. corpus2600.log, parsed read-only at build time. 174,614 transcripts × 2 calls = 349,228 calls; 31,231 done before this restart.
Figure 4. The live 2,600-question corpus run, calls per minute from its own log. This is the account limiter, not the model: bursts of 32 finish in 1.2 s.

2Cost

Method. Jev: measured input tokens × $0.042 per million, output free. Others: the measured GLM token profile (~15–18k in, ~9.5k out per 250-question call, ~8,000 of it hidden reasoning) scaled to 2,600 questions (11 calls) at each model's OpenRouter list price. Section 4 replaces these with billed usage.

2026-09-17T19:53:23.995350 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ $1k $10k $100k $1M Jev 1.13 (TypeSafe) GLM-5.3-Flash GPT-5 mini Claude Haiku 4.5 GPT-5 Claude Sonnet 5 $620 $8,700 $45,000 $127,000 $228,000 $254,000 Cost to ask 2,600 questions of every transcript in the corpus (175,000 calls) Log scale. LLM rows: 250 questions per call, 11 calls per transcript, ~200k input + ~105k output tokens per transcript including reasoning, at OpenRouter list prices. Jev: two calls of 1,300, $0.042 per million input tokens, output free. Estimates from measured token counts, Sept 2026 prices. The original 500-question GLM run cost on the order of $1,600.
Figure 5. Cost of asking 2,600 questions of every transcript in the corpus, log scale. The original 500-question GLM run cost on the order of $1,600; the same 500 on Jev cost about $170.

3Does it agree with the old scorer?

Method. Jev vs the stored GLM answers on the same transcripts and questions: 40 × 250 (85.8%) and 108 × 500 (87.0%), p ≥ 0.5; yes-rates 49.5% vs 49.8%. Calibration is the GLM yes-rate inside each Jev bucket. GLM's own retest agreement (91% at 250 per call) is the noise floor.

2026-09-17T19:53:24.087720 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ p < 0.2 0.2–0.4 0.4–0.6 0.6–0.8 p ≥ 0.8 Jev probability of yes (bucket) 0% 25% 50% 75% 100% Share the old GLM scorer answered yes perfect calibration 5.3% 27.8% 54.7% 76.3% 93.3% Jev's probabilities against the stored yes/no answers 108 transcripts × 500 questions. 67% of answers fall in the two outer buckets, where agreement is 94.1%. ts_stab.py, Sept 2026. The old scorer is GLM-5.3-Flash, 250 questions per call.
Figure 6. Jev probability bucket against the share of stored GLM yeses. Two-thirds of answers sit in the outer buckets, where agreement is 94.1%.
2026-09-17T19:53:24.158663 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ ≥ 0.99 0.97–0.99 0.95–0.97 0.90–0.95 < 0.90 The old scorer's agreement with itself on the same question (retest stability) 60% 70% 80% 90% 100% all answers 87.0% 98.0% 93.8% 91.9% 87.4% 79.3% Jev agrees with the old scorer wherever the old scorer agrees with itself Agreement at p ≥ 0.5, grouped by the question's own retest stability under GLM. Disagreement concentrates where the old answers were noise. 108 transcripts × 500 questions (ts_stab.py). Stability: share of identical answers when GLM scored the same transcript twice.
Figure 7. Agreement with GLM grouped by GLM's own retest stability. Disagreement lives where the old answers were noise. 13 of 500 questions disagree by interpretation, e.g. "Does any analyst identify themselves with a two-part introduction (name and firm)?": Jev yes 94%, GLM 23%.

4Benchmark against frontier models

Method. Three real transcripts of ~60k characters (ZPTA (2024-05-15, 58,690 chars), HLLY (2024-05-12, 60,222 chars), MLYS (2024-05-11, 58,535 chars)) with stored GLM answers. Each model got the exact 250-question prompt of our earlier free-model test, temperature 0.3, max_tokens 16,000, one call per (model, transcript), via OpenRouter on 2026-09-17 (anthropic/claude-fable-5.1 is listed there and was used directly); Jev got the same 250 questions via TypeSafe. Cost is billed usage; agreement is identical yes/no answers, Jev at p ≥ 0.5. Calls that spent the cap on hidden reasoning and returned nothing were rerun once at 32,000; GLM was also rerun at reasoning effort: low, the corpus run's setting, which reproduces its ~8,000-token reasoning profile. n = 3 transcripts; agreement between models is not ground truth.

Table 1. Benchmark on 3 transcripts × 250 questions, max_tokens 16,000. Latency is mean (min–max) of the three calls; tokens are mean prompt / completion / reasoning per call; cost is mean billed cost per 250-question call. Agreement uses the 32k rerun where the 16k call returned no answers.
ModelLatency per callTokens in / out / reasoningCost per callAnswers parsed (of 250)Agrees with JevAgrees with stored GLM
Jev 1.130.9 s (0.7–1.2)19,030 / 4,960 / 0$0.0008250/250/250—83.9%
GLM-5.3-Flash (reasoning: low)98.6 s (88.5–107.9)17,134 / 9,269 / 8,242$0.0068250/250/25083.9%91.5%
GLM-5.3-Flash (default reasoning)183.9 s (167.4–206.6)17,134 / 16,000 / 14,934$0.00630/0/0 (32k: 0/0/0, 415 s)n/an/a
GPT-5 mini175.7 s (153.2–194.4)17,016 / 15,425 / 14,506$0.0351250/166/239 (32k: 250, 186 s)78.2%80.2%
Claude Haiku 4.55.5 s (5.3–5.6)18,548 / 1,003 / 0$0.0236250/250/25076.1%71.2%
GPT-5186.0 s (165.9–215.9)17,016 / 15,732 / 15,061$0.1786232/0/250 (32k: 250/250, 197 s)83.5%86.3%
Claude Sonnet 5151.5 s (148.8–153.7)25,512 / 16,000 / 15,999$0.21100/0/0 (32k: 250/0/250, 278 s)80.4%88.8%
Claude Fable 5.1172.0 s (160.2–180.2)25,514 / 15,323 / 14,489$1.0213250/0/250 (32k: 250, 212 s)85.2%91.5%
2026-09-17T20:17:39.487769 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ 1 s 10 s 100 s 1,000 s 10,000 s Jev 1.13 GLM-5.3-Flash (reasoning: low) GLM-5.3-Flash (default reasoning) GPT-5 mini Claude Haiku 4.5 GPT-5 Claude Sonnet 5 Claude Fable 5.1 0.9 s 99 s 184 s 16k cap: 0/0/0 parsed; 32k: 415 s 176 s 16k cap: 250/166/239 parsed; 32k: 186 s 5.5 s 186 s 16k cap: 232/0/250 parsed; 32k: 197 s 151 s 16k cap: 0/0/0 parsed; 32k: 278 s 172 s 16k cap: 250/0/250 parsed; 32k: 212 s Benchmark: seconds per call, the same 250 questions on the same 3 transcripts Bars: mean of 3 calls at max_tokens 16,000, whiskers the range. Where a model spent the cap on hidden reasoning and returned no answers, the red diamond is the mean of a rerun at 32,000. n = 3 transcripts of ~60k characters. bench.py, 2026-09-17. Wall-clock from request to full response, single call, no streaming.
Figure 8. Seconds per call for the same 250 questions on the same 3 transcripts, log scale; whiskers are the range across transcripts.
2026-09-17T20:16:20.074500 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ 1 s 10 s 100 s 1,000 s 10,000 s Jev 1.13 GLM-5.3-Flash (reasoning: low) GLM-5.3-Flash (default reasoning) GPT-5 mini Claude Haiku 4.5 GPT-5 Claude Sonnet 5 Claude Fable 5.1 3.6 s 394 s 735 s 16k cap hit on some calls 703 s 16k cap hit on some calls 22 s 744 s 16k cap hit on some calls 606 s 16k cap hit on some calls 688 s 16k cap hit on some calls Benchmark: seconds per 1,000 questions, single call, one transcript Mean call latency ÷ 250 questions × 1,000. Sequential time for one transcript; parallelism is a separate axis (Figure 8). n = 3 transcripts. bench.py, 2026-09-17.
Figure 9. Seconds per 1,000 questions from a single call, i.e. sequential time per transcript.
2026-09-17T20:14:36.133756 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ $0.001 $0.10 $10 $1k $100k $10M Jev 1.13 GLM-5.3-Flash (reasoning: low) GLM-5.3-Flash (default reasoning) GPT-5 mini Claude Haiku 4.5 GPT-5 Claude Sonnet 5 Claude Fable 5.1 $0.0016 $610 $0.014 $12,300 $0.013 $11,500 $0.070 $63,900 $0.047 $42,900 $0.357 $325,000 $0.422 $384,100 $2.043 $1,858,800 per transcript, 500 questions (measured) projected: 175,000 transcripts × 2,600 questions Benchmark: what the same questions cost, measured per call and projected to the corpus Measured cost is OpenRouter's billed usage for the 250-question call, doubled for 500. Projection multiplies the measured 250-question call by 2,600/250 and 175,000 transcripts; Jev's projection is the measured corpus-run rate. bench.py, 2026-09-17. Prices are the providers' list prices on that day. n = 3 transcripts.
Figure 10. Measured cost per transcript at 500 questions, and the projection to 175,000 transcripts × 2,600 questions at the same per-call cost.
2026-09-17T20:14:15.018297 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ Jev 1.13 GLM-5.3-Flash (reasoning: low) GPT-5 mini Claude Haiku 4.5 GPT-5 Claude Sonnet 5 Claude Fable 5.1 stored GLM (corpus run) Jev 1.13 GLM-5.3-Flash (reasoning: low) GPT-5 mini Claude Haiku 4.5 GPT-5 Claude Sonnet 5 Claude Fable 5.1 stored GLM (corpus run) — 83.9 78.2 76.1 83.5 80.4 85.2 83.9 83.9 — 83.1 70.1 90.3 89.8 90.4 91.5 78.2 83.1 — 65.1 84.2 84.3 81.1 80.2 76.1 70.1 65.1 — 67.1 65.6 72.8 71.2 83.5 90.3 84.2 67.1 — 88.6 88.9 86.3 80.4 89.8 84.3 65.6 88.6 — 88.8 88.8 85.2 90.4 81.1 72.8 88.9 88.8 — 91.5 83.9 91.5 80.2 71.2 86.3 88.8 91.5 — Benchmark: agreement between scorers, % of identical yes/no answers Up to 750 answers per pair (3 transcripts × 250 questions); calls that hit the 16k cap use their 32k rerun. GLM at default reasoning returned no answers at either cap and is omitted. Jev at p ≥ 0.5. Agreement between two models is not ground truth: neither may be right. bench.py, 2026-09-17. 'stored GLM' is the answer written during the original corpus run; 'GLM-5.3-Flash' is a fresh call today.
Figure 11. Pairwise agreement on the 750 answers. The stored GLM row is the answer written during the original corpus run; the GLM-5.3-Flash row is a fresh call. Neither is ground truth.

52,600 questions in a day

Method. 90 personas (forensic linguist, bankruptcy trustee, air-traffic controller, jazz musician, beekeeper…) × 40 LLM-written questions, minus ~1,200 ever tried: 3,431. Wording dedupe (TF-IDF word + character n-grams, cosine ≥ 0.62): −739. The 2,692 plus the old 500 scored on 300 random transcripts with Jev (900 calls, 259 s): −372 outside 3–97% prevalence, −479 behavioural twins (|corr| ≥ 0.92, e.g. "Does the CEO answer the majority of analyst questions personally?" vs "…more questions than any other executive?", 0.94) → 2,341 (420 old + 1,921 new). Fill round, 40 fresh lenses: +259.

2026-09-17T19:53:24.445765 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ Generated 90 lenses × 40 questions, minus 1,200 ever tried After wording dedupe TF-IDF word + char n-grams, cosine ≥ 0.62 removed (+ the old 500 join validation) After validation on 300 transcripts (900 calls, 259 s): prevalence 3–97%, |corr| < 0.92 (420 old + 1,921 new) Fill round 40 fresh lenses, same filters 0 1,000 2,000 3,000 old 500 420 kept from the old 500 3,431 2,692 new 2,341 2,600 −739 near-duplicates 3,192 validated: −372 prevalence −479 behavioural twins +259 fill Building the 2,600-question battery in one day Final set: 154 lenses, zero duplicate texts. Prevalence: 409 questions under 10%, 894 at 10–30%, 887 at 30–70%, 410 above 70%. gen2600.py, validate2600.py, reselect2600.py, gen_fill.py. Validation used Jev on 300 random transcripts.
Figure 12. The build. Prevalence of the final set: 409 questions under 10%, 894 at 10–30%, 887 at 30–70%, 410 above 70%. Rare questions survive because a probability of 0.08 is still information.

6Early signal, and the test that failed

Method. First 5,820 labelled transcripts (12-month excess return over real SPY; cap ≥ $1B, ADV ≥ $3M; 41 months): per-question within-month Spearman IC vs the same with labels shuffled; era splits; partial IC after 14 price factors; strict test: top 30 by IC on 2017–2020, spread on 2021–2025.

2026-09-17T19:53:24.345775 image/svg+xml Matplotlib v3.10.9, https://matplotlib.org/ 0.00 0.02 0.04 0.06 0.08 0.10 0.12 0.14 |within-month rank IC| of the question's probability against 12-month excess return 0 100 200 300 400 questions null maximum 0.048 447 of 2,600 questions beyond it “strong” modifies a metric ≥ 3 times: 0.136 shuffled labels (null) real 12-month excess return Early look: 2,600 questions against returns on the first 5,820 labelled calls Real 95th/99th percentile 0.075 / 0.110 versus 0.028 / 0.037 for shuffled labels. Not a forecast: the strict out-of- sample test is at chance (see Limitations). early2600.py: within-month Spearman IC, 41 months, market cap at least $1B and ADV at least $3M, real SPY benchmark.
Figure 13. |IC| across the 2,600 questions, real labels against shuffled. Real 95th/99th/max 0.075/0.110/0.136; null 0.028/0.037/0.048; 447 questions beyond the null maximum; 147 keep their sign in all three eras. In-sample.
Table 3. Strongest questions by |IC| on 5,820 labelled calls. Descriptive and in-sample; not a recommendation.
QuestionICDetail
Does the word "strong" modify a financial metric at least three times?+0.1362017–20 +0.124 · 2021–22 +0.164 · 2023–25 +0.130
Is a buyback or dividend amount cited?+0.133—
Did a metric reach a record or all-time high?+0.132partial IC after 14 price factors +0.100
Is a "pivotal trial" mentioned?−0.119—
Is a trial described as "on track"?−0.116—

Out of sample, the top-30 composite spread was −4.5%. Thirty random questions gave −5.6%. At this sample size the selected questions are indistinguishable from chance.

7Limitations

Scripts, for the record: typesafe_test.py, ts_stab.py, union_parallel.py, union_compact.py, gen2600.py, validate2600.py, reselect2600.py, gen_fill.py, corpus2600.py, early2600.py, early2600b.py, bench.py. Every figure above is also available as PNG in light and dark variants under /research-media/deciding-is-not/. Prices are TypeSafe and OpenRouter list prices on 2026-09-17 and will change.
Cite this study Artul.ai Research Group (2026). “Thinking Is Expensive, Deciding Is Not: 500 Questions per Earnings Call in One Second.” Artul.ai Earnings-Call Research Library, Study No. 90. https://artul.ai/research/thinking-is-expensive-deciding-is-not
Related studies