LLMOps for Compound AI Systems — Observability & Cost

Why most GenAI pilots crumble after launch

Most GenAI pilots don't fail because the models are bad — they fail because the surrounding system wasn't built for production. In 2026 an "LLM call" is rarely a single model invocation. Real systems are compound: embedders, retrievers, vector stores, re-rankers, validators, tool calls, and multiple LLMs wired together. Without a focused LLMOps strategy, that complexity explodes into latency spikes, runaway token bills, and safety gaps once real traffic arrives.

This article outlines an actionable LLMOps playbook for compound AI systems that keeps them fast, safe, and affordable.

The five high-leverage controls every compound system needs

1) Model gateway (route, don’t brute-force)

Put a gateway between your application and providers. The gateway is the single control plane for routing, budgeting, caching, and basic guardrails. Route by task complexity and confidence — don’t throw a 13B model at every query.

Benefits:

• Big reductions in token spend by using the smallest model that meets quality constraints
• Provider failover and unified auth
• Centralized cost attribution and budget enforcement

Example routing heuristic:

• High-similarity factual queries -> 1.3B model on cheap instances
• Mid-tier synthesis -> 6–7B model
• Low-volume or high-stakes -> 13B+ frontier model with stricter eval gating

2) Pipeline-level traces (end-to-end visibility)

Instrument every stage as a span: embed, search, rerank, prompt build, LLM call, tool call. Correlate retriever hit rates, embedder latency, and token usage in one trace so you can find the slow or expensive stage instantly. Use OpenTelemetry-compatible spans and capture: model, prompt version, embedding version, token counts, retrieval scores, and cache hit/miss.

Why it matters: when cost or hallucination spikes, the root cause is usually a retrieval or chunking issue — not the final decoder.

3) Semantic caching (by meaning, not string)

Cache embeddings + responses keyed by semantic vector of the query (and tenant or privacy namespace where appropriate). That lets you short-circuit expensive LLM calls for paraphrases or repeated queries.

Key knobs:

• Similarity threshold (0.92–0.95 is a common sweet spot for FAQ/support)
• TTL based on data freshness
• Namespace by tenant for user-specific content

Typical gains: 15–60% reduction in API calls for repetitive workloads; latency drops from seconds to milliseconds on cache hits.

4) Eval gates (safety and quality checkpoints)

Run lightweight, automated checks before exposing outputs downstream: relevance, faithfulness to retrieved context, hallucination score, and safety filters. Use a small, cheap judge model or heuristic validators to accept/reject or escalate results.

Pattern: attempt cheap route -> validate output -> if validator fails, escalate to stronger model or human review.

5) Tiered scaling (scale the heavy parts independently)

Autoscale vector DBs, embedder workers, and large-model serving pools separately from front-door routers. Heavy tiers (vector search, GPU inference) should be monitored and scaled by the metrics they care about: query latency, queue depth, and token consumption, not CPU alone.

This avoids the common pattern where a few expensive escalations push the whole stack into failure.

Concrete engineering example: measurable wins

Last quarter I inherited a Q&A pipeline that spiked costs during business hours. We implemented three LLMOps controls:

• Model gateway that routes high-similarity queries to a 1.3B model served on cheaper instances, escalating to a 13B model only when relevance confidence < 0.7.
• Semantic cache at the retriever layer keyed by query embedding and tenant id.
• Single pipeline trace that tied retrieval quality to final answers.

Result: 38% reduction in token spend, 25% lower median latency, and a single trace that revealed a misconfigured retriever returning low-quality chunks.

A short code example: gateway + semantic cache + eval gate (Python/pseudocode)

# simplified pseudo-implementation
from embeddings import embed_text
from vector_store import qdrant_search, qdrant_upsert
from models import small_model, large_model, validator

SIMILARITY_THRESHOLD = 0.93
CACHE_TTL = 60 * 60 * 24  # 1 day

async def handle_request(tenant_id, user_query):
    q_emb = embed_text(user_query, model='embed-small')

    # semantic cache lookup
    hit = qdrant_search(collection=tenant_id, vector=q_emb, top_k=1)
    if hit and hit.score >= SIMILARITY_THRESHOLD:
        return hit.payload['response']  # cache hit

    # complexity classifier (cheap heuristic)
    if is_simple_lookup(user_query):
        response = await small_model.complete(user_query)
    else:
        response = await large_model.complete(user_query)

    # eval gate: lightweight judge before returning
    score = validator.score(response, context=q_emb)
    if score < 0.7:
        # escalate to stronger model or human queue
        response = await large_model.complete(user_query, system='escalate')

    # store in semantic cache asynchronously
    qdrant_upsert(collection=tenant_id, vector=q_emb, payload={'response': response}, ttl=CACHE_TTL)

    return response

This pattern is intentionally simple: embed first, check cache, route, validate, then writeback. In production you’ll add tracing spans around each step and per-request cost attribution.

Operational checklist (short)

• Centralize traffic through an LLM gateway (routing, budget, auth, failover).
• Instrument end-to-end traces with prompt and embedding version metadata.
• Implement semantic caching with tenant-aware namespaces and tuned similarity thresholds.
• Add eval gates (LLM-as-judge) on the hot path or async with human-review routing.
• Autoscale vector DBs and model serving independently; set SLOs for latency and cost.

LLMOps is an operating model, not a sprint

LLMOps for compound AI systems is not a single checklist you run once. It’s an operating model you iterate on as traffic reveals new failure modes: new query types, escalations, or cost drivers. Start with a gateway + tracing + semantic cache and expand to eval pipelines and tiered autoscaling.

What single LLMOps control would have saved your team the most pain when you moved from demo to production? Share a painful incident and the control that would have caught it earlier — that’s where the next optimization usually hides.