arXiv:2606.14350v1 [cs.DC] 12 Jun 2026
Design Methodology and Performance Trade-offs Management for Distributed and Compound AI Systems Milos Gravara
Andrija Stanisic
Stefan Nastic
Distributed Systems Group TU Wien [email protected]
Distributed Systems Group TU Wien [email protected]
Distributed Systems Group TU Wien [email protected]
Abstract—Artificial Intelligence (AI) systems must typically satisfy service-level objectives including accuracy, latency, and cost. The prevailing model-centric approaches select a monolithic model at design time and use it to process all inputs. Monolithic models apply identical computation regardless of input difficulty, cannot decompose tasks across specialized components, and have knowledge that is fixed at training time. During runtime, this can lead to performance degradation and increasing costs. Because the model is the most important design variable, it determines the majority of system behavior, coupling operational objectives to a single design-time choice. Addressing these limitations requires shifting from model-centric to system-centric design. Compound AI systems realize this shift by orchestrating multiple models, algorithms, and tools as distributed AI systems through explicit control logic. The performance of such systems depends on their workflow topology, the models assigned to each task, and the parameters governing runtime behavior. We present a design methodology that organizes this space along two dimensions, workflow topology and configuration selection, and identifies eight design patterns, each consolidating techniques to address a specific limitation of monolithic deployment. We validate our methodology through three case studies spanning object detection, question answering, and mathematical reasoning. Across our case studies, Compound AI configurations approach accuracy of monolithic models within 2.5 to 4 percentage points while reducing latency by up to 60% and cost by up to 71%. We show that model selection and parameter configuration jointly determine system performance, but the resulting design space grows combinatorially, as workflows compose more patterns and components. Thus, we identify five open challenges that define a roadmap from manually configured prototypes towards systems that automatically discover and maintain SLO-compliance in Compound and Distributed AI systems. Index Terms—Compound AI, Distributed AI Systems, Compound AI Optimization, Distributed Inference
I. I NTRODUCTION Artificial intelligence (AI) systems are deployed at massive scale across applications such as video analytics, autonomous navigation, conversational assistants, and code generation [1]. Advances in model architectures and training methods [2]–[4] have expanded their capabilities to include complex reasoning, multimodal understanding, and open-end interactions. As adoption grows, these models must satisfy strict service level objectives (SLOs), which typically include latency, throughput,
and cost. This places increasing pressure on how models are deployed [5], [6]. The prevailing approach for AI deployment is modelcentric [5], [7]. A single, monolithic model is selected at design time based on task-specific benchmarks and effectively remains fixed during serving. Every input follows the same computational path and consumes the same resources regardless of its content or difficulty. Improving performance for a given task relies primarily on scaling the model through additional parameters, training data, or compute budget, following empirical scaling laws [4], [8], [9]. However, model-centric AI systems exhibit structural limitations that cannot be resolved through scaling alone [10]. First, monolithic models apply the same inference process to every request regardless of its difficulty and domain. As a result, simple queries consume the same computational resources as complex ones, and there is no mechanism to decompose tasks across specialized models [11], [12]. Second, many real-world tasks require capabilities beyond model inference, such as precise computation, interaction with external systems, or output verification. These operations cannot be reliably performed by single models, regardless of their size [13]. Third, the knowledge encoded in model parameters is fixed at training time. Incrementally updating this knowledge through retraining or fine-tuning becomes prohibitively expensive as model scale increases [14]. In production, these structural limitations directly affect SLOs [15]. Because the model is the most important design variable, it determines the majority of system behavior, coupling operational objectives to choices made at design time [16], with no mechanism to control them independently. Satisfying SLOs requires selectively allocating computation across requests, composing specialized components for different aspects of a task, and adapting system behavior to changing workloads. A monolithic model whose behavior is fixed at inference time cannot provide this control. Addressing these requirements demands a shift from model-centric to systemcentric approach, where the unit of design is no longer the model but the system that orchestrates models, algorithms, and tools.
Compound AI [7] is an emerging paradigm which attempts to address these limitations by shifting the design focus from a single model to a composed system. Compound AI systems combine specialized AI models and engineered software components into workflows with explicit control logic. Instead of relying on a single model, the system can retrieve external knowledge [17], route requests to models with different capabilities [11], [12], invoke tools for specialized tasks [13], and allocate additional inference-time computation when necessary [18]. However, the performance of such systems no longer depends on a single model choice, but on multiple design decisions, such as the topology of the workflow, the assignment of models to each inference task, and the parameters that govern runtime behavior [19], [20]. In this paper, we present a design methodology for Compound AI systems that decomposes system design into two dimensions: workflow structure and configuration selection. We identify eight design patterns that capture common workflow topologies addressing key limitations of monolithic deployment. We evaluate the methodology across three case studies in vision and language domains, demonstrating that Compound AI systems can approach monolithic baselines while improving latency and cost. Our main contributions include: We consolidate recurring workflow composition techniques into eight design patterns for Compound AI systems, each addressing a specific limitation of monolithic deployment. • We empirically characterize Compound AI performance across three Compound AI workflows in vision and language domains. Throughout experiments, Compound AI systems achieve task performance comparable to monolithic baselines, while yielding efficiency gains of up to 60% in latency and 71% in cost. • We identify five open challenges in Compound AI that define a roadmap from manually configured prototypes towards AI systems that automatically discover and maintain SLO-compliance.
demonstrates that satisfying production SLOs requires degrees of freedom that a single model cannot provide. A. Monolithic AI Models The standard approach to AI deployment serves a single model as the complete inference pipeline. A monolithic deployment selects one model with fixed parameters and applies it uniformly to all incoming requests. The model is chosen at design time based on task-specific benchmarks, and its parameters remain fixed throughout serving. Every input, regardless of its content or difficulty, follows the same computational path and consumes the same resources. The choice of model is therefore the most important design variable in this paradigm, simultaneously determining output quality, computational cost, and serving latency. The primary mechanism for improving monolithic model performance is scaling, which involves increasing the number of parameters, the volume of training data, or the training compute budget. Scaling laws establish that pretraining loss decreases as a power law with respect to model size, dataset size, and compute [4], [8]. This is a model-centric paradigm that has driven consistent progress across tasks and modalities, with improvements measured by accuracy, F1, or similar metrics on held-out benchmarks.
•
The rest of the paper is organized as follows. Section II provides background on monolithic AI deployment and its limitations. Section III presents the design methodology, including design patterns and configuration selection. Section IV validates the methodology through case studies and identifies key Compound AI properties. Based on these findings, Section V lays out future research challenges. Section VI discusses related work, and Section VII concludes the work. II. M OTIVATION This section motivates the shift from model-centric to system-centric AI approaches. Section II-A establishes that in monolithic deployment model choice is the most important design variable, with model scaling as the only mechanism for improvement [4], [8]. Section II-B shows that production deployment fixes all three SLO dimensions to a single operating point that inference serving cannot change. Section II-C
B. Inference Serving A model in production must satisfy SLOs spanning accuracy, latency, and cost [15]. These objectives are coupled: higher accuracy consistently requires greater computational cost and latency. Inference serving systems manage deployments through request batching, memory allocation, and workload scheduling, with modern frameworks establishing standard practices through continuous batching, fragmentationaware memory management, and hardware-aware scheduling [21]–[23]. Such optimizations make a fixed model run more efficiently, but cannot change which model processes a given input or how much computation it receives. Because the model is the sole component of the deployed system, the model choice determines where the system operates across all three SLO dimensions. One model produces one operating point in the accuracy-latency-cost space, fixed at design time and unchanged throughout deployment. C. Limitations of Monolithic Deployment Figure 1 illustrates this coupling on GSM8K [24] benchmark across eight models from four model families: Gemma and Llama, served locally on an A4000 GPU (16GB), and GPT and Claude, accessed through proprietary APIs. Each model occupies a single point in both the accuracy-latency plane (Figure 1a) and the accuracy-cost plane (Figure 1b). The trend in both panels shows that moving toward higher accuracy requires accepting higher latency and higher cost simultaneously. No model reaches the top-left region of either panel, where high accuracy would coincide with low latency or low cost. The design variable is the model itself, and each model
Gemma
Llama
100 Sonnet 4
Accuracy (%)
90 Haiku 4.5 4o-mini
4o-mini Gemma 12B Llama 3B Gemma 4B
Llama 3B Gemma 4B
70
III. D ESIGN M ETHODOLOGY FOR C OMPOUND AI
Claude
GPT-4.1
Gemma 12B
80
GPT
GPT-4.1 Haiku 4.5
Sonnet 4
60 50
Llama 1B
Llama 1B
40 0
2
4
6
Latency (s)
(a) Accuracy vs. latency
8
0.02 0.05 0.10 0.20 0.50 1
2
Cost per 1K queries ($)
5
(b) Accuracy vs. cost
Fig. 1: Monolithic operating points on GSM8K (100 problems). Each model occupies a fixed position in the (a) accuracy-latency and (b) accuracy-cost planes.
produces exactly one operating point with no mechanism to trade off one objective against another at runtime. This rigidity is particularly wasteful because workloads are non-uniform. Inputs vary in difficulty, domain, and computational requirements. On GSM8K, for example, cheap local models such as Llama3.2-3B already solve 78% of problems correctly, while the remaining fraction requires models that cost up to two orders of magnitude more per query. Monolithic deployment ignores this structure by applying a single model uniformly to all inputs, over-provisioning for easy inputs and under-provisioning for hard ones. Beyond efficiency, monolithic models have structural limitations that scaling cannot resolve. A model’s knowledge is determined entirely by its training data, so it cannot access information that emerged after training without retraining or fine-tuning. This can turn out to be prohibitive, as the cost of incremental improvement grows exponentially [14]. Additionally, a monolithic model must cover every capability the task demands, even when dedicated models trained for specific aspects of the task would produce better results [25]. These are architectural rather than capacity constraints, as adding parameters does not give a model the ability to access external knowledge, or delegate work to a more suitable model. Meeting these requirements demands internal degrees of freedom that monolithic deployments cannot provide. Specifically, a system needs the ability to decide which model handles which input, when a result is sufficient to stop further computation, how much external knowledge to incorporate for a given request, whether an output meets quality criteria before it is served, and how to apportion computation across components when resources are constrained. None of these decisions can be expressed within a monolithic deployment because there is no point at which the system can observe input properties, intermediate results, or operating conditions and act on them. This is why addressing these limitations requires moving from model-centric to system-centric design, where the composition of models, algorithms, and tools becomes the design object and the decisions above become explicit, configurable aspects of the system.
We propose a design methodology for Compound AI systems. Compound AI systems are distributed AI systems that orchestrate AI models and software-engineered components through explicit control logic to meet service-level objectives. The control logic determines which component processes a given input, what context it receives, and how intermediate results are combined. Compound AI systems can be conceptually described using three main types of building blocks. AI Models perform the core inference tasks such as prediction, generation, or classification. Algorithms provide deterministic logic for control and coordination: dispatching requests, evaluating output quality, combining results, and enforcing constraints. Tools provide external capabilities such as databases, search indices, or code execution that extend the system beyond what models and algorithms can compute. These categories determine what types of parameters each component exposes, as discussed in Section III-B. The design methodology decomposes Compound AI system design into two dimensions. The first dimension is workflow topology, which determines how components are arranged and how data flows between them. Section III-A identifies eight design patterns that each address a specific limitation of monolithic deployments. The second dimension is configuration selection, which assigns specific models to inference tasks and sets the parameters that govern runtime behavior. Section III-B shows that this choice determines where the system operates within the accuracy-latency-cost space. A. Design Patterns Each design pattern defines a workflow topology that addresses a specific limitation of monolithic deployment. These patterns generalize techniques already established in practice, referenced in the Example column of Table I, recast as reusable structural abstractions. Fig. 2 illustrates the topology of each pattern, and Table I summarizes the problem that each pattern addresses, its structural solution, the expected effect on system objectives, and examples. We organize the eight patterns into four groups by the objective they primarily target: compute efficiency, output quality, capability extension, and safety. Compute Efficiency. The Router and Cascade patterns can improve compute efficiency by avoiding invocation of the same model for every request, regardless of its difficulty. Both patterns selectively allocate inference across models of different capability, but differ in timing of the allocation decision. The Router evaluates input properties, such as input difficulty or domain, before inference and dispatches each request to an appropriate model. The Router commits to a single model upfront, which is cheaper when the estimate is correct but risks misrouting. The Cascade, however, invokes models sequentially from lightweight to heavyweight and stops when a scoring function determines the output is sufficient. The Cascade always starts cheap and escalates only when necessary, but may invoke multiple models for hard inputs.
Model
Router
Model B
Data flow
Tool
Input
Input
Model A
Algorithm
Input
Model₁
Score
Model₂
Score
✓
✓
y₁
y₂
y
…
ₖ
Output
(e) Tool Executor
Model Output
(b) Cascade
(c) Sampler
Input
Input
Input
Model
Pre-filter
Model B
Model C
✗ retry
(d) Retriever
block
Model
Verifier
API Tool Registry
Data Source
select best
Calculator
Model A
⊕
Output
Input
Code Exec
Retriever
yN
Scorer Output
(a) Router
Model
×N
Model C
Output
⊕
Input
Model
Model₃
Dispatcher
Conditional
Aggregator
✓ accept
Output
Output
(f) Aggregator
(g) Verifier
Post-filter
block
Output
(h) Guardrail
Fig. 2: Design pattern topologies. Pattern Router
Problem Monolithic deployment applies the same model to every request, wasting cost and latency on inputs that a cheaper model could resolve correctly.
Solution A control component (e.g., algorithm or learned model) evaluates input properties and dispatches each request to an appropriately sized model.
Expected Effect Reduces cost and latency; risks accuracy loss when the router misclassifies input difficulty
Example RouteLLM [26], Hybrid LLM [12], ECO-LLM [27], collaborative object detection for edge video [28]–[30].
Cascade
Monolithic deployment applies the same model to every request, but input difficulty cannot be reliably estimated before inference.
Models are invoked sequentially from lightweight to heavyweight, with a scoring function (algorithm or model) evaluating output quality at each step; processing stops when quality is sufficient.
Reduces average cost by resolving most requests cheaply; increases worst-case latency when escalation is required.
FrugalGPT [11], speculative cascades [31], AutoMix [32], ViolaJones attentional cascade [33], MTCNN [34], BranchyNet early exits [35].
Sampler
A monolithic model’s output quality is bounded by a single inference pass, with no mechanism to improve quality by investing additional compute at inference time.
One or more models generate N candi- Improves output quality by scaldate outputs via repeated sampling; an ing inference-time compute; cost aggregation component combines or se- increases linearly with N . lects among candidates to produce final output.
Self-consistency [18], best-ofN [36], AlphaCode [37], scaling test-time compute [38], [39], multi-agent debate [40], vote and filter-vote [41].
Retriever
A monolithic model’s knowledge is fixed at training time, and updating it through retraining becomes prohibitively expensive as model scale increases.
A retrieval tool (e.g., database or search index) provides relevant external context that is merged into the model’s input before generation.
Improves accuracy and knowl- RAG [17], REALM [42], Videedge coverage without scaling oRAG [43], MedRAG [44]. model size; adds retrieval latency and depends on retrieval quality.
Tool Executor
A monolithic model cannot reliably perform precise computation, execute code, or interact with external systems.
Subtasks requiring deterministic execution are delegated to external tools such as calculators, code interpreters, or API endpoints.
Improves correctness on tasks Toolformer [13], function requiring precise computation or calling [45], code interpreters [45], external interaction. Introduces MCP tool servers [46]. dependency on tool availability.
Aggregator
A single model produces one output per request with no mechanism to pool predictions across multiple models or input partitions running in parallel, leaving accuracy bounded by what one model can produce alone.
Multiple models or instances process the same input or different partitions of it in parallel; an aggregation component combines outputs through, for example, voting, fusion, or merging.
Improvement in accuracy and robustness through complementary predictions; support for parallel processing of large inputs; increased cost with the number of models or partitions.
Vote and Filter-Vote [41], multiagent debate [40], ChatEval [47], Weighted Boxes Fusion for detection [48], Random Forests [49].
Verifier
Single-pass generation provides no output quality guarantees. Monolithic model cannot detect or correct its own errors before the output is served.
A verification component (e.g., algorithm or model) evaluates output against acceptance criteria; the system re-generates outputs that fail with modified parameters up to a retry budget.
Improvement in output reliability through iterative refinement; increased latency and cost scaling with the number of retries.
Training verifiers for math [24], LEVER execution-based code verification [50], Self-Refine [51], AlphaCodium test-based verification [52], generator-verifier networks [36].
Guardrail
A monolithic model has no built-in mechanism to enforce safety or compliance constraints independently of its own output, making safety guarantees dependent on model behavior.
Pre- and post-processing filters (e.g., algorithms or specialized models) enforce safety and compliance constraints around the core model.
Enforcement of safety indepen- NeMo Guardrails [53], Llama dent of model behavior; in- Guard [54], TorchOpera [55], creased latency and potential SafeWatch video guardrails [56]. utility degradation due to overfiltering.
TABLE I: Design patterns for Compound AI systems. Each pattern addresses a limitation of monolithic deployment through a specific structural solution, producing a characteristic effect on system objectives.
Output quality. The Sampler, Verifier, and Aggregator patterns can be used to improve output quality beyond what a single inference pass achieves. The Sampler generates N candidate outputs and selects the best through voting or scoring, trading additional compute for quality. The Verifier evaluates inference output against acceptance criteria and retriggers inference when quality is insufficient, refining the output through iteration. The Aggregator pattern runs multiple models or model instances in parallel and combines their outputs through voting, fusion or merging. All three patterns provide a mechanism to invest additional compute to gain output quality. This opens the possibility of using smaller, more efficient models that recover quality through repeated or combined inference rather than model scale. Capability Extension. The Retriever and Tool Executor can extend the system with capabilities that model inference alone cannot provide. The Retriever may augment the model’s input with relevant external context fetched from a database or search index, addressing the limitation that model knowledge is fixed at training time. The Tool Executor can delegate subtasks requiring deterministic execution to external tools such as code interpreters or API endpoints, addressing the limitation that models cannot reliably perform precise computation. Both patterns allow the system to evolve its capabilities independently of the model, by updating retrieval sources or adding new tools without retraining. Safety and compliance. The Guardrail pattern can enable safety as a system-level property rather than a model-level behavior. Pre-processing and post-processing filters enforce safety and compliance constraints independently of the model that performs the task. This allows safety guarantees to hold across different model configurations and to be audited and updated without modifying the underlying model. Each pattern addresses a specific limitation of monolithic deployment, but introduces trade-offs in doing so. A Router can significantly reduce cost and latency, but risks accuracy loss when the routing decision is incorrect. A Retriever may improve accuracy through external context, but also may introduce latency in the process of retrieving relevant information. In practice, patterns compose to balance these trade-offs. A system that routes inputs to cheaper models can recover accuracy through retrieval, combining both patterns into a single workflow topology. The resulting topology specifies structural roles and control flow, but is independent of which specific models, algorithms, or tools fill each role. Assigning concrete components to these roles and setting the parameters that govern their runtime behavior is the subject of configuration selection. B. Configuration Selection The topology alone does not determine the Compound AI system behavior. For instance, two systems with identical topologies can produce different accuracy, latency, and cost if they use different models or different parameter settings. Configuration selection assigns specific models to the inference roles defined by the topology and sets the parameters
that govern runtime behavior. We define a system configuration as a complete assignment of models to all inference roles together with values for all parameters. A configuration fully specifies how the system processes any given input. Changing any element of the configuration, whether a model assignment or a single parameter value, can shift the system’s operating point across all performance dimensions. Model selection assigns a model to each inference role in the workflow topology. A Router pattern, for instance, requires a routing mechanism and a set of candidate models for dispatch. The choice of models determines the accuracy each path can achieve, the latency each path incurs, and the cost of each inference call, making model selection the most consequential configuration dimension. Similar decisions apply to algorithms and tools, such as which routing mechanism or which retrieval index to use, though these choices are typically more constrained by the pattern structure and deployment environment. Parameter configuration sets the values that govern runtime behavior within a fixed topology and model assignment. These include routing thresholds that determine when a request is dispatched to a cheaper model, retrieval depth that controls how much external context is provided, sample counts that govern how many candidate outputs are generated, and modellevel settings such as temperature or batch size. Different parameter values shift the system’s operating point across accuracy, latency, and cost. IV. C ASE S TUDIES IN C OMPOUND AI SYSTEMS We validate our design methodology through three case studies that instantiate design patterns from Section III across vision and language domains. Each study compares Compound AI performance against monolithic baselines and characterizes trade-offs between task performance, latency, and cost. A. Experimental Setup Fig. 3 shows the three workflow topologies. CODEC is a collaborative edge-cloud object detection system that processes streaming drone video. A lightweight detection model runs on every incoming frame at the edge, while a more capable detection model runs in the cloud on selected frames sent asynchronously. A temporal fusion algorithm merges cloud predictions with edge detections using IoU matching. CODEC instantiates the Router and Aggregator patterns. QARouter combines retrieval-augmented generation with learned routing for question answering. Every incoming query first retrieves relevant passages from a vector database. A trained classifier then evaluates the query alongside the retrieved context and dispatches it to either a local or a proprietary LLM for generation. QARouter composes the Retriever and Router patterns. InferScale applies test-time compute scaling for reasoning tasks. For each input, the system generates N candidate answers using repeated sampling and selects the best response through majority voting. Thus, InferScale instantiates the Sampler pattern, with the sample count N as the primary configuration parameter.
Edge (Jetson)
every frame
YOLOv8s/MobileNetV2 Video Frames
Frame Selector
Cloud (RTX 4090)
Temporal Fusion
Detections
y₂
Answer
Question
complex
Cloud Detector
y₁
Qwen / LLaMA
GPT-4o-mini/Haiku
Context
LLM
…
LLM
Retriever
IoU match selected
Router (DistilBERT)
⊕
Question
SLM
simple
q + context
Edge Detector
×N
y
ₖ
Majority Voting
Answer
most frequent
yN
Swin / YOLOv8x
Vector DB
(a) CODEC
(b) QARouter
(c) InferScale
Fig. 3: Workflow topologies of analyzed use cases. TABLE II: Experimental configuration for case studies. CODEC Models Dataset Metric Baseline Infrastructure
YOLOv8 [57], MobileNetV2-SSD [58], [59], Swin [60] VisDrone2019-VID [61] mAP@50 Swin, YOLOv8x Jetson Orin Nano 8GB (edge), RTX 4090 24GB (cloud)
QARouter Models Dataset Metric Baseline Infrastructure
DistilBERT [62] (router), LLaMA3.2:3B [63], Qwen2.5:1.5B [64], GPT-4o-mini [45], Claude-3.5-Haiku [65] SQuAD v2.0 [66] F1 GPT-4o-mini, Claude-3.5-Haiku RTX A4000 16GB, public API
InferScale Models Dataset Metric Baseline Infrastructure
LLaMA3.2:3B (local) GSM8K [24] Accuracy GPT-4o-mini RTX 4090 24GB, public API
The case studies are implemented in Python 3.10 as research prototypes1 . Experiments run on a testbed with an NVIDIA Jetson Orin Nano (8GB) and NVIDIA A4000 (16GB) for lightweight inference, and an NVIDIA RTX 4090 (24GB) for large-model serving and local LLM inference via Ollama. Each workflow component executes in a Docker container with NVIDIA runtime, ensuring reproducible resource allocation. Proprietary models are accessed through public APIs. We evaluate three dimensions. Accuracy captures domainspecific metrics (mAP@50 for detection; F1 for QA; accuracy for mathematical reasoning). Latency measures average endto-end response time. Cost estimates per-1K-request expense, combining amortized local GPU cost (Jetson Orin Nano and RTX A4000: $0.10/hr and RTX 4090: $0.40/hr [67]) with API token pricing derived from proprietary server vendors [68], [69]. Table II summarizes the experimental framework, including models, datasets, and baselines. The evaluation has two objectives: 1) to examine whether Compound AI configurations can approach monolithic accuracy while reducing latency and cost, and 2) to characterize how model selection and parameter configuration shape the accuracy-latency-cost trade-off. 1 https://github.com/polaris-slo-cloud/compound-ai
B. CODEC: Edge-Cloud Object Detection CODEC instantiates the Router and Aggregator patterns for streaming drone video. The Router dispatches frames between edge and cloud models based on offloading frequency, while the Aggregator merges their predictions through temporal IoU fusion [70]. Fig. 4 compares eight configurations, comprised of model combinations presented in Table II, across three deployment modes: cloud-only monolithic baselines that process every frame on a RTX 4090 GPU server, edge-only baselines that rely entirely on a lightweight model running on an Nvidia Jetson device, and Compound AI configurations that combine both. To isolate each pattern’s contribution, we compare CODEC configurations against both baselines. The efficiency gain over cloud-only measures the Router’s contribution, and the accuracy gain over edge-only measures the Aggregator’s contribution. The Router reduces latency and cost via selective offloading. Large monolithic baselines achieve the highest accuracy (Swin: 28.8% mAP@50) but incur high latency (161 ms) and cost ($0.018/1K frames). By offloading only selected frames, the Router enables CODEC configurations to reduce latency by up to 60% and cost by 71%. All compound configurations operate within 52–65 ms, confirming the efficiency of selective offloading. The Aggregator recovers accuracy lost by edge-only deployment. Edge-only inference is fast (45–58 ms) and cheap ($0.001–0.002/1K frames) but limited in accuracy. YOLOv8s alone reaches 21.0% mAP@50, which is 7.8 points below the Swin cloud-only baseline. The Aggregator closes most of this gap by fusing asynchronous cloud predictions with continuous edge detections through a matching algorithm. Best CODEC configuration, YOLOv8s + Swin, achieves 25.5% mAP@50, recovering 4.5 of those 7.8 points (58%) at only 7 ms additional latency over edge-only baseline. Critically, none of the monolithic baselines reach this operating point. CODEC configurations occupy a position in the accuracy-latency-cost space that monolithic deployments cannot provide. Model selection governs the magnitude of these gains. While the patterns offer potential for performance benefits, the choice of which model fills each role determines how much benefit is realized. Among Compound AI configurations, accuracy varies by 7.7 percentage points (17.8% to 25.5%). The selection of edge model has a substantial effect. YOLOv8sbased configurations outperform MobileNetV2-based ones by 4–6 percentage points regardless of cloud model. Since the
28.8 28.0 25.5
25 20 15
23.6 21.0 17.8
19.6
15.0
x in x in in x 8s 2 Sw LOv8 LOv MNv 8s+v8s+Swv2+v82+Sw v v8 N Nv YO YO M M
150
Monolithic Small
161 157
100 58
50
65 65 45
52 53
x in x in in x 8s 2 Sw LOv8 LOv MNv 8s+v8s+Swv2+v82+Sw v v8 N Nv YO YO M M
(a) Accuracy (mAP@50)
(b) Latency (ms)
Compound
Cost ($/1K frames)
30
Latency (ms)
Accuracy (mAP@50)
Monolithic Large
17.9 17.5
10 2
5.1 5.2 4.7 4.8 1.6
10 3
1.2
x in x in in x 8s 2 Sw LOv8 LOv MNv 8s+v8s+Swv2+v82+Sw v v8 N Nv YO YO M M
(c) Cost ($/1K frames)
Fig. 4: CODEC performance (accuracy, latency, and cost) compared to monolithic baselines on VisDrone dataset.
edge model processes every frame while the cloud model processes only offloaded ones, its quality dominates overall system accuracy. Takeaway. CODEC demonstrates that the Router and Aggregator patterns together provide an operating point that neither monolithic baseline can reach, combining accuracy close to the cloud model with latency close to the edge model. However, model selection determines the magnitude of these gains and plays a vital part in determining Compound AI performance.
C. QARouter: Retrieval-Augmented Question Answering QARouter composes the Retriever and Router patterns for question answering. Every incoming query first passes through retrieval, where relevant passages are fetched from a FAISS index. A trained DistilBERT classifier [62] then evaluates query difficulty given the retrieved context and dispatches to either a local LLM or a proprietary model through an API. The router is trained following prior work [12], using repeated small-model sampling on SQuADv2.0 training split, to estimate per-query difficulty and derive routing labels. Routing reduces cost at the expense of accuracy. Routing alone trades accuracy for cost reduction. The best routed configuration (GPT+Qwen) achieves 87.6 F1, 6.1 percentage points below the GPT-4o-mini monolithic baseline at 27% lower cost. This gap establishes the baseline contribution of routing in isolation and motivates the addition of retrieval. Retrieval improves accuracy across all configurations. Fig. 5(a) compares routed configurations with and without retrieval (k=5 passages). Adding retrieval improves F1 by 3.6–4.6 points across all model pairs, regardless of which proprietary model handles complex queries. GPT+Qwen with retrieval reaches 91.2 F1, within 2.5 points of the GPT-4o-mini monolithic baseline at 27% lower cost. The consistency of the retrieval gain across model pairs confirms that the Retriever’s contribution does not depend on the downstream models. Retrieval depth creates a non-linear accuracy-cost tradeoff. Fig. 5(b) shows F1 and cost as a function of k for GPT+Qwen configuration. Accuracy rises from k=0 to k=3 (+3.2 F1), plateaus between k=5 and k=10, then degrades
beyond k=10 as irrelevant passages introduce noise into the generation context. Cost, by contrast, rises linearly with k because each additional passage increases the prompt token count. At k=5, cost is 42% higher than the no-retrieval baseline; at k=20, it is 163% higher with lower accuracy than k=5. The optimal k lies in the plateau region where accuracy has saturated but cost has not yet escalated. This represents a balance that cannot be identified without empirical evaluation across the full range. Retrieval depth and routing threshold are interacting parameters. Fig. 5(c) shows that the optimal k, which maximizes accuracy, shifts with the routing threshold τ , which determines the confidence required to dispatch a query to the local model. At τ = 0.9, only queries classified as easy with high confidence by the router are processed locally. Consequently, the proprietary model handles the majority of traffic including many moderately easy queries. These queries are well-served by moderate context, and k = 5 is sufficient. At τ = 0.3, most queries are dispatched locally and only the hardest queries reach the proprietary model. Hard queries benefit from richer context, shifting the optimum to k = 15. The magnitude of retrieval’s contribution varies accordingly. At τ = 0.6, retrieval improves F1 by 6.3 points, compared to 2.3 points at τ = 0.9 and 1.9 points at τ = 0.3. Tuning k at a fixed τ , or vice versa, yields suboptimal configurations, requiring joint optimization of both parameters. Takeaway. QARouter reaches monolithic baseline at 27% lower cost, demonstrating that Compound AI can approach monolithic accuracy while improving efficiency. Retrieval depth produces a non-monotonic accuracy-cost relationship whose optimum cannot be determined by intuition alone. When the multiple patterns compose, the optimal retrieval depth shifts with the routing threshold, making independent parameter tuning insufficient and joint optimization necessary.
D. InferScale: Test-Time Compute Scaling InferScale instantiates the Sampler pattern for mathematical reasoning on GSM8K. The system generates N candidate answers from LLaMA 3.2:3B using repeated sampling at 0.7
88.9
85
87.4 85.8
84.3
83.1
90
0.05
88
80 75 GPT+L
(a) Retrieval ablation (F1)
85
0.04 0.03
86 0
LaMAGPT+QweCn l+LLaMA Cl+Qwen
= 0.3
90
0.06
89.5
87.6
= 0.6
0.07
91.2
F1 (%)
Cl-3.5-Haiku
= 0.9
Cost ($)
92
GPT-4o-mini
90
F1 (%)
F1 (%)
Cost ($)
95
With RAG (k=5)
F1 (%)
Without RAG
5
10
15
Retrieval depth (k)
20
80 0
5
10
15
Retrieval depth (k)
20
(c) Threshold × depth
(b) Retrieval depth vs. cost
Fig. 5: QARouter performance on SQuAD dataset. (a) Retrieval effect on F1. (b) F1 & cost as a function of retrieval depth. (c) Parameter coupling effect on F1.
Accuracy (%)
temperature and selects the final response through majority voting. The sample count N is the primary configuration parameter. Repeated sampling closes the accuracy gap to a larger model at lower cost. Figure 6 plots each configuration in the accuracy-latency plane (a) and the accuracy-cost plane (b). Increasing N moves the operating point along the planes. At N =4, the system reaches 80% accuracy, within 4 percentage points of the GPT-4o-mini baseline, while reducing cost by 43% and latency by 41%. This configuration demonstrates that the Sampler pattern can approach monolithic accuracy at substantially lower operational cost by allocating inference-time compute within a smaller local model rather than delegating to a larger one. At N =8, accuracy matches the GPT-4o-mini baseline at 84%, confirming that the pattern can reach the monolithic ceiling when accuracy is the binding constraint.
85 80 N=2
LLaMA-3.2:3B
GPT-4o-mini
N=8 N=16
N=8
GPT-4o-mini N=4
N=2
N=16 GPT-4o-mini
N=4
75 70
N=1
0
N=1
5
10
Latency (s)
15
(a) Accuracy vs. latency
0.0
0.2
0.4
Cost ($/1K queries) (b) Accuracy vs. cost
Fig. 6: InferScale performance on GSM8K. Accuracy degrades beyond the optimal sample count. At N =16, accuracy drops to 83% while latency doubles to 16.5 s and cost rises to $0.458 per 1K queries. Frequent but incorrect answers begin to dominate the majority vote. This configuration is strictly dominated by N =8, which achieves higher accuracy at half the latency and cost. Additional compute, therefore, does not unconditionally improve quality, and the optimal N must be determined empirically.
Takeaway. The Sampler pattern offers a potential for a smaller model to approach monolithic accuracy through repeated sampling and majority voting. The accuracy-efficiency relationship is non-linear. Beyond optimal sample size, additional samples degrade both accuracy and efficiency.
E. Discussion TABLE III: Compound vs. monolithic baselines. Values show relative change; negative latency and cost indicate savings. Case Study
Pattern
CODEC QARouter InferScale
Router+Agg. Router+Retriever Sampler
Accuracy
Latency
Cost
−3.3 pp −2.5 pp −4 pp
−60% −21% -41%
−71% −27% −43%
Table III summarizes Compound AI performance relative to monolithic baselines across the three case studies. These results establish four findings about Compound AI design trade-offs. Compound AI approaches monolithic accuracy while reducing latency and cost, opening operating points monolithic deployments cannot provide. Section II showed that each model in Fig. 1 occupies a single fixed point in the accuracy-latency-cost space, with no mechanism to trade one objective against another at runtime. The case studies break this property. CODEC achieves 25.5% mAP@50 at 65 ms, which no cloud or edge model alone reaches, since cloud models require 157–161 ms and edge models peak at 21.0%. QARouter and InferScale likewise come within 2.5 and 4 percentage points of their monolithic baselines at lower cost, each occupying a position that Fig. 1 shows is inaccessible to monolithic deployment. Model selection determines the magnitude of Compound AI gains. While the design patterns create structural potential for trade-off management, the choice of which model fills each role determines how much of that potential is realized. In CODEC, edge model selection has the highest impact on the overall accuracy because the edge model processes
every frame, while the cloud model processes only the offloaded fraction. YOLOv8s-based configurations outperform MobileNetV2-based ones by 4–6 percentage points regardless of utilized cloud model. In QARouter, the choice of local and proprietary model pair shifts F1 score by up to 4.5 percentage points across configurations. Parameter configuration shapes the trade-off space nonlinearly. Within a fixed model assignment, parameter values determine where the system operates in the accuracy-latencycost space. However, the relationship between parameters and system objectives is non-monotonic. In InferScale, increasing the sample count from N = 1 to N = 8 improves accuracy from 72% to 84%, but further increasing to N = 16 degrades accuracy to 83% while doubling latency and cost. Additional inference-time compute does not unconditionally improve quality. In QARouter, retrieval depth beyond k = 10 degrades accuracy as irrelevant passages introduce noise into the generation context, while cost continues to rise linearly with k. In both cases, the optimal parameter value lies in a region that cannot be identified by intuition alone and must be determined empirically. Model selection and parameter configuration interact across composed patterns. The case studies show that these configuration choices are interdependent. In QARouter, the routing threshold determines which model handles which queries. As a consequence, it affects how much each model’s quality contributes to overall F1, and what retrieval depth is optimal, as more capable models typically require less context size. This means that Compound AI trade-offs cannot be managed by optimizing each configuration choice in isolation. As systems compose more patterns, these interactions multiply, making manual configuration increasingly unreliable. V. R ESEARCH ROADMAP The case studies demonstrate that Compound AI configurations can achieve operating points unattainable by monolithic deployments. However, every configuration evaluated in Section IV was discovered through systematic but tedious, time-consuming and costly manual experimentation. We argue that the long-term goal for Compound AI systems is enabling automatic identification of optimal configurations while maintaining SLO compliance as production conditions change. We identify five key future research challenges (RC) that should be addressed in pursuit of this goal. RC-1: Automatic Design Space Exploration. A Compound AI workflow exposes many design choices, including model selection for each inference task, the algorithms and tools assigned to each workflow stage, and parameters that govern runtime behavior. Even workflows modest in size can produce thousands of candidate configurations. Gradient-based optimization cannot navigate this space because the workflows are non-differentiable. Components are heterogeneous and many choices are discrete or categorical, such as routing decisions or model assignments. Black-box methods offer an alternative, but the space is not decomposable. As Section IV demonstrated, parameters interact across composed patterns,
meaning that each candidate configuration must be evaluated jointly through a full end-to-end workflow execution. This makes evaluation expensive and rules out independent percomponent tuning. How can such configuration space be searched efficiently when both gradient-based and decomposed search strategies are inapplicable, is an open research challenge. RC-2: Dynamic Runtime Adaptation. The configurations evaluated in Section IV were static, optimized offline for a fixed dataset and infrastructure. However, production conditions change. For instance, query distributions can shift, model APIs update pricing or deprecate versions, and hardware load fluctuates with demand. Under any of these shifts, a previously optimal configuration can drift outside the SLO-compliant trade-off space. Restoring compliance may require adjustments at different granularities, such as tuning parameter values, runtime model selection and switching, or restructuring the workflow topology. We envision novel adaptation mechanisms that can dynamically adjust system configuration to restore and maintain SLO compliance as conditions change. RC-3: Novel Programming Abstractions. Runtime adaptation requires reassigning models to inference tasks without disrupting workflow execution, but models performing the same task often differ in interfaces, output formats, and invocation protocols. Current Compound AI frameworks bind each inference task to a specific model, so reassigning a model at runtime risks breaking downstream workflow steps that depend on the previous model’s output format. Novel programming abstractions are needed that decouple inference tasks from the models assigned to them, providing stable interfaces so that model reassignment does not disrupt workflow execution. RC-4: Serverless Compound AI Systems. The adaptation mechanisms above require that runtime model selection is cheap, but conventional deployment ties models to GPU memory and serving infrastructure, making switching expensive. A FaaS execution model with scale-to-zero capabilities eliminates the need to keep candidate models pre-loaded in memory, making model switching a lightweight operation rather than an infrastructure-level disruption. However, Compound AI workflows are multi-stage pipelines, and executing them as compositions of stateless functions raises open problems in intermediate state management, inter-stage communication, and scheduling that respects end-to-end workflow latency rather than optimizing individual invocations. RC-5: Quality Attribution in Compound AI Workflows. When overall task accuracy degrades in a Compound AI workflow, the root cause may lie in any upstream model or component. Consequently, the error propagates through the workflow in ways that infrastructure-level metrics, such as cost or request latency, cannot reveal. The adaptation mechanisms from RC-2 require knowledge about which component to adjust, yet pinpointing where in the workflow the quality degradation originates remains an open problem. Estimating per-component accuracy contribution in a non-differentiable system is challenging given that components interact nonlinearly, errors compound across stages, and there is no
gradient signal to trace quality loss back to its source. Solving the quality attribution problem is one of the main enablers for the adaptation mechanisms envisioned in RC-2. These five challenges define the research roadmap from manually configured Compound AI prototypes towards systems that can automatically discover and maintain configurations that satisfy SLO constraints. RC-1 concerns finding good configurations offline. RC-2 through RC-5 concern keeping the system within its SLO-compliant operating region once deployed. We consider that advancing Compound AI to production scale requires progress across all five directions. VI. R ELATED W ORK Our work intersects three lines of research: AI paradigms that compose multiple components, prior work on Compound AI systems, and distributed systems whose architectural principles we build upon but whose trade-off space we redefine around task performance. A. Related AI Paradigms 1) Agentic AI: Agentic AI refers to systems in which LLM-driven agents autonomously decide which actions to take, which tools to invoke, and in what sequence [71], [72]. Foundational work such as ReAct [73] demonstrated that interleaving reasoning traces with tool-calling actions enables LLMs to solve multi-step tasks without a predefined execution plan. Multi-agent extensions coordinate several such agents through communication protocols or shared state [74], and recent position papers argue that understanding these systems requires a systems-theoretic perspective that accounts for emergent behavior arising from agent interactions [75]. Key distinction between agentic and Compound AI lies in workflow control. In agentic systems, the workflow is implicit: it emerges at runtime from the agent’s reasoning and planning [73]. In Compound AI, the workflow is explicit: practitioner specifies which component process which inputs, in what order, and under what conditions. Explicit workflow structure exposes a bounded design space in which the effect of each decision on system objectives can be optimized. 2) Modular AI: Modular AI architectures compose specialized sub-networks into task-specific computation graphs. Mixture-of-experts models [76] route inputs to specialized sub-networks within a single model, while modular deep learning [77] assembles independently trained modules. These systems are trained end-to-end via backpropagation because all components are differentiable. Compound AI systems break this assumption. Due to heterogeneity of building blocks and design patterns in Compound AI, these systems are non-differentiable [78], which prevents gradient-based joint optimization. Recent work addresses this through surrogate methods, such as approximate gradients [19], [79], system-level preference optimization [80], and local reward functions aligned with global performance [20]. Our work is complementary. We provide the architectural abstractions that define the design space over which such methods operate.
B. Classical Distributed Systems Compound AI systems are distributed systems. They coordinate heterogeneous components across tasks, deployments, and network boundaries. Classical distributed systems research provides foundational principles for service composition, fault tolerance, and scheduling [81], [82] that Compound AI systems inherit. However, classical distributed systems optimize for infrastructure-level objectives, such as throughput, availability, and resource utilization. Compound AI systems introduce task performance (e.g., accuracy) as a first-class system objective that interacts with infrastructure objectives in that classical systems do not exhibit. A routing decision in a load balancer optimizes latency or throughput, while a routing decision in a Compound AI system trades accuracy against cost, as different models produce outputs of different quality for the same input. Our design methodology operates at this boundary, presenting Compound AI design as workflow topology and configuration selection, making the trade-offs between task performance and operational efficiency manageable. VII. C ONCLUSION We presented a design methodology for Compound AI systems. Methodology is organized through workflow topology design, captured through eight design patterns that each address a specific limitation of monolithic deployment and configuration selection, which assigns models to inference tasks within the workflow and configures parameters that govern runtime behavior. These dimensions define a structured design space for building AI systems to meet service-level objectives that no monolithic model can satisfy independently. Three case studies across vision and language domains demonstrate that Compound AI systems can approach monolithic baselines in task performance while improving efficiency. CODEC reaches within 3.3 percentage points of the monolithic baseline for object detection while reducing latency by 60% and cost by 71%. QARouter matches 97% of monolithic accuracy at 27% lower cost. InferScale enables a 3B-parameter model to match GPT-4o-mini on mathematical reasoning through repeated sampling. Across the studies, model selection dominates system-level performance and configuration parameters interact non-linearly, requiring joint optimization. These findings are based on manual experimentation over research-scale testbeds with established benchmarks. Future work will focus on addressing research challenges outlined in Section V to advance from manual prototyping towards Compound AI systems that automatically discover and maintain SLO-compliant configurations in production environments. ACKNOWLEDGMENT This work was partly funded by the European Union under the Horizon Europe programme through the SNS JU (Grant Agreement No. 101192912, NexaSphere). Views expressed are those of the authors and do not necessarily reflect those of the EU or the SNS JU.
R EFERENCES [1] R. Bommasani, D. A. Hudson, E. Adeli, R. Altman, S. Arber, S. von Arx, M. S. Bernstein, J. Bohg, A. Bosselut, E. Brunskill et al., “On the opportunities and risks of foundation models,” arXiv preprint arXiv:2108.07258, 2022. [2] A. Vaswani, N. Shazeer, N. Parmar, J. Uszkoreit, L. Jones, A. N. Gomez, Ł. Kaiser, and I. Polosukhin, “Attention is all you need,” Advances in Neural Information Processing Systems, vol. 30, 2017. [3] T. Brown, B. Mann, N. Ryder, M. Subbiah, J. D. Kaplan, P. Dhariwal, A. Neelakantan, P. Shyam, G. Sastry, A. Askell et al., “Language models are few-shot learners,” Advances in Neural Information Processing Systems, vol. 33, pp. 1877–1901, 2020. [4] J. Hoffmann, S. Borgeaud, A. Mensch, E. Buchatskaya, T. Cai, E. Rutherford, D. de Las Casas, L. A. Hendricks, J. Welbl, A. Clark et al., “Training compute-optimal large language models,” Advances in Neural Information Processing Systems, vol. 35, pp. 30 016–30 030, 2022. [5] X. Miao, G. Oliaro, Z. Zhang, X. Cheng, Z. Wang, Z. Zhang, R. Y. Y. Wong, A. Zhu, L. Yang, X. Shi et al., “Efficient LLM serving: A survey,” arXiv preprint arXiv:2312.15234, 2025. [6] M. Golec et al., “Reconciling predictability and efficiency in the management of AI serving systems,” in IEEE International Conference on Web Services, 2023. [7] M. Zaharia, O. Khattab, L. Chen, J. Q. Davis, H. Miller, C. Potts, J. Zou, M. Carbin, J. Frankle, N. Rao, and A. Ghodsi, “The shift from models to compound AI systems,” Berkeley AI Research Blog, 2024. [8] J. Kaplan, S. McCandlish, T. Henighan, T. B. Brown, B. Chess, R. Child, S. Gray, A. Radford, J. Wu, and D. Amodei, “Scaling laws for neural language models,” arXiv preprint arXiv:2001.08361, 2020. [9] E. M. Bender, T. Gebru, A. McMillan-Major, and S. Shmitchell, “On the dangers of stochastic parrots: Can language models be too big?” in Proceedings of the 2021 ACM Conference on Fairness, Accountability, and Transparency, ser. FAccT ’21. New York, NY, USA: Association for Computing Machinery, 2021, p. 610–623. [Online]. Available: https://doi.org/10.1145/3442188.3445922 [10] A. Srivastava et al., “Beyond the imitation game: Quantifying and extrapolating the capabilities of language models,” 2023. [Online]. Available: https://arxiv.org/abs/2206.04615 [11] L. Chen, M. Zaharia, and J. Zou, “FrugalGPT: How to use large language models while reducing cost and improving performance,” arXiv preprint arXiv:2305.05176, 2023. [12] D. Ding, A. Mallick, C. Wang, R. Sim, S. Mukherjee, V. Ruhle, L. V. S. Lakshmanan, and A. H. Awadallah, “Hybrid llm: Cost-efficient and quality-aware query routing,” arXiv preprint arXiv:2404.14618, 2024. [13] T. Schick, J. Dwivedi-Yu, R. Dessı̀, R. Raileanu, M. Lomeli, E. Hambro, L. Zettlemoyer, N. Cancedda, and T. Scialom, “Toolformer: Language models can teach themselves to use tools,” Advances in Neural Information Processing Systems, vol. 36, 2023. [14] B. Cottier, R. Rahman, L. Fattorini, N. Maslej, T. Besiroglu, and D. Owen, “The rising costs of training frontier ai models,” 2025. [Online]. Available: https://arxiv.org/abs/2405.21015 [15] S. Kapoor, B. Stroebl, Z. S. Siber, N. Koppel, and A. Narayanan, “AI agents that matter,” arXiv preprint arXiv:2407.01502, 2024. [16] L. Chen, J. Q. Davis, B. Hanin, P. Bailis, M. Zaharia, J. Zou, and I. Stoica, “Optimizing model selection for compound AI systems,” arXiv preprint arXiv:2502.14815, 2025. [17] P. Lewis, E. Perez, A. Piktus, F. Petroni, V. Karpukhin, N. Goyal, H. Küttler, M. Lewis, W.-t. Yih, T. Rocktäschel et al., “Retrievalaugmented generation for knowledge-intensive NLP tasks,” Advances in Neural Information Processing Systems, vol. 33, pp. 9459–9474, 2020. [18] X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou, “Self-consistency improves chain of thought reasoning in language models,” arXiv preprint arXiv:2203.11171, 2023. [19] M. Gravara, J. L. Herrera, and S. Nastic, “Compass: Optimizing compound ai workflows for runtime adaptation,” in Proceedings of the IEEE International Symposium on Cluster, Cloud and Internet Computing (CCGrid), 2026. [20] S. Wu, P. Sarthi, S. Zhao, A. Lee, H. Shandilya, A. M. Grobelnik, N. Choudhary, E. Huang, K. Subbian, L. Zhang, D. Yang, J. Zou, and J. Leskovec, “Optimas: Optimizing compound ai systems with globally aligned local rewards,” 2025. [Online]. Available: https://arxiv.org/abs/2507.03041
[21] W. Kwon, Z. Li, S. Zhuang, Y. Sheng, L. Zheng, C. H. Yu, J. Gonzalez, H. Zhang, and I. Stoica, “Efficient memory management for large language model serving with PagedAttention,” in ACM Symposium on Operating Systems Principles, 2023. [22] G.-I. Yu, J. S. Jeong, G.-W. Kim, S. Kim, and B.-G. Chun, “Orca: A distributed serving system for transformer-based generative models,” in USENIX Symposium on Operating Systems Design and Implementation, 2022. [23] X. Miao, G. Oliaro, Z. Zhang, X. Cheng, Z. Wang, R. Y. Y. Wong et al., “Towards efficient generative large language model serving: A survey from algorithms to systems,” arXiv preprint arXiv:2312.15234, 2024. [24] K. Cobbe, V. Kosaraju, M. Bavarian, M. Chen, H. Jun, L. Kaiser, M. Plappert, J. Tworek, J. Hilton, R. Nakano, C. Hesse, and J. Schulman, “Training verifiers to solve math word problems,” arXiv preprint arXiv:2110.14168, 2021. [25] D. Jiang, X. Ren, and B. Y. Lin, “LLM-Blender: Ensembling large language models with pairwise ranking and generative fusion,” arXiv preprint arXiv:2306.02561, 2023. [26] I. Ong, A. Almahairi, V. Wu, W.-L. Chiang, T. Wu, J. E. Gonzalez, M. W. Kadous, and I. Stoica, “RouteLLM: Learning to route LLMs with preference data,” arXiv preprint arXiv:2406.18665, 2024. [27] P. Patidar, A. Crown, K. Hsieh, Y. Xu, T. Chakraborty, R. Chandra, and Y. Agarwal, “Orchestration for domain-specific edge-cloud language models,” arXiv preprint arXiv:2507.09003, 2025. [28] M. Khani, P. Hamadanian, A. Nasr-Esfahany, and M. Alizadeh, “Realtime video inference on edge devices via adaptive model streaming,” in Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2021, pp. 4572–4582. [29] Z. Cao, Z. Li, P. Heng, Y. Chen, D. Xie, and J. Liu, “Edge-cloud collaborated object detection via difficult-case discriminator,” 2021. [Online]. Available: https://arxiv.org/abs/2108.12858 [30] M. Maresch and S. Nastic, “Vate: Edge-cloud system for object detection in real-time video streams,” in 2024 IEEE 8th International Conference on Fog and Edge Computing (ICFEC), 2024, pp. 27–34. [31] H. Narasimhan, W. Jitkrittum, A. S. Rawat, S. Kim, N. Gupta, A. K. Menon, and S. Kumar, “Faster cascades via speculative decoding,” arXiv preprint arXiv:2405.19261, 2024. [32] P. Aggarwal, A. Madaan, A. Anand, S. P. Potharaju, S. Mishra, P. Zhou, A. Gupta, D. Rajagopal, K. Kappaganthu, Y. Yang, S. Upadhyay, M. Faruqui, and Mausam, “AutoMix: Automatically mixing language models,” in Advances in Neural Information Processing Systems (NeurIPS), 2024. [33] P. Viola and M. Jones, “Rapid object detection using a boosted cascade of simple features,” in Proceedings of the IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR), vol. 1, 2001, pp. I–511–I–518. [34] K. Zhang, Z. Zhang, Z. Li, and Y. Qiao, “Joint face detection and alignment using multitask cascaded convolutional networks,” IEEE Signal Processing Letters, vol. 23, no. 10, pp. 1499–1503, 2016. [35] S. Teerapittayanon, B. McDanel, and H. T. Kung, “BranchyNet: Fast inference via early exiting from deep neural networks,” in Proceedings of the International Conference on Pattern Recognition (ICPR), 2016. [36] J. Q. Davis, B. Hanin, L. Chen, P. Bailis, I. Stoica, and M. Zaharia, “Networks of networks: Complexity class principles applied to compound AI systems design,” arXiv preprint arXiv:2407.01476, 2024. [37] Y. Li, D. Choi, J. Chung, N. Kushman, J. Schrittwieser, R. Leblond, T. Eccles, J. Keeling, F. Gimeno, A. Dal Lago, T. Hubert, P. Choy, C. de Masson d’Autume, I. Babuschkin, X. Chen, P.-S. Huang, J. Welbl, S. Gowal, A. Cherepanov, J. Molloy, D. J. Mankowitz, E. S. Robson, P. Kohli, N. de Freitas, K. Kavukcuoglu, and O. Vinyals, “Competitionlevel code generation with AlphaCode,” Science, vol. 378, no. 6624, pp. 1092–1097, 2022. [38] C. Snell, J. Lee, K. Xu, and A. Kumar, “Scaling LLM test-time compute optimally can be more effective than scaling model parameters,” 2024. [39] V. Balachandran, J. Chen, L. Chen, S. Garg, N. Joshi, Y. Lara, J. Langford, B. Nushi, V. Vineet, Y. Wu, and S. Yousefi, “Inference-time scaling for complex tasks: Where we stand and what lies ahead,” arXiv preprint arXiv:2504.00294, 2025. [40] Y. Du, S. Li, A. Torralba, J. B. Tenenbaum, and I. Mordatch, “Improving factuality and reasoning in language models through multiagent debate,” in Proceedings of the International Conference on Machine Learning (ICML), 2024.
[41] L. Chen, J. Q. Davis, B. Hanin, P. Bailis, I. Stoica, M. Zaharia, and J. Zou, “Are more LLM calls all you need? Towards scaling laws of compound inference systems,” arXiv preprint arXiv:2403.02419, 2024. [42] K. Guu, K. Lee, Z. Tung, P. Pasupat, and M.-W. Chang, “REALM: Retrieval-augmented language model pre-training,” in Proceedings of the International Conference on Machine Learning (ICML), 2020. [43] X. Ren, L. Xu, L. Xia, S. Wang, D. Yin, and C. Huang, “Videorag: Retrieval-augmented generation with extreme long-context videos,” arXiv preprint arXiv:2502.01549, 2025. [44] X. Zhao, S. Liu, S.-Y. Yang, and C. Miao, “Medrag: Enhancing retrieval-augmented generation with knowledge graph-elicited reasoning for healthcare copilot,” in Proceedings of the ACM Web Conference, 2025, pp. 4442–4457. [45] OpenAI, “Gpt-4 technical report,” 2024. [Online]. Available: https://arxiv.org/abs/2303.08774 [46] Anthropic, “Introducing the Model Context Protocol,” https://www.anthropic.com/news/model-context-protocol, Nov. 2024, open standard; specification at https://modelcontextprotocol.io. [47] C.-M. Chan, W. Chen, Y. Su, J. Yu, W. Xue, S. Zhang, J. Fu, and Z. Liu, “Chateval: Towards better llm-based evaluators through multiagent debate,” arXiv preprint arXiv:2308.07201, 2023. [48] R. Solovyev, W. Wang, and T. Gabruseva, “Weighted boxes fusion: Ensembling boxes from different object detection models,” Image and Vision Computing, vol. 107, p. 104117, 2021. [49] L. Breiman, “Random forests,” Machine Learning, vol. 45, no. 1, pp. 5–32, 2001. [50] A. Ni, S. Iyer, D. Radev, V. Stoyanov, W.-t. Yih, S. I. Wang, and X. V. Lin, “LEVER: Learning to verify language-to-code generation with execution,” in Proceedings of the International Conference on Machine Learning (ICML), 2023. [51] A. Madaan, N. Tandon, P. Gupta, S. Hallinan, L. Gao, S. Wiegreffe, U. Alon, N. Dziri, S. Prabhumoye, Y. Yang, S. Gupta, B. P. Majumder, K. Hermann, S. Welleck, A. Yazdanbakhsh, and P. Clark, “Self-refine: Iterative refinement with self-feedback,” in Advances in Neural Information Processing Systems (NeurIPS), 2023. [52] T. Ridnik, D. Kredo, and I. Friedman, “Code generation with AlphaCodium: From prompt engineering to flow engineering,” 2024. [53] T. Rebedea, R. Dinu, M. Sreedhar, C. Parisien, and J. Cohen, “NeMo Guardrails: A toolkit for controllable and safe LLM applications with programmable rails,” in Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing: System Demonstrations (EMNLP Demo), 2023. [54] H. Inan, K. Upasani, J. Chi, R. Rungta, K. Iyer, Y. Mao, M. Tontchev, Q. Hu, B. Fuller, D. Testuggine, and M. Khabsa, “Llama Guard: LLMbased input-output safeguard for human-AI conversations,” 2023. [55] S. Han, Z. Hu, A. D. Shah, H. Jin, Y. Yao, D. Stripelis, Z. Xu, and C. He, “Torchopera: A compound ai system for llm safety,” arXiv preprint arXiv:2406.10847, 2024. [56] Z. Chen, F. Pinto, M. Pan, and B. Li, “SafeWatch: An efficient safetypolicy following video guardrail model with transparent explanations,” in International Conference on Learning Representations (ICLR), 2025. [57] G. Jocher, A. Chaurasia, and J. Qiu, “Ultralytics YOLOv8,” https://github.com/ultralytics/ultralytics, 2023. [58] M. Sandler, A. Howard, M. Zhu, A. Zhmoginov, and L.-C. Chen, “MobileNetV2: Inverted residuals and linear bottlenecks,” in Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR), 2018, pp. 4510–4520. [59] W. Liu, D. Anguelov, D. Erhan, C. Szegedy, S. Reed, C.-Y. Fu, and A. C. Berg, “SSD: Single shot multibox detector,” Lecture Notes in Computer Science, vol. 9905, pp. 21–37, 2016. [60] Z. Liu, Y. Lin, Y. Cao, H. Hu, Y. Wei, Z. Zhang, S. Lin, and B. Guo, “Swin Transformer: Hierarchical vision transformer using shifted windows,” in Proceedings of the IEEE/CVF International Conference on Computer Vision (ICCV), 2021, pp. 10 012–10 022. [61] P. Zhu, L. Wen, D. Du, X. Bian, H. Fan, Q. Hu, and H. Ling, “Detection and tracking meet drones challenge,” IEEE Transactions on Pattern Analysis and Machine Intelligence, vol. 44, no. 11, pp. 7380–7399, 2021. [62] V. Sanh, L. Debut, J. Chaumond, and T. Wolf, “Distilbert, a distilled version of bert: smaller, faster, cheaper and lighter,” 2020. [Online]. Available: https://arxiv.org/abs/1910.01108 [63] A. Grattafiori, A. Dubey, A. Jauhri, A. Pandey, A. Kadian, A. Al-Dahle, A. Letman, A. Mathur, A. Schelten, A. Yang et al., “The Llama 3 herd of models,” arXiv preprint arXiv:2407.21783, 2024.
[64] J. Bai, S. Bai, Y. Chu, Z. Cui, K. Dang, X. Deng, Y. Fan, W. Ge, Y. Han, F. Huang, B. Hui, L. Ji, M. Li, J. Lin, R. Lin, D. Liu, G. Liu, C. Lu, K. Lu, J. Ma, R. Men, X. Ren, X. Ren, C. Tan, S. Tan, J. Tu, P. Wang, S. Wang, W. Wang, S. Wu, B. Xu, J. Xu, A. Yang, H. Yang, J. Yang, S. Yang, Y. Yao, B. Yu, H. Yuan, Z. Yuan, J. Zhang, X. Zhang, Y. Zhang, Z. Zhang, C. Zhou, J. Zhou, X. Zhou, and T. Zhu, “Qwen technical report,” 2023. [Online]. Available: https://arxiv.org/abs/2309.16609 [65] Anthropic, “Claude 3 haiku,” 2024, large language model. [Online]. Available: https://www.anthropic.com [66] P. Rajpurkar, R. Jia, and P. Liang, “Know what you don’t know: Unanswerable questions for squad,” in Proceedings of the 56th Annual Meeting of the Association for Computational Linguistics (ACL), 2018. [67] Runpod, “Runpod pricing,” https://www.runpod.io/pricing, 2026, gPU and serverless compute pricing with per-second billing for Runpod pods and workers (retrieved 2026). [Online]. Available: https://www.runpod.io/pricing [68] OpenAI, “Openai api pricing,” https://openai.com/api/pricing/, 2026, billing rates per million input, cached input, and output tokens for OpenAI models (retrieved 2026). [Online]. Available: https://openai.com/api/pricing/ [69] Anthropic, “Anthropic claude api pricing,” https://docs.anthropic.com/en/docs/about-claude/pricing, 2026, detailed per-model pricing for Claude models showing input, cache, and output token costs (retrieved 2026). [Online]. Available: https://docs.anthropic.com/en/docs/about-claude/pricing [70] H. W. Kuhn, “The hungarian method for the assignment problem,” Naval Research Logistics Quarterly, vol. 2, no. 1–2, p. 83–97, 1955. [71] D. B. Acharya, K. Kuppan, and B. Divya, “Agentic AI: Autonomous intelligence for complex goals—a comprehensive survey,” IEEE Access, vol. 13, pp. 18 912–18 936, 2025. [72] J. Schneider, “Generative to agentic AI: Survey, conceptualization, and challenges,” arXiv preprint arXiv:2504.18875, 2025. [73] S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao, “ReAct: Synergizing reasoning and acting in language models,” in International Conference on Learning Representations, 2023. [74] T. Guo, X. Chen, Y. Wang, R. Chang, S. Pei, N. V. Chawla, O. Wiest, and X. Zhang, “Large language model based multi-agents: A survey of progress and challenges,” in International Joint Conference on Artificial Intelligence, 2024, pp. 8048–8057. [75] E. Miehling, K. N. Ramamurthy, K. R. Varshney, M. Riemer, D. Bouneffouf, J. T. Richards, A. Dhurandhar, E. M. Daly, M. Hind, P. Sattigeri, D. Wei, A. Rawat, J. Gajcin, and W. Geyer, “Agentic AI needs a systems theory,” arXiv preprint arXiv:2503.00237, 2025. [76] N. Shazeer, A. Mirhoseini, K. Maziarz, A. Davis, Q. Le, G. Hinton, and J. Dean, “Outrageously large neural networks: The sparsely-gated mixture-of-experts layer,” arXiv preprint arXiv:1701.06538, 2017. [77] J. Pfeiffer, S. Ruder, I. Vulić, and E. M. Ponti, “Modular deep learning,” arXiv preprint arXiv:2302.11529, 2024. [78] L. Chen, J. Q. Davis, B. Hanin, P. Bailis, M. Zaharia, J. Zou, and I. Stoica, “Optimizing model selection for compound ai systems,” arXiv preprint arXiv:2502.14815, 2025. [79] M. Yuksekgonul, F. Bianchi, J. Boen, S. Liu, Z. Huang, C. Guestrin, and J. Zou, “Textgrad: Automatic ”differentiation” via text,” 2024. [Online]. Available: https://arxiv.org/abs/2406.07496 [80] X. Wang, Y. J. Zhang, Z. Ding, K. Tsai, H. Wu, and S. Koyejo, “Aligning compound AI systems via system-level DPO,” arXiv preprint arXiv:2502.11559, 2025. [81] J. Dean and S. Ghemawat, “MapReduce: Simplified data processing on large clusters,” Communications of the ACM, vol. 51, no. 1, pp. 107–113, 2008. [82] S. Newman, Building Microservices: Designing Fine-Grained Systems, 2nd ed. O’Reilly Media, 2021.