Ads ranking models are scaling toward LLM-sized parameter counts faster than the underlying serving hardware can grow. Compute is finite and heterogeneous, so an extra unit of it returns very different value depending on the request, the model, and the chip it lands on. Intelligent Delivery is Meta's ML-driven answer to that allocation problem: a layer that steers resources across the serving stack toward a system-wide optimum, and that has contributed roughly 10% incremental ranking performance on top of model and system advances across major surfaces from 2017 through the first half of 2026.
Why allocation is hard
Three properties of ads delivery make global optimization difficult:
- Marginal compute value is heterogeneous and context-dependent. The same additional unit of compute yields different returns by surface, user intent, candidate quality, and system state. Request-aware signals alone are not enough: allocating well means estimating, per request, the return on every tunable system parameter, where each knob behaves differently at every funnel stage. That per-request calculation has to complete across a vast decision space within milliseconds.
- Local optima don't compose into a global one. Ads serving spans multi-stage ranking, hundreds of models, multiple hardware generations, and many data centers. Result estimation is only the first step; the stack must also be controllable, and resources can't be shifted reliably across those boundaries without adaptive controls that account for stack-wide dependencies.
- The optimum keeps moving. Every new model, hardware generation, or architecture reshapes the optimization landscape and can invalidate prior allocation decisions, so the system must adapt quickly enough to stay near-optimal.
Request understanding: one shared intelligence layer
The first version of this used coarse segments — requests grouped by surface, context, and ad creative representation, with engineer-authored policies per group. That approach didn't scale: each new signal multiplied the rules, and independent segments missed the nonlinear interactions among thousands of signals, capping accuracy.
Reframing the problem as two ML questions changed that: which ad requests are most likely to benefit from more compute, and how will different resource settings affect their outcomes and serving performance? Offline benchmarks on major surfaces showed about a 20% improvement in identifying the highest-impact requests relative to the previous production model.

The Resource Core Model handles the first question. It is a set of deep learning models with 6B sparse and 20M dense parameters that runs once before candidate retrieval and is shared across the delivery funnel. Learned embeddings and deep feature interactions pick up request patterns that manually defined segments cannot. It is then fine-tuned into specialized models, each producing incremental signals about outcome, compute consumption, and latency impact. The Core Model supplies the understanding; the individual allocation mechanisms decide how to act on it.

A hierarchy of allocation engines
The fleet is globally distributed and heterogeneous — many regions, several generations of hardware, and millions of hosts — all shared by a multi-tier stack, so no single mechanism can control resource distribution end to end. Instead the problem is decomposed into layers, each with its own decision engine. Following one request through a few hundred milliseconds of its lifecycle shows how they fit together.
Which region serves it? Traffic and capacity are not colocated, and regions differ in hardware mix and available headroom, so the same unit of compute is worth more in some places than others. Real-time infrastructure shifts traffic between regions on a cycle of minutes, driving toward the point where every region gets equal efficiency from its marginal unit of capacity.
Which hardware does it land on? The fleet spans Intel, AMD, and Arm CPUs and NVIDIA, AMD, and Meta Training and Inference Accelerator (MTIA) accelerators, across several generations of each. Variety isn't the hard part — capacity isn't interchangeable. Different stages are bound by different resources (retrieval by memory capacity, ranking by compute, model inference by accelerator throughput), so there is no single fastest SKU, only the best match per workload. Measured efficiency is benchmarked for every workload-SKU pair, and an assignment is solved to send scarce hardware to the workloads that convert it into the most useful work.
How much of the host does it get? Concurrent requests differ in latency budget and impact under a hard tail-latency SLO. Deep learning models predict each request's expected outcome plus its compute and latency cost, and a constrained optimization maximizes impact delivered within the host's latency budget. As load rises, the trade-off tightens and resource-intensive, low-impact work is trimmed first. Enforcing those decisions requires control from the kernel-level scheduler up to application-level thread pools.

These are only a subset of the decisions made across a request's lifetime; others cover how many ads to rank per request per stage and which candidates enter the pool. The decisions are tightly coupled — moving traffic between regions changes per-host load, which feeds the feedback controller that sets per-request work — so changes are validated in an end-to-end, closed-loop hardware testing environment to confirm the system is optimizing the global optimum rather than a local one.
Closing the optimization loop with agents
Integrating each new model, mechanism, or hardware generation into production means choosing among millions of tunable dimensions — too many to brute-force with available hardware and time. Engineers historically used prior knowledge to pick promising configurations, but the search space grew faster than that could cover. A constrained optimization approach automated part of it and improved results, yet it covered only a few key knobs, generalized poorly, and had no way to absorb human intuition.
Instead of searching blindly, AI agents monitor the system landscape for changes and inefficiencies. In a long context window, an agent reads mechanism source code, design documents, and a decade of experiment logs, then narrows the field to a handful of changes worth testing. Engineers review and approve each change before it ships.
Agents can already propose well-reasoned changes and design and run rigorous experiments. In the first half of 2026 they contributed to about 20% of Intelligent Delivery optimizations, and on the most automated mechanism they account for about 80% of engineering effort — from reading the system landscape and forming hypotheses through experiments to the final converged change. The loop has compressed from months to weeks, with people still firmly in control, and historically accumulated engineering expertise is steadily captured along the way.

Next frontiers
Real-time end-to-end optimization. Understanding a request and deciding how to serve it are still separate steps. The goal is a single model that reads a request and serves it in real time without months of experiments. Learning-based methods for varying compute per request are well established; the open problem is doing it jointly across every serving stage at once under shifting traffic, hard capacity limits, and tight inter-stage dependencies.
Serving state-of-the-art models on GPUs. Large ranking models such as Meta's Generative Ads Model (GEM) are growing toward LLM scale and increasingly run on GPUs, which opens a different optimization space. GPU capacity doesn't divide like CPU time — it comes in whole, fixed blocks, and throughput, batching, and memory behave differently. Levers built for a CPU world have to be rethought, and much current work goes into turning those mechanisms into new ones. The more useful work extracted from each accelerator, the more people can be served strong models under the same capacity.



