FedRAMP Moderate cost control architecture for enterprise LLM deployment — Reference Architecture

Reference architecture · published 2026-10-16 · regulated enterprise · FedRAMP Moderate · layout spec_first · implementation executed in CI before publish

Enterprise implementation parameters

Every value below is a parameter you can hold a vendor or an internal team to. Adjectives are not acceptance criteria.

The control that resolves this is a Pre-Flight Budget Governor, evaluated before the request reaches a model provider rather than audited afterwards. In regulated enterprise the binding constraint is FedRAMP Moderate, and the question it actually asks is which NIST 800-53 control does each component satisfy. The shape below holds p95 ≤ 900ms over durable queue (SQS / Kafka) with an outbox, and ships with a standard-library implementation that runs as written.

Where the rollout actually stalls

LLM spend is discovered in a monthly invoice and defended with a dashboard, so it is reported rather than controlled. Finance asks for a per-team cap and engineering cannot implement one, because nothing in the request path knows a budget exists.

What FedRAMP Moderate specifically requires

FedRAMP is control-by-control. Every component must map to a specific NIST 800-53 Rev 5 control identifier with an implementation statement, and anything crossing the authorisation boundary needs its own justification in the SSP.

The artifact that satisfies it is a control implementation summary mapped to control identifiers. The way teams most often fail it: a component outside the authorisation boundary that nobody documented, found during assessment.

Reference implementation — Two-phase token budget with per-tenant chargeback

Standard-library Python, no external dependencies, runs as written. Executed by the publish gate: if it raises, this page does not ship. Wire it behind durable queue (SQS / Kafka) with an outbox; the failure mode it guards against is a consumer crash between side effect and acknowledgement. The output you hand the assessor is the SSP control implementation summary.

"""Pre-flight token budget enforcement with per-tenant chargeback.

Why this shape: LLM spend is discovered monthly in an invoice and defended with
a dashboard, which means it is never actually controlled. The control has to run
BEFORE the call, on an estimate, with a hard ceiling per tenant and per period —
otherwise the first thing finance asks for is a cap you cannot implement.
"""
import math
import time
from dataclasses import dataclass, field


# USD per 1k tokens. Keep rates in config, not code: they change, and a stale
# rate silently misprices every chargeback downstream of it.
RATES = {
    "frontier":  {"in": 0.0030, "out": 0.0150},
    "mid":       {"in": 0.0008, "out": 0.0040},
    "small":     {"in": 0.0001, "out": 0.0004},
}


def estimate_tokens(text: str, chars_per_token: float = 3.8) -> int:
    """Deliberately a conservative OVER-estimate.

    Under-estimating defeats the purpose: the request gets admitted, the real
    usage exceeds the budget, and the ceiling is decorative."""
    return max(1, math.ceil(len(text or "") / chars_per_token))


def price(tier: str, tokens_in: int, tokens_out: int) -> float:
    r = RATES[tier]
    return (tokens_in / 1000.0) * r["in"] + (tokens_out / 1000.0) * r["out"]


class BudgetExceeded(Exception):
    def __init__(self, tenant, projected, ceiling):
        self.tenant, self.projected, self.ceiling = tenant, projected, ceiling
        super().__init__(f"{tenant}: ${projected:.4f} would exceed "
                         f"${ceiling:.2f} for the period")


@dataclass
class Budget:
    ceiling_usd: float
    period_seconds: float = 86400.0
    spent_usd: float = 0.0
    started: float = field(default_factory=time.time)
    committed: dict = field(default_factory=dict)   # request_id -> reserved USD

    def _roll(self, now):
        if now - self.started >= self.period_seconds:
            self.started, self.spent_usd = now, 0.0
            self.committed.clear()

    def reserve(self, request_id: str, projected_usd: float, now=None) -> float:
        """Two-phase: reserve the estimate, settle the actual.

        Without a reservation, N concurrent requests each see the same low
        `spent` and all get admitted — the classic race that blows a cap."""
        now = time.time() if now is None else now
        self._roll(now)
        outstanding = sum(self.committed.values())
        if self.spent_usd + outstanding + projected_usd > self.ceiling_usd:
            raise BudgetExceeded("tenant",
                                 self.spent_usd + outstanding + projected_usd,
                                 self.ceiling_usd)
        self.committed[request_id] = projected_usd
        return projected_usd

    def settle(self, request_id: str, actual_usd: float):
        self.committed.pop(request_id, None)
        self.spent_usd += actual_usd

    def release(self, request_id: str):
        self.committed.pop(request_id, None)


class Governor:
    def __init__(self):
        self.budgets: dict = {}
        self.ledger: list = []

    def set_budget(self, tenant: str, ceiling_usd: float, period_seconds=86400.0):
        self.budgets[tenant] = Budget(ceiling_usd, period_seconds)

    def admit(self, tenant: str, request_id: str, prompt: str,
              tier: str = "mid", max_output_tokens: int = 1024) -> dict:
        b = self.budgets.get(tenant)
        if b is None:
            raise KeyError(f"{tenant} has no budget: fail closed, never open")
        t_in = estimate_tokens(prompt)
        projected = price(tier, t_in, max_output_tokens)
        b.reserve(request_id, projected)
        return {"tenant": tenant, "request_id": request_id, "tier": tier,
                "tokens_in_est": t_in, "projected_usd": round(projected, 6)}

    def record(self, tenant: str, request_id: str, tier: str,
               tokens_in: int, tokens_out: int) -> dict:
        actual = price(tier, tokens_in, tokens_out)
        self.budgets[tenant].settle(request_id, actual)
        row = {"tenant": tenant, "request_id": request_id, "tier": tier,
               "tokens_in": tokens_in, "tokens_out": tokens_out,
               "actual_usd": round(actual, 6), "ts": time.time()}
        self.ledger.append(row)     # this is the chargeback record
        return row


if __name__ == "__main__":
    g = Governor()
    g.set_budget("bank-eu", ceiling_usd=0.05)
    adm = g.admit("bank-eu", "req-1", "Reconcile these 400 journal lines." * 20)
    print("admitted:", adm)
    print("settled :", g.record("bank-eu", "req-1", "mid", adm["tokens_in_est"], 310))
    try:
        for i in range(40):
            g.admit("bank-eu", f"burst-{i}", "x" * 4000, tier="frontier")
    except BudgetExceeded as e:
        print("ceiling held:", e)

The FedRAMP Moderate control, as code

NIST 800-53 control map with a boundary-crossing check. This is the artifact an assessor asks for under FedRAMP Moderate specifically — it is not the same control as the one above, and a system that implements one does not thereby implement the other. It executes under the same publish gate.

"""NIST 800-53 control satisfaction map with an authorisation-boundary check.

FedRAMP reviewers do not ask whether the system is secure. They ask which
control, by identifier, each component satisfies, and what crosses the
authorisation boundary. An external model endpoint is a boundary crossing, and
an undeclared crossing is the finding that stalls an ATO.
"""

MODERATE_BASELINE = {
    "AC-4": "Information flow enforcement",
    "AU-2": "Event logging",
    "AU-9": "Protection of audit information",
    "CA-3": "Information exchange / external connections",
    "SC-7": "Boundary protection",
    "SC-8": "Transmission confidentiality and integrity",
    "SC-28": "Protection of information at rest",
    "SI-4": "System monitoring",
}


class AuthorisationBoundary:
    def __init__(self, name: str):
        self.name = name
        self.components: dict[str, dict] = {}
        self.crossings: list[dict] = []

    def declare(self, component: str, inside: bool, controls: list[str]) -> None:
        unknown = [c for c in controls if c not in MODERATE_BASELINE]
        if unknown:
            raise KeyError(f"not in the Moderate baseline: {unknown}")
        self.components[component] = {"inside": inside, "controls": set(controls)}

    def connect(self, src: str, dst: str, declared: bool) -> None:
        for end in (src, dst):
            if end not in self.components:
                raise KeyError(f"undeclared component: {end}")
        crossing = self.components[src]["inside"] != self.components[dst]["inside"]
        self.crossings.append({"src": src, "dst": dst,
                               "boundary_crossing": crossing, "declared": declared})

    def undeclared_crossings(self) -> list[dict]:
        return [c for c in self.crossings if c["boundary_crossing"] and not c["declared"]]

    def coverage(self) -> dict:
        covered = set()
        for meta in self.components.values():
            covered |= meta["controls"]
        gaps = sorted(set(MODERATE_BASELINE) - covered)
        return {"covered": sorted(covered), "gaps": gaps,
                "ato_ready": not gaps and not self.undeclared_crossings()}


if __name__ == "__main__":
    b = AuthorisationBoundary("agency-llm-enclave")
    b.declare("gateway", True, ["AC-4", "SC-7", "SC-8"])
    b.declare("audit_store", True, ["AU-2", "AU-9", "SC-28"])
    b.declare("monitor", True, ["SI-4"])
    b.declare("external_model_api", False, ["CA-3"])

    b.connect("gateway", "audit_store", declared=True)
    b.connect("gateway", "external_model_api", declared=True)
    cov = b.coverage()
    assert cov["ato_ready"], cov
    assert cov["gaps"] == [], cov

    # The finding this exists to catch: a crossing nobody declared.
    b2 = AuthorisationBoundary("agency-llm-enclave")
    b2.declare("gateway", True, list(MODERATE_BASELINE))
    b2.declare("telemetry_sidecar", False, ["CA-3"])
    b2.connect("gateway", "telemetry_sidecar", declared=False)
    assert not b2.coverage()["ato_ready"], b2.coverage()
    assert len(b2.undeclared_crossings()) == 1, b2.undeclared_crossings()

    try:
        b2.declare("rogue", True, ["XX-1"])
        raise AssertionError("accepted a control outside the baseline")
    except KeyError:
        pass

    print("FedRAMP Moderate boundary + control map: OK")
    print(f"  controls covered {len(cov['covered'])}/{len(MODERATE_BASELINE)}, "
          f"undeclared crossings {len(b2.undeclared_crossings())}")

The request path

Pre-Flight Budget Governor — the request path, with the decision points that must exist before the first model call:

flowchart LR
    REQ[Request] --> EST[Conservative token estimate]
    EST --> PR[Price at tier rate]
    PR --> RES{Reserve against budget<br/>spent + outstanding + projected}
    RES -->|over ceiling| REJ[429 BudgetExceeded]
    RES -->|no budget| FC[Refuse - fail closed]
    RES -->|ok| TR[Tier router<br/>cheapest tier meeting quality bar]
    TR --> M[Model call]
    M --> ST[Settle actual usage]
    ST --> LED[(Chargeback ledger)]
    LED --> FIN[Finance reconciliation]

The parts you have to build

1. Conservative estimator — Deliberately over-estimates; under-estimating makes the ceiling decorative.
2. Two-phase budget — Reserve the estimate, settle the actual — closes the concurrency race.
3. Rate table in config — Prices change; a stale rate in code silently misprices every chargeback.
4. Tier router — Routes to the cheapest tier that meets the quality bar for the task.
5. Chargeback ledger — Per-tenant, per-request actuals — the artifact finance reconciles against.
6. Fail-closed default — A tenant with no budget is refused, never admitted.

Risk register with acceptance criteria

Each row carries an acceptance parameter rather than an adjective, because "low latency" cannot be signed off. Retention here is bound by per the data class retention schedule, enforced automatically.

Control questions before sign-off

• Which NIST 800-53 control does each component satisfy, and which components sit outside the authorisation boundary?
  Each component carries its control identifiers in configuration, and the boundary diagram is generated from that configuration so it cannot drift from reality.
• What refuses a request that would exceed this team's monthly cap, and where in the path does it run?
  The budget governor, at admission — before the model call. It prices a conservative token estimate against the tenant's remaining ceiling and refuses the request if the projection would exceed it.
• If 50 requests arrive at once against a nearly-exhausted budget, how many are admitted?
  Only those that fit. Admission counts outstanding reservations as well as settled spend, which closes the race where concurrent requests all read the same low figure and are all admitted.
• How does your chargeback figure reconcile to the provider invoice, and what is the variance?
  The chargeback ledger records per-request actuals priced from a versioned rate table with an effective date; reconcile it monthly and track the variance against the provider invoice.
• What happens to a tenant with no budget configured?
  It is refused. A missing budget fails closed — admitting an unbudgeted tenant is how the cap becomes decorative.
• Which rate table priced last month's chargeback, and when was it last updated?
  The rate table in versioned config, with its effective date recorded. A rate older than 90 days raises an alert, because a stale rate silently misprices every chargeback downstream.

Related reference architectures

• Part of enterprise llm cost control.
• fedRAMP Moderate vendor evaluation criteria for enterprise AI covers the adjacent case.
• Where this interacts with another regime, see fedRAMP Moderate agent permission and delegated access architecture.
• fedRAMP Moderate tracing and token accounting architecture for enterprise covers the adjacent case.
• A different failure mode of the same component: fedRAMP Moderate model release gate and golden set evaluation.
• If this is the blocker in front of you: enterprise AI infrastructure review.