Triple-Stack LLM
Router

Three Tiers, One Router, ~95% Savings

Most AI cost waste comes from one mistake: sending everything to expensive models. This system classifies every call by complexity, dispatches it to the cheapest model that can handle it, and applies output discipline to compress what each tier sends and stores.

The Three Tiers

Each tier has a class, a model, token budgets, and a target distribution within a rolling 50-call quota window (±10% tolerance). Hard-floor purposes skip quota logic entirely — they always land on T3.

Purpose Buckets & Flags

The classifier checks purpose first, then flags, then prompt heuristics. Pass an explicit purpose for faster, more accurate routing. Hard-floor purposes (red pills below) route directly to T3 regardless of quota or cost pressure.

Calling the Router

Import once. Call ask() with a prompt and an optional purpose. The router classifies, checks quota, dispatches to the cheapest competent tier, logs the call to memory/tier-usage.jsonl, and returns a result object.

Three call patterns. Include purpose whenever you know it — routing is faster and more accurate than heuristic-only classification.

const { ask } = require('./lib/tiered-ask.cjs');

// ── SIMPLE CALL — router picks tier automatically
const r = await ask({ prompt: 'Summarize this paragraph: ...' });
console.log(r.text, r.tier, r.model);

// ── WITH PURPOSE — faster, more accurate routing
const r2 = await ask({
  purpose: 'summarize',
  prompt: 'Apollo program: 1961-1972, 12 men on moon.',
  system: 'Return 2 sentences max.'
});

// ── HARD-FLOOR — always hits T3 regardless of quota
const r3 = await ask({
  purpose: 'architectural_decision',
  prompt: 'Design a load-balancer for 10M RPS. List tradeoffs.'
});

// ── FORCE A TIER via flags
const r4 = await ask({ flags: ['cheap'], prompt: 'Extract fields from this JSON...' });

Return shape

CLI Commands

Check that all three tiers are reachable before your first real call.

node lib/tiered-ask.cjs ping
      

See tier distribution, average latency, fallback count, and per-model breakdown across the last N calls. Run this regularly to catch routing drift.

node scripts/tier-usage-report.cjs
node scripts/tier-usage-report.cjs 200  # last 200 calls

Five Phases to Production

Run the v2 setup prompt in Claude Code (or any agent with bash + file write). Takes ~5–10 minutes on broadband. The only manual step: paste your API keys when asked.

Copy this template. Fill in your API keys and set TIER1_MODEL to the model chosen in Phase A.

      OLLAMA_BASE_URL=http://localhost:11434
TIER1_MODEL=qwen3:32b
DEEPSEEK_API_KEY=sk-...
DEEPSEEK_BASE_URL=https://api.deepseek.com/v1
TIER2_MODEL=deepseek-v4-pro
TIER2_FALLBACK_MODEL=deepseek-v4-flash
ANTHROPIC_API_KEY=sk-ant-...
TIER3_MODEL=claude-opus-4-7
QUOTA_WINDOW_SIZE=50
QUOTA_TARGET_CHAT=0.30
QUOTA_TARGET_CHEAP=0.40
QUOTA_TARGET_PRECISION=0.30
QUOTA_TOLERANCE=0.10

Run all six checks. Each should produce the expected output shown in the comment.

# 1 — All tiers reachable
node lib/tiered-ask.cjs ping
# → { tier1: { ok: true }, tier2: { ok: true }, tier3: { ok: true } }

# 2 — T1 routing (short greeting → tier 1)
node -e "require('./lib/tiered-ask.cjs').ask({ prompt: 'hi' }).then(r => console.log(r.tier))"
# → 1

# 3 — T2 routing (known purpose → tier 2)
node -e "require('./lib/tiered-ask.cjs').ask({ purpose: 'summarize', prompt: 'Apollo 1961-1972.' }).then(r => console.log(r.tier))"
# → 2

# 4 — T3 routing (complex prompt → tier 3)
node -e "require('./lib/tiered-ask.cjs').ask({ prompt: 'Design load-balancer for 10M RPS.' }).then(r => console.log(r.tier))"
# → 3

# 5 — Hard floor (always tier 3, no demotion)
node -e "require('./lib/tiered-ask.cjs').ask({ purpose: 'identity_audit', prompt: 'who are you?' }).then(r => console.log(r.tier))"
# → 3

# 6 — Distribution report
node scripts/tier-usage-report.cjs

Rules That Don't Bend

Six invariants that override operational convenience. Violating any one breaks the system's trust guarantees or data integrity. No exception without explicit user confirmation and a logged rationale.

Five Laws of Output Discipline

Output is the most expensive surface — every emitted token is billed. These habits close the four leaks that burn ~30% of output tokens in unoptimized prompts: narrated reasoning, restated instructions, forward-carried context, and confirmatory tool calls.

Three Memory Tiers

Memory is leverage when curated, cost when hoarded. Each tier has a distinct lifespan, eviction policy, and promotion rule. The worst mistake: letting working-memory content graduate automatically and turning long-term memory into a junk drawer.

20 Laws in Five Clusters

The two invariants (quality floor, permanent memory) override all 20 laws. These clusters cover the laws that cause the most silent failures when violated. Each law is ≤15 words — scan before any session.

Strip Until It Breaks, Then Stop