FedRAMP Moderate reference architecture for enterprise LLM deployment at scale — Reference Architecture

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

The control that resolves this is a Tenant-Fair Inference Tier, 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 ≤ 450ms over gRPC with mTLS, and ships with a standard-library implementation that runs as written.

The control gap

A shared inference tier holds under average load and breaches its p95 under a neighbour's batch job. The SLA is written on a percentile, the dashboards show a mean, and admission control is a single global rate limit that protects the provider rather than any individual tenant.

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.

Component breakdown

1. Per-tenant token bucket — Sustained rate plus burst, so one tenant cannot spend another's budget.
2. Reservation ledger — Guaranteed in-flight slots per tenant; reservations must sum below the ceiling.
3. Global concurrency ceiling — Bounds the shared tier so it degrades predictably instead of collapsing.
4. Percentile window — Streaming p95/p99 per tenant — the number the contract is written on.
5. Queue with deadline — Requests carry a deadline and are shed rather than served late.
6. Shed path — 429 with an accurate Retry-After so clients back off instead of hot-looping.

Reference implementation — Per-tenant admission control and percentile tracking

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 gRPC with mTLS; the failure mode it guards against is a half-open HTTP/2 stream silently dropping the deadline. The output you hand the assessor is the SSP control implementation summary.

"""Per-tenant admission control for a shared inference tier.

Why this shape: a global rate limit protects the provider and nobody else. The
failure enterprises actually hit is the noisy-neighbour one — tenant A's batch
job saturates the queue and tenant B breaches the p95 latency SLA that is
written into their contract. You cannot fix that downstream of admission.

Two controls, both required:
  * a per-tenant token bucket, so one tenant cannot consume another's budget
  * a global concurrency ceiling with per-tenant reservations, so the shared
    tier degrades predictably instead of collapsing
"""
import heapq
import time
from dataclasses import dataclass, field


@dataclass
class TokenBucket:
    rate: float            # sustained requests per second
    burst: float           # instantaneous allowance
    tokens: float = None
    updated: float = field(default_factory=time.monotonic)

    def __post_init__(self):
        if self.rate <= 0 or self.burst <= 0:
            raise ValueError("rate and burst must be positive")
        if self.tokens is None:
            self.tokens = self.burst

    def take(self, n: float = 1.0, now: float = None) -> bool:
        now = time.monotonic() if now is None else now
        elapsed = max(0.0, now - self.updated)
        self.tokens = min(self.burst, self.tokens + elapsed * self.rate)
        self.updated = now
        if self.tokens >= n:
            self.tokens -= n
            return True
        return False

    def retry_after(self, n: float = 1.0) -> float:
        """Seconds until n tokens exist. Return this in a 429 Retry-After so
        clients back off correctly instead of hot-looping."""
        deficit = max(0.0, n - self.tokens)
        return deficit / self.rate


class Admission:
    """Per-tenant buckets plus a global concurrency ceiling with reservations.

    reserved: tenant -> guaranteed in-flight slots. The sum of reservations
    must stay below `ceiling`, or the guarantee is fiction.
    """

    def __init__(self, ceiling: int, reserved: dict = None):
        self.ceiling = ceiling
        self.reserved = dict(reserved or {})
        if sum(self.reserved.values()) > ceiling:
            raise ValueError(
                f"reservations {sum(self.reserved.values())} exceed ceiling "
                f"{ceiling}: at least one tenant's SLA cannot be honoured")
        self.buckets: dict = {}
        self.inflight: dict = {}

    def configure(self, tenant: str, rate: float, burst: float):
        self.buckets[tenant] = TokenBucket(rate=rate, burst=burst)

    def admit(self, tenant: str, cost: float = 1.0) -> tuple:
        """-> (admitted, reason, retry_after_seconds)"""
        bucket = self.buckets.get(tenant)
        if bucket is None:
            return False, "tenant_not_provisioned", None

        used = sum(self.inflight.values())
        mine = self.inflight.get(tenant, 0)
        my_reservation = self.reserved.get(tenant, 0)

        # A tenant inside its reservation is admitted even when the shared pool
        # is full — that is what makes the reservation worth signing.
        if used >= self.ceiling and mine >= my_reservation:
            return False, "global_ceiling", 0.05

        if not bucket.take(cost):
            return False, "tenant_rate_limit", round(bucket.retry_after(cost), 3)

        self.inflight[tenant] = mine + 1
        return True, "ok", None

    def release(self, tenant: str):
        self.inflight[tenant] = max(0, self.inflight.get(tenant, 0) - 1)


class LatencyWindow:
    """Streaming p95/p99 over a bounded window.

    An average hides exactly the breach you are contractually exposed to: an
    SLA is written on a percentile, so the number you alert on must be one.
    """

    def __init__(self, size: int = 2048):
        self.size = size
        self.samples: list = []

    def observe(self, ms: float):
        self.samples.append(ms)
        if len(self.samples) > self.size:
            self.samples = self.samples[-self.size:]

    def quantile(self, q: float) -> float:
        if not self.samples:
            return 0.0
        ordered = sorted(self.samples)
        # Nearest-rank: the smallest sample at or above the q-th position.
        idx = min(len(ordered) - 1, max(0, int(round(q * len(ordered) + 0.5)) - 1))
        return ordered[idx]

    def breach(self, slo_ms: float, q: float = 0.95) -> bool:
        return self.quantile(q) > slo_ms


if __name__ == "__main__":
    adm = Admission(ceiling=10, reserved={"bank-eu": 4})
    adm.configure("bank-eu", rate=5, burst=5)
    adm.configure("retail-us", rate=50, burst=50)
    for _ in range(9):
        adm.admit("retail-us")
    print("noisy neighbour holds", adm.inflight)
    print("reserved tenant still admitted:", adm.admit("bank-eu"))
    print("burst exhausted ->", [adm.admit("bank-eu") for _ in range(5)][-1])

    win = LatencyWindow()
    for ms in [120, 140, 135, 128, 900, 131, 139, 142, 150, 2200]:
        win.observe(ms)
    print(f"p95={win.quantile(0.95):.0f}ms breach(400ms)={win.breach(400)}")

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

Tenant-Fair Inference Tier — the request path, with the decision points that must exist before the first model call:

flowchart TB
    subgraph Tenants
      TA[Tenant A - batch]
      TB[Tenant B - interactive p95 400ms]
    end
    TA --> AD{Admission}
    TB --> AD
    AD -->|bucket empty| S429[429 + Retry-After]
    AD -->|ceiling full,<br/>outside reservation| S429
    AD -->|admit| Q[Deadline queue]
    Q -->|deadline passed| SH[Shed - do not serve late]
    Q --> W[Worker pool]
    W --> P[Model / vLLM]
    P --> OBS[Per-tenant p95 / p99 window]
    OBS -->|breach| ALERT[Page + autoscale signal]

Technical parameters

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

Risk mitigation matrix

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.
• Which tenants have contractual percentile targets, and what reserves capacity for them?
  Any tenant with a contractual percentile gets an entry in the reservation ledger — guaranteed in-flight slots inside the global ceiling. Reservations are validated at configuration time and must sum below the ceiling.
• What happens to tenant B's p95 when tenant A sends 10x its normal volume — measured, not assumed?
  Tenant B stays inside its SLO, because tenant A is bounded by its own token bucket and cannot consume B's reserved slots. This is testable: saturate A and watch B's p95 window.
• Is the alert on a percentile or a mean?
  A percentile. The SLA is written on p95, so the alert is on p95. The mean is dashboard-only, because it hides exactly the breach you are contractually exposed to.
• What is shed under saturation, and how does a client learn when to retry?
  Requests past their deadline are shed rather than served late, and the shed path returns 429 with an accurate Retry-After computed from the bucket's refill rate so clients back off instead of hot-looping.
• Can a cache entry created for one tenant ever be served to another?
  No. Every cache key is namespaced by tenant id; keying on prompt text alone is the mechanism by which one tenant's completion is served to another.

See also

• Part of enterprise llm architecture at scale.
• ISO/IEC 27001:2022 reference architecture for enterprise LLM deployment covers the adjacent case.
• HIPAA reference architecture for enterprise LLM deployment at scale covers the adjacent case.
• Where this interacts with another regime, see enterprise LLM deployment at scale.
• If this is the blocker in front of you: enterprise AI infrastructure review.