Useful Cheatsheets
Build / AI /

AI Model Selection

Select the optimal artificial intelligence model tier by evaluating latency, context size, reasoning capacity, and token costs.

TL;DR

  1. Evaluate required reasoning complexity against latency and token-budget constraints.
  2. Route high-volume classification tasks to fast-tier models like haiku or mini.
  3. Reserve frontier reasoning models like o3-mini for mathematical proof generation.
Jump to section

Model Tier Classification

    Frontier General Models

    Highest capability models for complex reasoning and software architecture.

    const FRONTIER = [
  'claude-3-5-sonnet-20241022',
  'gpt-4o',
];
// Best for coding, analysis, and planning
    Fast High-Volume Tier

    Ultra-low latency models priced for massive scale classification.

    const FAST_TIER = [
  'claude-3-5-haiku-20241022',
  'gpt-4o-mini',
  'gemini-1.5-flash',
];
// 10x cheaper, sub-second latency
    Deep Reasoning Tier

    Models that generate hidden chain-of-thought tokens before answering.

    const REASONING = ['o1', 'o3-mini', 'deepseek-r1'];
// Excels at competitive math and logic

Decision Matrix Parameters

    Cost Per Million Tokens

    Calculate expected blended token expenditure across model tiers.

    interface ModelCost {
  inputPerM: number;
  outputPerM: number;
}
const miniCost: ModelCost = {
  inputPerM: 0.15,
  outputPerM: 0.60,
};
    Latency Constraints

    Evaluate time-to-first-token requirements for interactive user interfaces.

    const isInteractive = targetTtftMs < 800;
const model = isInteractive
  ? 'gpt-4o-mini'
  : 'o3-mini';
    Context Window Capacity

    Select model based on input token volume requirements.

    const tokens = countTokens(documentText);
const model = tokens > 200000
  ? 'gemini-1.5-pro'
  : 'gpt-4o';

Cascading Routing Logic

    Task Difficulty Classifier

    Inspect query complexity before dispatching to target model tier.

    function routeTask(prompt: string): string {
  const complex = /refactor|proof|audit/i;
  return complex.test(prompt)
    ? 'gpt-4o'
    : 'gpt-4o-mini';
}
    Fallback On Failure

    Escalate to frontier model when lightweight model outputs fail schema.

    try {
  return await runFastModel(input);
} catch {
  return await runFrontierModel(input);
}
    Cost Budget Enforcer

    Switch to budget tier when monthly account token quotas are reached.

    const activeModel = monthlySpend > limit
  ? 'claude-3-5-haiku-20241022'
  : 'claude-3-5-sonnet-20241022';

Provider Feature Comparison

    Prompt Caching Support

    Providers supporting 90 percent discounts on reused prompt context.

    const cacheSupport = ['anthropic', 'openai'];
// Drastically cuts static prompt costs
    Native Tool Calling

    High reliability structured schema function calling support.

    const toolScores = {
  'claude-3-5-sonnet': 0.98,
  'gpt-4o': 0.97,
};
// Critical for autonomous agent loops
    Multimodal Modalities

    Compare supported sensory inputs across available provider models.

    const modalities = {
  'gpt-4o': ['text', 'vision', 'audio'],
  'claude-3-5-sonnet': ['text', 'vision'],
};

Tips

  1. Implement a tiered model cascade where lightweight haiku models attempt tasks first, escalating to frontier models only upon validation failure.
  2. Audit token pricing across providers to take advantage of dramatic price drops in modern multimodal flash models.

Warnings

  1. Avoid using expensive frontier models like gpt-4o for simple extraction tasks that lightweight models perform with identical accuracy.
  2. Do not assume high benchmark scores translate to low latency; reasoning models generate internal thought-tokens that increase time-to-first-token.

In Practice

FAQ