How to Cut Your LLM Costs by 70% Without Losing Quality

type ModelTier = "fast" | "standard" | "premium";
 
function selectModel(request: AIRequest): ModelTier {
  // Simple classification, FAQ, routing → fast model
  if (request.complexity === "low" || request.type === "classification") {
    return "fast"; // GPT-4o-mini, Claude Haiku, Gemini Flash
  }
 
  // Standard generation, summarization → mid-tier
  if (request.complexity === "medium") {
    return "standard"; // GPT-4o, Claude Sonnet
  }
 
  // Complex reasoning, code generation, analysis → premium
  return "premium"; // GPT-4.5, Claude Opus, o3
}
 
const MODEL_MAP = {
  fast: { model: "gpt-4o-mini", costPer1kTokens: 0.00015 },
  standard: { model: "gpt-4o", costPer1kTokens: 0.0025 },
  premium: { model: "gpt-4.5-preview", costPer1kTokens: 0.075 },
};

async function cachedInference(prompt: string): Promise<string> {
  // Check semantic cache (not just exact match)
  const embedding = await embed(prompt);
  const cached = await cache.findSimilar(embedding, {
    threshold: 0.95,
    maxAge: "24h",
  });
 
  if (cached) {
    metrics.increment("cache_hit");
    return cached.response;
  }
 
  // Cache miss — call the model
  const response = await llm.generate(prompt);
  await cache.store(embedding, response, { ttl: "24h" });
  metrics.increment("cache_miss");
 
  return response;
}

❌ BEFORE (847 tokens):
"You are a helpful customer service assistant for Acme Corp.
Acme Corp was founded in 2019 and sells premium kitchen appliances.
Our values are quality, innovation, and customer satisfaction.
When responding to customers, always be polite, professional, and helpful.
If you don't know the answer, say so honestly.
Always try to resolve the issue in one interaction.
Here is the customer's message: {message}
Please provide a helpful response."
 
✅ AFTER (156 tokens):
"Acme Corp support agent. Kitchen appliances.
Rules: Be concise. Resolve in one reply. Say 'I don't know' when unsure.
Customer: {message}"

const TOKEN_BUDGETS = {
  chat_response: { maxInput: 2000, maxOutput: 500 },
  email_draft: { maxInput: 3000, maxOutput: 1000 },
  document_summary: { maxInput: 8000, maxOutput: 500 },
  code_review: { maxInput: 4000, maxOutput: 2000 },
};
 
async function enforceTokenBudget(
  feature: string,
  input: string
): Promise<string> {
  const budget = TOKEN_BUDGETS[feature];
  const inputTokens = countTokens(input);
 
  if (inputTokens > budget.maxInput) {
    // Truncate intelligently, not just cut off
    input = await summarizeToFit(input, budget.maxInput);
  }
 
  return llm.generate(input, { maxTokens: budget.maxOutput });
}

// Instead of processing each email individually...
// Batch them and process together
 
async function batchClassify(emails: Email[]): Promise<Classification[]> {
  // Group into batches of 20
  const batches = chunk(emails, 20);
 
  return Promise.all(
    batches.map((batch) =>
      llm.generate({
        prompt: `Classify these ${batch.length} emails. Return JSON array.`,
        input: batch.map((e, i) => `[${i}] ${e.subject}: ${e.body}`).join("\n"),
      })
    )
  );
}
// 100 emails: 100 API calls → 5 API calls. Same results.