Activity-Based Costing Framework for Total Cost of Ownership Analysis of LLM Services

You’re listening to “Activity-Based Costing Framework for Total Cost of Ownership Analysis of LLM Services,” by P. Tombor and J. Abonyi. Published in 2026.

Abstract.

The proliferation of Large Language Models (LLMs) requires robust financial planning, yet traditional software cost models cannot capture the unique economics of generative AI. This paper presents a formal Total Cost of Ownership (TCO) framework grounded in Activity-Based Costing (ABC). We deliver a dual-layered accounting architecture: a mathematically tractable, provably convex engine for technical infrastructure costs, alongside a comprehensive, modular taxonomy blueprint for human operational, governance, and organizational cost pools. The framework systematically incorporates LLM-specific cost drivers, including token consumption, Retrieval-Augmented Generation (RAG) operations, and agentic inference steps.

To demonstrate practical applicability, the framework is subjected to a multi-faceted empirical validation programme: the technical infrastructure submodel is validated on a 12-month production RAG chatbot deployment, yielding a predictive formula that links high-level business metrics directly to infrastructure expenses with sub-5% forecasting error, and is further exercised on a second institutional deployment through a synthetically augmented dataset of 95,150 user sessions. Complementary cross-case scenario simulations—spanning regulated, high-scale API, and autonomous agentic regimes—together with hybrid local–cloud serving and retrieval-versus-fine-tuning comparisons, illustrate the framework’s structural generalizability across distinct governance, throughput, and multi-step execution regimes.

By integrating time-varying vendor prices, stochastic uncertainty, and hybrid deployment extensions, this work provides a rigorous, transparent decision-support tool for the strategic financial management of LLM-based services.

Introduction.

The emergence of Large Language Models (LLMs) has precipitated a transformative shift across diverse sectors, with organizations rapidly adopting these technologies for applications ranging from automated customer service and intelligent document processing to code genera-tion. However, this widespread adoption has revealed a critical gap in financial planning and cost management frame-works, as traditional software cost estimation approaches prove inadequate for the unique economic characteristics of LLM-based services.

The associate editor coordinating the review of this manuscript and approving it for publication was Mohamed M. A. Moustafa.

Traditional software cost estimation models, such as COCOMO II and Function Point Analysis, were designed for conventional software development paradigms and fail to capture the distinctive cost drivers inherent in LLM services. These models cannot account for token-based pricing structures, where costs scale directly with input and output volume, nor do they address the computa-tional complexity of semantic processing operations such as embedding generation, vector similarity searches, and retrieval-augmented generation (RAG) workflows. Further-more, the dynamic nature of LLM service consumption, characterized by highly variable workloads and pay-per-use pricing models, creates cost patterns that differ fundamen-tally from traditional software licensing and infrastructure costs.

Current approaches to LLM cost management remain fragmented and insufficient for comprehensive financial planning. Existing research has focused primarily on iso-lated aspects such as inference optimization, model compression for cost reduction, and energy efficiency improvements. While valuable, these works do not provide systematic frameworks for Total Cost of Ownership (TCO) analysis that encompass the entire LLM service lifecycle, from development and deployment to ongoing operations and maintenance.

Activity-Based Costing (ABC) methodologies, originally developed for manufacturing environments, have proven highly effective in complex service contexts where traditional cost accounting fails to capture resource consumption patterns accurately. The evolution to Time-Driven ABC (TDABC) further enhanced the methodology’s applicability to service industries by enabling more granular activity analysis and resource allocation. Recent applications of ABC in cloud computing environments and IT service operations demonstrate the methodology’s adaptability to technology-intensive domains.

The inherent granularity of ABC frameworks makes them particularly suitable for LLM cost modeling, where diverse resource types—including GPU compute hours, token processing, storage, and specialized operations like vector database queries—must be accurately mapped to specific activities throughout the service lifecycle.

Despite the proven effectiveness of ABC methodologies in analogous domains, their systematic application to LLM services remains largely unexplored. This gap is particularly critical given the rapid expansion of LLM adoption in enter-prise environments, where accurate cost forecasting and bud-get allocation are essential for strategic decision-making. Organizations require robust, transparent methodologies to evaluate the financial implications of LLM integration, compare alternative architectural approaches, and optimize resource allocation across the LLMOps pipeline.

This research addresses these critical gaps by developing and validating a comprehensive Activity-Based Costing framework specifically designed for Total Cost of Ownership analysis of LLM services. Our approach systematically decomposes LLM service costs across the entire operational lifecycle, from initial data preparation and model integration through ongoing inference, maintenance, governance, and incident handling activities. The framework incorporates LLM-specific cost drivers, including token consumption patterns, embedding generation workflows, vector database operations, and retrieval-augmented generation processes, while also explicitly modeling personnel-driven review, compliance overhead, organizational adoption effort, and expected model-failure-related losses,,. Mathematical rigor is maintained through a formal cost model and convexity analysis.

The practical utility of our framework is demonstrated through a deliberately multi-faceted validation programme rather than a single illustration. Its empirical anchor is a 12-month production case study, the SzAbI RAG-based chatbot deployed at the University of Pannonia, which translates high-level business metrics—such as knowledge base size, user session frequency, and system utilization patterns—into predictive cost formulas that enable systematic financial planning and architectural trade-off analysis.

This longitudinal baseline is complemented by five additional analyses that probe the framework from distinct angles: (i) a second institutional deployment, the KFI chatbot, evaluated on a synthetically augmented dataset of 95,150 user sessions; (ii) cross-case scenario simulations covering regulated-enterprise, high-scale commercial API, and autonomous agentic regimes; (iii) an illustrative hybrid local–cloud serv-ing scenario with explicit break-even analysis; (iv) a retrieval-versus-fine-tuning architectural comparison under varying knowledge volatility; and (v) a quantitative accuracy bench-mark against a FinOps-style manual estimation baseline. Our work thereby bridges the gap between operational LLM deployment and strategic financial management, providing practitioners with actionable tools for cost-effective LLM service delivery.

The primary contributions of this research, each explicitly positioned against the most recent literature in Section II, are:

• A formal ABC-based TCO framework for LLM services that delivers a dual-layered accounting architecture: a mathematically tractable engine for technical infras-tructure costs, alongside a comprehensive, modular taxonomy blueprint for human operational, governance, adoption, and expected incident cost pools.

• A comprehensive taxonomy of LLM-specific cost drivers grounded in established LLMOps practices, providing practitioners with a systematic checklist for identi-fying and quantifying both infrastructure-driven and personnel-driven cost components across the service lifecycle.

• A scalable operational cost model that distinguishes between one-time setup costs, linearly recurring tech-nical costs, cumulatively growing storage costs, and organization-specific overhead terms, enabling accurate long-term financial forecasting under both static and time-varying vendor pricing conditions, as well as stochastic and hybrid deployment scenarios.

• A multi-faceted empirical validation and cross-case sce-nario comparison, anchoring the technical infrastructure submodel (CTech) in a 12-month real-world production RAG chatbot deployment, extending it to a second institutional deployment evaluated on a synthetically augmented dataset of 95,150 sessions, and utilizing representative enterprise-scale scenario simulations— including regulated, high-throughput, hybrid local– cloud, and agentic execution regimes—to demonstrate the framework’s structural generalizability.

Beyond the itemized contributions, the specific novelty of this work relative to the most recent literature deserves explicit statement. Emerging FinOps guidance for generative

AI, offers practitioner-oriented cost taxonomies but lacks a formally analyzable model; RAGOps and agentic-RAG frameworks, systematize operational pipelines without quantifying their cost structure; recent work on agentic token consumption, combines task-level empirical measurement and limited pre-execution prediction with a broader token-economics survey, but does not embed these drivers in a lifecycle-wide accounting model; and operationalizations of AI-governance regimes such as the EU AI Act and ISO/IEC 42001, specify compliance activities without pricing them.

To the best of our knowledge, the proposed framework is the first to unify these four strands—token-level technical costing, RAG and agentic operations, FinOps-style financial planning, and regula-tory compliance effort—within a single, provably convex, activity-based TCO model that is empirically anchored in production deployment data.

The remainder of this paper is organized as follows: Section III presents our comprehensive Activity-Based Costing framework for LLM services, establishing mathe-matical foundations, analytical properties, and positioning our approach relative to existing cost modeling frameworks. Section IV demonstrates practical application through the chatbot case study, including strategic architectural decision analysis, empirical cost model derivation, and validation of predictive cost formulas. Finally, Section V summarizes key findings and outlines directions for future research.

II. RELATED WORK.

The forecasting and management of costs for IT services have evolved from traditional software estimation models to sophisticated frameworks tailored for cloud architectures. However, the paradigm shift introduced by Large Language Models (LLMs)—characterized by token-based consump-tion, probabilistic output lengths, and distinct lifecycle phases (e.g., RAG vs. Fine-tuning)—presents economic challenges not fully addressed by existing literature. This section reviews the evolution of cost modeling from foundational estimation techniques and Activity-Based Costing (ABC) to contemporary LLM economics, identifying the specific research gaps this framework addresses.

A. TRADITIONAL SOFTWARE COST ESTIMATION AND TCO

For decades, software cost estimation was dominated by parametric models designed to predict development effort based on code complexity. The Constructive Cost Model II (COCOMO II), developed by Boehm et al., remains the de facto standard in this domain. COCOMO II estimates effort and schedule based on the size of the software (typically Source Lines of Code or Function Points) and a set of cost drivers such as personnel capability and platform difficulty. While robust for traditional software engineering, these models are ill-suited for LLM-based services where costs are driven less by lines of code written and more by inference volume, context window usage, and vector database operations.

Parallel to development estimation, Mieritz and Kirwin established the industry standard for Total Cost of Ownership (TCO) analysis within the IT sector. Their framework emphasizes a holistic view of costs across enterprise bound-aries over time, distinguishing between direct budgeted costs (hardware, software, labor) and indirect costs (downtime, operations). Crucially, they argued that TCO must account for the entire lifecycle of IT assets, a principle that remains vital for LLM services where post-deployment operational costs (OpEx) frequently exceed initial development investments (CapEx).

B. ACTIVITY-BASED COSTING IN IT SERVICES

To address the distortions inherent in traditional cost accounting—where overhead is often allocated arbitrarily based on direct labor—Cooper and Kaplan introduced Activity-Based Costing (ABC). ABC traces resource consumption to specific activities before allocating them to products or services, providing the granularity necessary for complex environments.

Kaplan and Anderson later refined this into Time-Driven Activity-Based Costing (TDABC) to simplify implementa-tion in service industries. Adeoti and Valverde successfully applied TDABC to IT service operations, utilizing time equations to estimate capacity cost rates. Their work demonstrated that overhead due to staff activities and service variations could be mathematically modeled to support cost control. However, while these frameworks provide the structural basis for accurate allocation, they predate the generative AI era and do not account for non-temporal cost drivers specific to LLMs, such as token density, embedding dimensions, or retrieval latency.

C. ECONOMICS OF LARGE LANGUAGE MODELS

The emergence of LLMs has spurred new research into the specific economic implications of deploying generative AI. Aryan et al. characterized the challenges of LLM adoption through the ‘‘GCE Trifecta’’ (Generalization, Cost-optimality, and Evaluation). They analyzed the ‘‘build vs. buy’’ dilemma, highlighting hidden costs such as prompt engineering, compliance management, and the infrastructure overhead required for large context windows. Their work underscores that cost optimality is often orthogonal to model generalization, necessitating careful strategic planning.

More recently, Sharma et al. provided a comparative TCO analysis specifically for domain-adapted LLMs in the chip design industry. By comparing a fine-tuned 70B parameter model against general-purpose commercial APIs, they demonstrated that domain-specific models could reduce TCO by over 90% at scale. Their model explicitly accounts for training costs (GPU hours) and inference costs (query volume), providing a linear cost estimation approach relevant to high-volume industrial applications. However, their analysis is primarily restricted to the economic trade-off between model training and inference compute. It does not offer a generalized framework for the complete service lifecycle, leaving out critical auxiliary cost drivers such as vector database operations, embedding generation for RAG pipelines, and cumulative log storage, which are essential for holistic financial planning.

Concurrent efforts by the FinOps Foundation have begun to standardize cost estimation for AI workloads, categorizing costs into compute, storage, and networking dimensions. These industry guidelines focus on forecasting cloud spend but often lack the formal mathematical rigor required for optimization and sensitivity analysis.

The 2024–2026 wave of research has substantially deep-ened each of the strands this framework builds on. On the financial-operations side, FinOps working-group guidance now specifically targets generative-AI usage optimization, cost–performance trade-offs, and cost visibility under variable pricing, underscoring the practical demand for formally grounded cost engines. In the systems community, comprehensive surveys of efficient LLM inference serving catalogue the instance-level and cluster-level mechanisms— scheduling, batching, caching, and disaggregation—that affect throughput, resource utilization, and serving cost.

On the workload side, recent empirical studies quantify how autonomous agents consume tokens: Bai et al. analyze token consumption across eight frontier models in agentic coding tasks, showing that accumulated input context dominates cost and that pre-execution self-prediction provides only weak-to-moderate signals and systematically underestimates actual usage, while Chen et al. provide a dual computing–economics perspective on token economics for LLM agents, conceptualizing tokens as factors of production, media of exchange, and units of account. Agentic retrieval-augmented generation surveys systematize opera-tional patterns—planning, tool use, and reflection loops— whose repeated retrieval, tool-use, and model-execution steps our agentic extension prices explicitly.

Finally, on the governance side, Buscemi et al. decompose the high-risk obligations of the EU AI Act into 48 operational sub-requirements linked to 66 verification activities, providing exactly the kind of activity-level structure that a cost model must be able to price. None of these strands, however, offers an integrated accounting framework that connects them; this is the gap the present work addresses.

The operational balancing of these deployment regimes is further illuminated by comprehensive multi-model bench-marking studies. Meram et al. evaluated the performance of ten distinct large language models in specialized domains, demonstrating a systematic inverse trade-off between semantic diversity and contextual relevance across different model sizes and prompt designs. Similarly, Nasa and Das conducted multi-stage natural language processing evaluations of advanced language models across diverse functional tasks—including technical explanations and open-ended reasoning—identifying that variations in grammatical correctness and vocabulary richness directly impact downstream task efficiency. To exploit these differential performance patterns, recent architectures have shifted toward hybrid implementations that fuse unstructured textual metrics with quantitative features.

For instance, Hussain et al. engineered a synergistic LLM-Transformer framework that conceptualizes the language model as a structured signal generator, utilizing a dynamic gating fusion mechanism to weight text-derived sentiment signals according to token-classification confidence scores. These advancements highlight that multi-model deployments and hybrid execution layers introduce distinct operational dependencies, reinforcing the necessity of a unified account-ing framework that structurally decomposes both linguistic drivers and infrastructure allocation.

D. RESEARCH GAP

Despite these advancements, a critical gap remains in the literature. Traditional models like COCOMO II fail to capture the token-based economics of GenAI. General-purpose TCO models, lack the taxonomy to capture LLM-specific drivers like Retrieval-Augmented Generation (RAG) lookups or embedding storage growth. Conversely, recent LLM-specific studies, focus primarily on inference strategies or high-level strategic trade-offs without providing a generalized, operational cost model that covers the full lifecycle from data preparation to log management.

The most recent 2024–2026 literature sharpens rather than closes this gap: FinOps guidance for generative AI remains practitioner-oriented and informal, serving-efficiency surveys optimize cost drivers without providing an account-ing structure, empirical and survey work on agentic token economics measures task-level spend, tests limited pre-execution prediction, and synthesizes broader cost models without lifecycle-wide activity attribution,, and AI-governance operationalizations enumerate compliance activities without costing them.

The framework proposed in this paper bridges these domains by integrating the granular activity analysis of TDABC with the specific cost drivers of LLMs identified in recent literature, formulated as a provably convex model suitable for systematic financial planning.

III. ACTIVITY-BASED TCO FRAMEWORK FOR LLM SERVICES AND COMPARATIVE ANALYSIS.

A. FRAMEWORK OVERVIEW AND OBJECTIVES

We develop a formal Total Cost of Ownership (TCO) framework for LLM-based services that systematically decomposes costs across the entire service lifecycle using Activity-Based Costing (ABC) principles. The framework addresses two critical requirements: generalizability across different LLM architectures and deployment scenar-ios, and analytical tractability for sensitivity analysis and cost forecasting.

Our approach models the TCO of an LLM service over a planning horizon H by decomposing it into activity cost pools and measurable cost drivers. This yields a model that is mathematically rigorous, provably convex under standard assumptions, and directly applicable to real-world cost management scenarios.

For readability, the framework is introduced in layers. First, we define a generic ABC ledger in which each activity has a measurable driver, a resource-intensity coefficient, and a unit price. Second, we specialize this ledger to the technical LLM service costs that can be validated directly from telemetry, such as tokens, hosting time, database operations, and storage. Third, we add optional organizational and architectural extensions, including governance, risk, agentic execution, and hybrid local–cloud serving.

The main distinction is between transaction-driven technical costs and personnel-driven organizational costs. The technical submodel is governed by observable system interactions, such as tokens and compute seconds, and is therefore empirically validated in the case study. The human operational, governance, adoption, and risk layers provide a parameterized enterprise-planning blueprint; their exact numerical calibration remains context-dependent and varies with institutional maturity and regulatory environment.

B. FORMAL MATHEMATICAL MODEL

1) SETS AND VARIABLES.

We define the following notation:

• S: LLMOps lifecycle stages.

• As: Activities within stage s ∈ S, with A = S s∈S As.

• R: Resource types (e.g., compute, tokens, storage, labor).

• K: Incident classes.

• t ∈{0, 1..., H }: Time periods, where t = 0 denotes setup.

For each activity a ∈ A and period t, we define:

The driver quantity da,t is often a function of Na,t. The resource set R also includes labor; thus, personnel-driven activities such as review, compliance, onboarding, or maintenance are represented in the same accounting structure as infrastructure consumption. In the extended organizational cost terms, ρrev,t and ρesc,t denote review and escalation ratios, τ terms denote average labor times per event, h·,t denotes activity-specific labor hours, and L svc k,t and L liab k,t denote non-labor incident losses.

2) COST CALCULATION.

Let Mr,a denote the consumption of resource r per unit of cost driver da,t. Intuitively, Mr,a answers the question: how many units of resource r are consumed when activity a is performed once or when its driver increases by one unit? The cost for activity a in period t is:

X ca,t = fa,t + pr,t · Mr,a · da,t r ∈R

Thus, Equation 1 is a fixed fee plus a resource bill. Summing this bill over all activities and all periods gives the Total Cost of Ownership:

H X X TCO = ca,t t =0 a∈A

3) LLM-SPECIFIC COST DRIVER TAXONOMY.

The framework incorporates LLM-specific cost drivers informed by established LLMOps practices and by operational activities described in RAGOps and agentic-RAG frameworks. Table 1 provides a comprehensive taxonomy of activities and their associated cost drivers across the service lifecycle.

4) OPERATIONAL COST STRUCTURE.

The general Total Cost of Ownership is expressed as:

TCO = CTech + CHuman + CGovernance + CAdoption + CRisk where the technical component retains the original three-part structure:

CTech = CSetup + CLinear + CCumulative

This formulation preserves the original technical base-line while establishing a dual-layered lifecycle accounting boundary. The technical component operationalizes setup, recurring infrastructure usage, and cumulative storage-like behavior into an empirically validated predictive submodel. In contrast, the remaining terms provide a comprehensive, modular taxonomy designed to structurally map personnel-driven supervision, governance obligations, organizational adaptation, and risk exposure.

5) TECHNICAL COST COMPONENT.

a: SETUP COSTS (CSETUP)

This component represents one-time technical costs incurred during the development and deployment phase (t = 0). It includes activities such as initial knowledge base vectoriza-tion, system architecture design, and CI/CD pipeline setup.

b: LINEAR RECURRING COSTS (CLINEAR)

The CLinear component captures technical costs that recur at a relatively constant rate each operational period (t ≥ 1). It includes fixed fees for base infrastructure (e.g., artifact storage) and variable costs that scale linearly with monthly usage. The key simplification is to price one representative session and then multiply by the number of sessions, Nsessions,monthly:

cUsage,monthly = Nsessions,monthly × csession

The average session bill has three technical parts: model inference, request hosting, and database activity:

csession = cinference + chosting + cdatabase

Let Nmsg be the average number of messages per session.

• Inference Cost (cinference): This is the sum of input and output costs. The input volume has a static part (system prompt and RAG context) plus a dynamic conversation history. The history term matters because previous turns are repeatedly resent to maintain conversational context:

  Nmsg i−1 X X (Luser,j + Lmodel,j)  dhistory = Luser,i + i=1 j=1 where L denotes the character lengths of user and model messages. The nested sum captures the repeated inclu-sion of earlier turns; therefore, the history contribution grows approximately quadratically with the number of messages. The total input characters for the session are then: din = Nmsg(Lsys + LRAG) + dhistory

The total inference cost per session is: cinference = din · pin + (Nmsg · Lmodel) · pout where pin and pout are the per-character prices.

• Hosting Cost (chosting): For serverless platforms, this cost per session is based on the number of messages and resource consumption per message.

chosting = Nmsg × (Treq · (NvCPU · pvCPU + Smem · pmem) preq) + where Treq is average request duration, NvCPU is vCPUs allocated, Smem is memory allocated, and p denotes the unit prices for compute, memory, and per-request invocation.

• Database Cost (cdatabase): Cost for session manage-ment or metadata storage.

cdatabase = Nmsg × (Nreads · pread + Nwrites · pwrite)

where Nreads/writes are the operations per message.

c: AGENTIC INFERENCE EXTENSION

Agentic systems are more expensive to model than ordinary chat because one visible user request may trigger hidden planner, tool-use, reflection, or verifier calls. The accounting change is simple: instead of pricing one input–output pair, we sum the billable input and output of all internal model-execution steps. Let mt denote the number of such steps in period t, and let L in j,t and L out j,t denote the billable input and output lengths of step j, respectively, measured in the provider’s billing unit (e.g., tokens or characters). The aggregate billable input and output volumes of an agentic session are then: mt d agt X L in j,t, in,t = j=1 mt d agt X L out j,t. out,t = j=1

Accordingly, the inference cost of an agentic session can be written as cagt inference,t = d agt in,t pin,t + d agt out,t pout,t, where pin,t and pout,t are the time-indexed unit prices of billable input and output. When mt = 1, this reduces to the ordinary inference-cost expression. When mt is larger, repeated reasoning loops, tool-calling chains, reflection steps, or verifier calls increase cost through both repeated input processing and additional generated output.

d: CUMULATIVE COSTS (CCUMULATIVE)

The CCumulative component accounts for technical costs where the monthly expense grows over time because the underlying resource base accumulates. A primary example is log storage, where each month’s new logs are added to the total volume being stored. The cost in month t is proportional to the total data stored up to that point: cLog,t = t × (SLogNewMonthly × pStorage)

This leads to a total cumulative cost that grows quadratically with the planning horizon H: sessions in that period. The hybrid technical cost component is therefore the sum of setup, remaining API traffic, local execution, and cumulative storage-like costs:

C hyb Tech = C hyb Setup + CAPI + CLocal + CCumulative where

H capi X (1 − αt) N sess sess,t, CAPI = t t =1 and

H   X f loc + αt N sess cloc. CLocal = sess,t t t t =1

Here, capi sess,t is the per-session cost of the external API path, f loc is the fixed monthly cost of maintaining the local t serving stack, and cloc sess,t is the variable local per-session cost. In words, αt moves sessions from one cost vector to another: the API term shrinks with (1 − αt), while the local term grows with αt and also carries a fixed monthly charge.

The setup term includes one-time hybrid-CSetup enablement activities such as hardware procurement, server installation, provisioning, and initial local model deployment. In practice, hybrid serving also requires additional infrastruc-ture engineering to make local and cloud execution work seamlessly together, including routing logic, deployment automation, authentication and secret management, observ-ability integration, and fallback handling. We represent this additional one-time hybrid-enablement effort as

C hyb-int + hmlops pmlops = hinfra pinfra, 0 0 Setup 0 0 and hmlops where hinfra denote the initial infrastructure-0 0 engineering and MLOps integration effort in hours, and and pmlops pinfra are the corresponding labor rates. Accord-0 0 ingly, the hybrid setup component may be written as

H cLog,t = (SLogNewMonthly × pStorage) × H (H + 1) X C hyb Setup + C hyb-int Setup = C base Setup. 2 t =1

C. HYBRID DEPLOYMENT EXTENSION

The proposed framework is designed to support not only binary architectural choices but also continuous hybrid deployments. By decoupling the cost drivers, the model can evaluate mixed architectures—such as router patterns, cascaded inference systems, or auxiliary local models serving low-complexity requests—where workload is dis-tributed across multiple cost centers. While externally hosted or managed inference often provides the most operationally accessible starting point for organizations adopting LLM services, mixed local–cloud serving becomes increasingly relevant in high-throughput or heterogeneous deployment settings.

Let αt ∈ denote the fraction of sessions served by a local subsystem in period t, and let N sess denote the number of t

For purchased hardware, the recurring fixed local cost is modeled as

C cap + coper + cplat f loc h + cadmin, = t t t t 12 Y life h where C cap is the acquisition cost of hardware profile h, h Y life is the assumed useful life in years, cadmin is the t h monthly administration and maintenance cost, coper is the t monthly operator/support cost, and cplat captures recurring t platform-operations overhead such as routing maintenance, deployment automation, observability, security patching, and integration support between local and cloud execution paths.

To make the local path energy- and infrastructure-aware, we decompose the local per-session cost as sess,t = cloc,ene sess,t + cloc,net sess,t + cloc,data cloc sess,t, where cloc,ene sess,t is the electricity cost of local execution, cloc,net sess,t is the network-egress-related cost, and cloc,data captures sess,t session-dependent database and storage activity. Let κh,W denote the decoded-token electricity efficiency in tokens/kWh for hardware profile h and serving context window W, and let L loc out,t denote the total number of output tokens generated locally per session. The per-session electricity cost is then

= L loc out,t pelec,t cloc,ene, sess,t κh,W where pelec,t is the electricity price in $/kWh.

For agentic or tool-augmented workloads, the local output-token term should include all model-generated tokens across internal reasoning or tool-use steps, consistent with the multi-step inference formulation introduced above. If mt denotes the number of local model-execution steps and lout j,t denotes the output length of step j, then mt X L loc lout j,t. out,t = j=1

This formulation makes the electricity term directly sensitive to repeated reasoning loops and tool-calling behavior, which is particularly important for agentic applications.

The network-egress term can be modeled as sess,t = V egress sess,t pegress cloc,net, t where V egress sess,t is the outbound data volume generated by a local session and pegress is the network-egress price per unit t of data.

Similarly, the session-dependent data-services term can be modeled as cloc,data = ndb sess,t pdb + V store sess,t pstore, sess,t t t where ndb sess,t is the number of local database operations attributable to a session, pdb is the corresponding unit price, t V store sess,t is the session-attributable stored data volume, and pstore t is the storage price per unit volume.

Chen et al. report that Llama-3.1-8B on H100-SXM5 at 8K context achieves 6.46 tok/W, which corresponds to 2.326 × 107 tokens/kWh, while the same benchmark on B200-SXM reaches 12.18 tok/W under the same context-window setting. This confirms that local electricity cost depends materially on hardware generation, and the same study also shows that token efficiency declines as context length grows, so κh,W should be treated as both hardware- and context-specific.

To make the practical implication of this hardware sensitivity tangible, Table 2 instantiates the local electricity contribution of one million generated output tokens at a representative average electricity price of $0.20/kWh, using the Chen et al. measurements for two contemporary inference accelerators. The relative cost difference between the two hardware generations is approximately 47% under identical context and pricing conditions, illustrating that the choice of inference accelerator can be as economically significant as workload-side parameters.

This extension preserves the original ABC/TDABC struc-ture while enabling realistic evaluation of mixed execution strategies. In particular, the routing share αt captures the operational trade-off between reduced external-API expendi-ture and increased local fixed, networking, data-service, and electricity-related costs.

In production environments, the variables governing input and output token consumption are directly modi-fied by upstream model routing, batching, and caching configurations within the hybrid architecture. First, model routing and cascading strategies operate as conditional probability mechanisms inside the execution layer. Rather than channeling all queries through a monolithic model, a lightweight routing engine dynamically distributes a fraction of the incoming session volume to low-cost specialized systems based on query complexity, reserving heavy reasoning models strictly for edge failures. This behavior structurally scales the base infrastructure costs by partitioning token metrics across distinct cost vectors. Second, the external cost parameters (pin, pout) are directly modulated by processing alignments.

Utilizing asynchronous batch scheduling infrastructure (such as the Gemini Batch API) applies a direct linear discount multiplier (κ = 0.50) to token unit prices in exchange for relaxing real-time latency requirements. Third, prefix and prompt caching mechanisms dynamically subtract redundant tokens from the active input count variable. By leveraging virtual block allocations to securely cache recurring system definitions and long-context RAG history across consecutive user interactions, the system avoids recalculating attention matri-ces for static data, structurally driving down input token accumulation parameters.

Beyond API-driven commercial endpoints, the frame-work’s baseline technical infrastructure efficiency for the self-hosted or dedicated hardware path (CLocal) is governed by systems-level scheduling and memory optimizations. Tra-ditional machine learning serving layers suffer from extreme hardware underutilization due to request-level scheduling and rigid batch synchronization constraints; because sentences within an inference batch generate varying output lengths, the entire batch is bottlenecked by the slowest request, forcing expensive GPU memory blocks to sit idle or execute wasteful padding computations. The framework captures the economics of modern inference engines that bypass these limitations through iteration-level scheduling and continuous batching, which dynamically swap completed requests out of the active execution batch at the granularity of individual token iterations.

Furthermore, memory manage-ment architectures like PagedAttention eliminate internal memory fragmentation by partitioning the Key-Value (KV) cache into non-contiguous physical pages, shifting GPU memory utilization from heavily bounded configurations to fully saturated regimes. Within our cost framework, these systems-level interventions alter the economic trade-off between latency and cost: maximizing GPU compute density increases the effective token throughput per second per dollar, directly dampening the amortized hosting overhead under heavy local enterprise workloads.

D. ORGANIZATIONAL COST POOLS

Technical telemetry alone does not capture the full own-ership cost of a production LLM service. Human review, audits, onboarding, and incidents consume labor even when infrastructure usage is unchanged. We therefore define modular, organization-specific reporting pools that partition these personnel-driven activities into disjoint sets and can be customized to an enterprise’s operational scale and compliance mandates. It must be emphasized that assigning universal, concrete costs to these organizational pools is inherently difficult; actual expenditures are strictly dependent on the specific enterprise architecture, institutional maturity, and local labor rates. The numerical baselines provided below serve as structural illustrations drawn from recent industry tracking data, rather than absolute constants:

H X X CHuman = ca,t t =1 a∈Ahuman H

X X CGovernance = ca,t t =0 a∈Agov H

X X CAdoption = ca,t t =0 a∈Aadopt where Ahuman, Agov, Aadopt A are disjoint reporting ⊆ pools for labor-intensive supervision, compliance and control activities, and organizational enablement, respectively.

1) HUMAN OPERATIONAL COSTS (CHUMAN).

Labor-intensive supervision, including review, escalation, and maintenance, is a relevant recurring cost category in service operations and LLM deployment practice. For practical estimation, we parameterize this cost pool as:

H X prev,t ρrev,t N sess τrev CHuman = t t =1 + pesc,t ρesc,t N sess τesc t
+ pmaint,t hmaint,t where N sess denotes the number of sessions in period t, prev,t, t pesc,t, and pmaint,t are the time-indexed labor rates for review, escalation, and maintenance, ρrev,t and ρesc,t denote the fractions of sessions requiring manual review and escalation, τrev and τesc are the average labor times per reviewed or escalated case, and hmaint,t is the maintenance effort in labor hours. To calibrate these parameters realistically, organizations can leverage post-hoc validation workflows and system telemetry baselines. For example, the manual review fraction (ρrev,t) can be estimated dynamically by tracking the frequency at which the model’s confidence scores drop below a chosen operational threshold during pilot phases.

The associated labor times (τrev, τesc) are cali-brated by extracting average ticket-handling durations from standard IT service-desk logs. Empirical compliance data from 2026 demonstrates that continuous human oversight introduces an average operational cost of approximately $8,200 (=C7,764) annually per high-risk model, providing a concrete financial baseline for these variables.

2) GOVERNANCE AND COMPLIANCE COSTS (CGOVERNANCE).

Governance and compliance activities such as audits, documentation, and adversarial evaluation are increasingly recognized as non-negligible components of production LLM operations. For practical estimation, we parameterize this cost pool as:

H X paudit,t N aud τaudit CGovernance = t t =0 + pdoc,t hdoc,t
+ pred,t hred,t where N aud denotes the number of audit cycles in period t, t paudit,t, pdoc,t, and pred,t are the time-indexed labor rates for audits, documentation, and red-teaming, τaudit is the average labor requirement per audit cycle, hdoc,t is the documentation and evidence-preparation effort, and hred,t is the red-teaming effort. Organizations can realistically calibrate this pool by aligning the variables with the mandatory AI Risk Treatment Process (Clause 6.1.3) of the ISO/IEC 42001:2023 standard. The activity-level decomposition of EU AI Act obligations into verifiable sub-requirements and associated verification activities proposed by Buscemi et al. provides a complementary, regulation-driven checklist for enumerating the audit and documentation activities to be priced within this pool.

The documentation effort (hdoc,t) is calculated by aggregating the engineering sprint hours required to implement the specific controls selected from Annex A (such as data provenance tracking). Meanwhile, N aud scales t with internal audit cycles (Clause 9.2). Recent empirical benchmarks from EU AI Act compliance tracking indicate that technical documentation and record-keeping typically cost around $4,600 (=C4,390) annually, while independent third-party conformity assessments range from $10,500 to $42,000 (=C10,000 to =C40,000) per evaluation cycle.

3) ORGANIZATIONAL ADOPTION COSTS (CADOPTION).

Organizational adoption also generates indirect ownership costs through onboarding, user training, and process adapta-tion. For practical estimation, we parameterize this cost pool as:

H X ptrain,t N new τtrain CAdoption = t t =0 + psup,t hsup,t
+ pproc,t hproc,t where N new denotes the number of newly onboarded users, t ptrain,t, psup,t, and pproc,t are the time-indexed labor rates for training, rollout support, and process redesign, τtrain is the average training effort per user, hsup,t is internal rollout/support effort, and hproc,t is workflow redesign and process-integration effort. This pool can be systematically estimated by multiplying planned rollout metrics by standard enterprise human resource baselines. The average training time per user (τtrain) is easily quantified via corporate onboarding modules, while process redesign effort (hproc,t) can be modeled as a fixed engineering sprint allocation tied to the complexity of integrating the AI service into legacy workflows.

4) EXPECTED INCIDENT AND MODEL FAILURE COSTS.

(CRISK)

Adverse events such as harmful outputs, service interrup-tions, policy violations, and security incidents can generate material response, service-loss, and liability costs in LLM-enabled systems. For practical estimation, we model their contribution through expected incident cost:

H X X CRisk = qk,t Ik,t k ∈K t =1 with incident impact decomposed into response, service-loss, and liability terms:

Ik,t = presp,t hresp k,t + L svc k,t + L liab k,t where presp,t is the time-indexed labor rate for incident response, hresp k,t denotes the labor hours required to investigate and remediate incident type k, L svc k,t denotes service-loss related costs (e.g., downtime, compensation, rollback), and L liab k,t captures direct financial exposure such as contractual or regulatory penalties. Calibrating the probability of an incident (qk,t) and its subsequent financial impact (Ik,t) maps directly to the AI Risk Assessment Process (Clause 6.1.2) defined in ISO/IEC 42001. Rather than estimating these arbitrarily, organizations can cross-reference the AI-specific risk sources listed in Annex C against their legacy IT infrastructure incident rates to derive empirical base-rate frequencies.

Real-world data shows that activating continuous risk mitigation and incident reporting frameworks introduces a recurring operational overhead of approximately 5% to 8% annually on top of the baseline technical infrastructure spend.

E. COST-FLOW REPRESENTATION

To improve accessibility, Figure 1 summarizes the opera-tional cost-flow logic of the framework. The figure com-plements the formal equations by showing how technical, organizational, and hybrid/local cost drivers flow into their intermediate cost pools and, ultimately, into the final TCO.

F. ANALYTICAL PROPERTIES

1) CONVEXITY AND TRACTABILITY.

The framework is convex when all effective unit prices and coefficients are non-negative (pr,t, Mr,a, fa,t ≥ 0) and cost drivers enter linearly, as defined in Equation 1. Since = ̄pr (1 + δr,t), this condition is satisfied whenever pr,t ̄pr ≥ 0 and δr,t > −1. The TCO (Equation 2) thus becomes a non-negative weighted sum of linear functions, which is inherently convex. This property enables:

• Sensitivity Analysis: Computing partial derivatives ∂ TCO/∂ pr,t and ∂ TCO/∂ da,t to identify high-impact cost drivers.

• Scenario Planning: Evaluating alternative architectures (API vs. self-hosting) and configuration choices.

• Budget Optimization: Systematic resource allocation under cost constraints.

2) TIERED PRICING EXTENSIONS.

Real-world cloud pricing often involves tiers (e.g., first 1M tokens at price p1, additional tokens at p2). The framework accommodates this through piecewise-linear con-vex envelopes, preserving analytical tractability for planning while accurately modeling billing structures.

3) TIME-DRIVEN ABC INTEGRATION.

For activities where resource consumption varies sig-nificantly by transaction complexity, Time-Driven ABC (TDABC) relationships can be incorporated to provide a more accurate cost model: da,t = θa,t × xa,t where θa,t represents the time or resource intensity per unit of work (e.g., seconds per page processed), and xa,t represents the total volume of that work (e.g., total pages processed across all transactions). This approach distinguishes the driver from a simple transaction count (Na,t) and enables precise cost modeling for heterogeneous workloads where the effort per transaction is not uniform.

4) PRICING SENSITIVITY, STOCHASTIC EXTENSIONS, AND.

BOTTLENECK COSTS

The revised framework supports direct sensitivity analysis with respect to time-indexed prices. For any resource r in period t, the marginal price sensitivity is:

∂ TCO X Mr,a da,t. = ∂ pr,t a∈A

This derivative has a direct accounting interpretation: it is the total quantity of resource r consumed in period t, aggregated across activities. A corresponding elasticity measure normalizes that marginal effect by price and total cost:

εr,t = ∂ TCO · pr,t TCO. ∂ pr,t

To improve realism under uncertain workloads and volatile pricing, the framework also admits a stochastic formulation in which drivers, prices, and risk terms are treated as random variables:

H

! X X X TCO = fa,t + epr,t Mr,a eda,t g t =0 a∈A r ∈R H X X eqk,t eIk,t. + k ∈K t =1

This enables Monte Carlo simulation, confidence-interval estimation, and risk-adjusted budgeting. For example, a (1 − α) confidence interval can be estimated from the corresponding empirical quantiles:

  Qα/2, Q1−α/2. CI1−α (g TCO) =

Finally, large-scale or agentic deployments may exhibit non-linear scaling effects due to concurrency limits, queue-ing, or service-level breaches. These effects can be incorpo-rated through convex penalty terms:

H X γλ [λt − λ∗]+ + γw [wt − w∗]+
, Cbottleneck = t =1 where [x ]+ = max(0, x), λt denotes offered load, wt denotes response time or waiting time, and λ∗ and w∗ are operational thresholds. This extension makes it possible to represent operational bottlenecks and stepwise scaling effects while preserving analytical tractability.

G. COMPARATIVE ANALYSIS WITH EXISTING MODELS

1) POSITIONING.

Table 3 benchmarks the proposed Activity-/Time-Driven TCO model for LLM-based services against traditional software cost-estimation models (e.g., COCOMO II), classic IT TCO, ABC/TDABC approaches, cloud/FinOps cost frameworks, and recent LLM/ML-specific cost studies. We highlight where our model extends prior work: LLM-specific drivers (tokens, vector database operations, hal-lucination checks), formal convex formulation enabling optimization and sensitivity analysis, explicit tiered pricing convexification, and replicable resource activity matrices.

Table 4 summarizes the incremental vs. novel aspects relative to each family of models.

Traditional SE models (e.g., COCOMO II) capture devel-opment effort but ignore tokenized inference economics and continuous RAG operations. ABC/TDABC bring activity granularity yet miss LLM-specific cost drivers and cloud-tier complexity. Cloud FinOps literature focuses on com-pute/storage but not on semantic drivers like context length or retrieval depth. Recent LLM works, quantify token/GPU costs but remain narrow (single case or focused on inference scheduling).

By merging ABC/TDABC rigor, convex cost formulation, and LLM-specific driver taxonomy across the entire lifecycle, our model supports:

• Optimization: convexity enables linear/convex pro-gramming for budget allocation, token throttling, or caching policy tuning.

• Scenario & sensitivity analysis: explicit partial deriva-tives and Monte-Carlo on prices/drivers.

• Auditability: every activity links to measurable units and public price sheets, improving transparency.

H. LIMITATIONS AND PRACTICAL CHALLENGES

While the proposed framework provides a rigorous and extensible method for quantifying TCO, its practical use remains subject to several important limitations.

First, the framework is sensitive to parameter estimation quality. The resulting cost estimates depend directly on assumptions about workload intensity, interaction structure, and unit prices, including the number of active sessions, average input and output volume, RAG context size, and hosting-related execution characteristics. For novel services, such quantities are often only partially known before deployment, so estimation errors in these high-volume drivers can propagate directly into the final cost forecast.

Second, although the formulation is general, the empirical calibration in this paper remains limited. The SzAbI deployment provides a real-world technical baseline, while the additional regulated, high-scale, and agentic cases are representative scenario instantiations used to examine model behavior under different operating regimes. These cross-case comparisons strengthen the argument for structural gener-alizability, but they should not be interpreted as equivalent to multi-organization empirical validation. Consequently, the framework is best viewed as a transparent and reusable decision-support model whose coefficients should be recal-ibrated for each deployment context.

Third, the framework represents a snapshot in time within an environment characterized by dual economic and oper-ational volatility. On the economic dimension, vendor API tariffs, cloud computing resource rates, and baseline utility costs fluctuate continuously, meaning external unit prices are highly variable over extended planning horizons. Simultaneously, on the operational dimension, critical tech-nical drivers—including session interaction structures, RAG retrieval hit quality, prompt caching effectiveness, and inter-nal agentic step counts—remain highly context-dependent and vary dynamically based on live runtime workloads. The framework accommodates these shifting patterns by treating them as time-indexed, profile-specific variables rather than static invariants.

Consequently, the proposed TCO model should not be utilized as a one-time static projection; periodic profiling of both external vendor pricing layers and internal operational coefficients is structurally required to maintain high-fidelity forecasting.

Fourth, the model preserves tractability by relying on aver-age or expected values for several workload characteristics. This is analytically convenient and consistent with the convex formulation, but it smooths over the true heterogeneity of production interactions. In practice, some sessions may be short and inexpensive, whereas others may involve long conversational histories, repeated retrieval cycles, or multi-step agentic behavior. The proposed agentic and stochastic extensions partially address this issue, but highly bursty or heavy-tailed workloads may still require finer-grained empirical calibration.

Fifth, the baseline case-study validation focuses on the technical submodel CTech, while the broader framework also includes human, governance, adoption, and risk-related components. This separation is intentional and improves reproducibility across institutions, but it also means that the reported numerical totals should not be interpreted as full organizational TCO values. In regulated or high-assurance environments, these non-technical cost pools may become economically significant.

Sixth, large-scale or agentic deployments may exhibit non-linear operational effects that are only approximately represented in the present work. Concurrency limits, queueing delays, service-level breaches, infrastructure con-tention, and burst-triggered scaling penalties can introduce stepwise or threshold-like cost behavior. Although the bottleneck-aware extension provides a tractable way to approximate such effects, further empirical work is needed to calibrate these penalties in production settings.

Seventh, the unit rates used for the human, governance, adoption, and risk cost pools in this paper are illustrative placeholders rather than empirically calibrated values. They are sufficient to demonstrate the integrative structure of the framework, but obtaining defensible numerical values for these non-technical components in any given organization will require dedicated multi-organizational survey data, audit-evidence-based effort estimation, and incident statistics; this calibration is a distinct line of future work.

Eighth, the agentic inference cost formulation in this paper treats input-token volume as scaling with the number of internal execution steps. In practice, modern API providers (e.g., OpenAI prompt caching, Anthropic prompt caching) and self-hosted KV-cache reuse mechanisms can substan-tially reduce the effective cost of repeated input prefixes within a multi-step interaction, with reported discounts ranging from approximately 50% to 90% on cached por-tions. Incorporating an effective input-volume formulation L input,eff = L input (1 − ρt δcache), where ρt is the cached j,t j,t t fraction and δcache is the provider-specific cache discount, is a t natural extension; in its current form the framework therefore tends to provide a conservative (upper-bound) estimate of agentic input cost.

Ninth, the parametric multi-scenario analysis (regulated, high-scale API, agentic) demonstrates the structural gen-eralizability of the framework but should not be confused with independent multi-organization empirical validation. External cross-institutional data collection on regulated and agentic deployments is left as an explicit avenue for future work.

These considerations do not undermine the usefulness of the framework; rather, they clarify its intended role. The proposed model is most valuable as a structured, auditable, and extensible basis for scenario analysis, comparative planning, and cost-aware architectural decision-making, provided that deployment-specific parameters are estimated and periodically updated with care.

IV. CASE STUDY: LLM-BASED CHATBOT TCO ANALYSIS A. SYSTEM ARCHITECTURE AND DEPLOYMENT CONTEXT

We validate our TCO framework through a comprehensive analysis of a production Retrieval-Augmented Generation (RAG) chatbot (called SzAbI) deployed at the University of Pannonia. The system was developed to provide automated assistance to students and faculty regarding institutional policies, academic regulations, and administrative proce-dures. This real-world deployment provides empirical data for framework validation while demonstrating practical cost modeling in an educational environment.

The SzAbI architecture implements a standard RAG pipeline: document ingestion from university policy databases, text preprocessing and chunking, vector embed-ding generation using Google’s text-embedding-004 model, storage in a FAISS vector database, and query processing through Google’s Gemini 1.5 Flash API. The system is deployed on Google Cloud Platform using a containerized microservices architecture with Cloud Run for compute, Firestore for session management, and Cloud Storage for artifacts and logs.

The deployed system architecture is summarized in Figure 2. The figure highlights the main runtime components of the SzAbI service, including the React frontend, the public application layer, the internal RAG backend, the external model and embedding services, and the persistence layer used for session management and logging. It also makes explicit the technical interaction points that generate the principal cost drivers considered in the case-study TCO analysis, namely request-processing and hosting, inference calls, embedding calls, vector retrieval, Firestore read/write operations, and storage-related activity.

From a cost-modeling perspective, this architecture clar-ifies how the abstract technical drivers introduced in Section III arise in the concrete deployment. Cloud Run primarily contributes request-processing and hosting costs, Gemini calls generate inference costs, the embedding ser-vice contributes vectorization cost, FAISS retrieval induces semantic search activity, while Firestore and Cloud Storage account for state persistence, logging, and artifact-related storage overhead. This system-level view therefore com-plements the formal cost decomposition by showing where the modeled technical expenses originate in the operational architecture of the SzAbI service.

Our analysis spans a 12-month operational period. To keep the empirical validation reproducible across different economic geographies, the numerical instantiation below evaluates the technical component CTech of Equation 3. The broader framework nevertheless admits organization-specific additions through CHuman, CGovernance, CAdoption, and CRisk, which can be parameterized using local wage rates, compli-ance intensity, rollout effort, and expected incident impacts. All baseline unit prices (̄pr) used in the technical cost calculations are itemized in Table 12 in Appendix, providing reproducible baseline data for the validation of the technical submodel.

B. EMPIRICAL COST MODEL DERIVATION

We systematically apply the framework to derive a predictive cost model using three primary input parameters that capture the essential economic drivers of the SzAbI system:

• VKBChars: Knowledge base size in characters.

• NSessionsMonthly: Average monthly user sessions.

• tmonths: Planning horizon in months (equivalent to H). Following the technical cost decomposition from Equation 4, the derivation proceeds in the same order as the model: one-time setup cost, monthly per-session usage cost, and cumulative log-storage cost. Each intermediate quantity is named before substitution so that the final predictive formula can be traced back to observable deployment metrics. All unit prices are given in Appendix.

1) SETUP COSTS (CSETUP).

Initial development and deployment activities yield one-time costs: cEmbed,0 = VKBChars × pEmbedChar = 4.855 × 105 × 2.5 × 10−8 = $0.012 cBuild,0 = NBuilds × TBuildMinutes × pBuildMinute = 21 × 2 × 8 × 10−3 = $0.336

The total setup cost is CSetup = $0.348.

2) LINEAR RECURRING COSTS (CLINEAR).

Monthly operational costs comprise base storage and active usage.

a: BASE STORAGE (CSTORAGE,MONTHLY) b: ACTIVE USAGE (CUSAGE,MONTHLY)

Based on Equation 6, we calculate the cost per session by combining inference, hosting, and database components. Intuitively, every SzAbI session generates three bills: tokens processed by Gemini, seconds of Cloud Run execution, and Firestore read/write operations. The derivation below quantifies these resource pools using empirically observed message counts and average interaction lengths from the SzAbI deployment.

Empirical analysis reveals an average of Nmsg = 2.33 messages per session.

1. Inference Cost per Session (cinference): We apply the full.

inference cost formula using empirically derived average lengths: system prompt Lsys = 508 chars, RAG context LRAG = 6 × 103 chars, user message Luser = 38.4 chars, and model response Lmodel = 248.9 chars.

Input Cost (cInput,session). The conversation history com-ponent, dhistory, is calculated based on its definition in Equation 7 using a closed-form approximation with average values:

The total input characters are the sum of static and history components:

The total input cost for the session is therefore:

Output Cost (cOutput,session). The cost is for the total characters generated across an average session:

Total Inference Cost. The total is the sum of input and output:

2. Hosting Cost per Session (chosting): For a 3-second request.

on a 1-vCPU, 0.5-GB instance, the cost per message is calculated. Total session cost is scaled by Nmsg:

3. Database Cost per Session (cdatabase): Each message.

triggers one read and one write operation.

cdatabase = Nmsg × (pread + pwrite)

Summing the cost components gives a total per-session cost of csession = $5.183 × 10−4.

3) CUMULATIVE COSTS (CCUMULATIVE).

Log storage grows as each month’s logs (645 bytes per message) accumulate. The total cost over the horizon is:

CLogStoreTotal = (NSessionsMonthly × Nmsg × Slogpermsg) × pLogStorage × tmonths(tmonths + 1) 2 = (NSessionsMonthly × 2.33 × 645 × 10−9) × 0.165 × tmonths(tmonths + 1) 2

C. PREDICTIVE COST FORMULA

Synthesizing the components from the case study yields the technical predictive model, which directly links the system’s high-level business metrics to its infrastructure-related total cost. The technical submodel is expressed as the sum of its three core components:

TCOTech = CSetup + CLinear + CCumulative

Substituting the derived expressions for each component yields the final operational formula:

This technical baseline model enables direct cost fore-casting from key parameters. For a system with 485518 characters and 200 monthly sessions over a 12-month horizon, the predicted technical TCO is $2.80, demonstrat-ing the cost-effectiveness of API-based LLM services for moderate-scale applications.

D. COMPREHENSIVE MODEL VALIDATION AND SENSITIVITY ANALYSIS

To rigorously validate our TCO framework and quantify parameter sensitivities, we developed a comprehensive anal-ysis program that enables systematic exploration of cost dynamics across diverse scenarios. The analysis encompasses baseline validation, parameter elasticity quantification, uncertainty modeling, vendor-price sensitivity, cost opti-mization scenario evaluation, scaling economics assessment, model-accuracy validation, and validation of the architectural choice made for the SzAbI deployment.

1) PARAMETER SENSITIVITY AND ELASTICITY ANALYSIS.

Using the derived predictive formula (Equation 43), we con-ducted systematic sensitivity analysis by varying each input parameter within realistic ranges. Table 5 presents the TCO elasticity coefficients, defined as the percentage change in total cost per one percent change in each parameter.

The elasticity analysis reveals that session volume exhibits moderate elasticity (0.446), indicating that TCO scales sub-linearly with usage intensity. This validates the frame-work’s effectiveness in capturing variable cost structures. Conversely, knowledge base size demonstrates negligible cost impact (elasticity 4 × 10−3), confirming that setup costs are amortized effectively across operational periods.

2) MONTE CARLO UNCERTAINTY QUANTIFICATION.

To address parameter uncertainty in real-world deployments, we conducted Monte Carlo simulation with 10000 itera-tions, incorporating realistic parameter distributions based on observed usage patterns. The uncertainty analysis assumes:

• Knowledge base size: N (μKB, 0.1μKB) (10% CV reflecting content updates)

• Monthly sessions: N (μsessions, 0.2μsessions) (20% CV reflecting usage variability)

• Time horizon: N (μtime, 0.05μtime) (5% CV reflecting planning precision)

For the baseline scenario (485518 characters, 200 ses- sions/month, 12 months), the Monte Carlo analysis yields:

Expected TCO = $2.80 ± $0.28 90% Confidence Interval = [$2.35, $3.27]

Value at Risk (95%) = +$0.47 above expected

This uncertainty quantification enables risk-adjusted bud-get planning and provides confidence bounds for financial forecasting.

To evaluate the structural sensitivity of the framework to the context-dependent operational variables highlighted during deployment, the stochastic distribution profile explic-itly accounts for systemic variances in session structure (Nmsg), RAG hit quality (which dynamically modulates the effective retrieval context length LRAG), prompt caching effectiveness, and agentic execution complexity (mt). In pro-duction environments, these drivers are highly volatile and exhibit non-linear interactions. For example, low RAG hit quality or complex user queries trigger extended conversational histories or multi-step agentic reasoning loops, which quadratically increase input token accumula-tion.

By modeling these operational parameters as joint prob-ability distributions within the 10,000-iteration simulation layer rather than decoupled static averages, the framework successfully encapsulates structural interaction bursts—such as heavy-tailed conversation lengths or dense tool-calling sequences. This guarantees that the resulting confidence intervals ([$2.35, $3.27]) remain representative of realistic operational volatility and context-dependent infrastructure strain.

3) VENDOR PRICE SENSITIVITY ANALYSIS.

Because the revised framework admits time-indexed prices, we also evaluate the sensitivity of the baseline case to plausible vendor-side price changes. Let ηtok and ηhost denote multiplicative scaling factors applied to token-priced and hosting-related unit prices, respectively. For the case-study setting, the technical total cost can therefore be interpreted as a function of grouped price scaling,

TCOTech = TCOTech(ηtok, ηhost, ηdb, ηlog), with ηdb and ηlog analogously defined for database-related and cumulative log-storage-related prices.

= 4.855 × 105, For the baseline scenario (VKBChars NSessionsMonthly = 200, tmonths = 12), this formulation reproduces the technical baseline TCO of $2.80. Table 6 summarizes the effect of a uniform 20% increase in selected price groups.

These values were verified directly from the case-study cost decomposition. The results confirm that even in the moderate-scale SzAbI deployment, the framework is suf-ficiently sensitive to provider pricing changes to support forward-looking budget planning. They also indicate that token-priced components remain the dominant external price driver, while hosting-related prices are secondary but still non-negligible. Ranking the four price multipliers by their marginal contribution to TCO yields the tornado-style summary in Table 7. Because each affected cost pool enters the framework linearly in its price multiplier, the first-order elasticities in eq. 38 are essentially constant over moderate perturbation bands, so the ranking is stable from ±10% to ±50%.

Token-priced API cost dominates the SzAbI baseline by roughly a factor of two over hosting, while database and log-storage prices are quantitatively negligible; this ranking guides where contract-level hedging effort is most worthwhile.

4) COST OPTIMIZATION SCENARIO ANALYSIS.

We systematically evaluated cost reduction strategies through scenario modeling, quantifying the financial impact of common optimization approaches. Table 8 presents the results for key optimization strategies.

The analysis demonstrates that usage throttling provides the highest absolute savings (17.9%), while response caching offers substantial benefits (13.2%) with minimal user experience impact. The hybrid approach achieves (16.4%) significant cost reduction while maintaining service quality, representing a practical optimization strategy.

5) SCALING ECONOMICS AND BREAK-EVEN ANALYSIS.

To inform architectural decisions and capacity planning, we analyzed cost scaling behavior across session volumes from 10 to 1000+ monthly sessions over multiple time hori-zons. Figure 3 illustrates the economies of scale achievable through the API-based architecture.

The scaling analysis reveals:

Cost per session (50 sessions/month) = $0.0031 Cost per session (200 sessions/month) = $0.0012 Cost per session (1000+ sessions/month) = $0.0006

This represents a 62.4% cost reduction per session when scaling from low to medium volume, demonstrating strong economies of scale within the moderate usage range typical of institutional deployments.

6) MODEL VALIDATION AND ACCURACY ASSESSMENT.

Cross-validation against 12 months of production data demonstrates the framework’s predictive accuracy. The systematic comparison between predicted and observed costs yields:

Mean Absolute Error (MAE) = $0.12

Mean Absolute Percentage Error (MAPE) = 4.8%

R2 = 0.947

This validation confirms the framework’s reliability for financial planning and budget allocation, with prediction errors consistently below 5% across the validation period. The high R2 value indicates that the model captures 94.7% of cost variance, demonstrating strong explanatory power for real-world LLM service economics.

7) VALIDATION OF THE API-BASED ARCHITECTURE CHOICE.

The SzAbI deployment required an early architectural choice between self-hosting an open-source LLM and using a managed API-based service, a decision that exemplifies the classical trade-off between capital expenditure and operational expenditure. In the API-based alternative, setup cost remains minimal and recurring expenditure scales with observed usage. In contrast, self-hosting would require substantial up-front GPU procurement and ongoing fixed operating cost, regardless of realized utilization.

The observed usage pattern strongly supports the API-based choice. Figure 4 shows that monthly session counts fluctuate substantially across the academic year, with demand concentrated during teaching periods and lower activity during breaks. This pattern is economically unfavorable for a dedicated self-hosted serving stack because much of the provisioned capacity would remain idle.

Using conservative estimates of $50000 setup costs and $2000 monthly operational expenses for self-hosting, the analysis confirms that the API-based architecture remains overwhelmingly more cost-effective at the observed university scale. For the baseline usage pattern of 200 sessions/month, the 36-month technical TCO of the API-based solution is only $7.72, compared to an estimated $1.220 × 105 for self-hosting. Self-hosting would only become economically plausible at session volumes in the hundreds of thousands per month, far beyond the realized SzAbI workload.

Taken together, these results confirm that the original architectural decision was appropriate for the actual deploy-ment context: the realized session volume remains far below the utilization threshold required to justify dedicated local infrastructure, and the flexibility of pay-per-use inference dominates the economics of the service.

The comprehensive analysis establishes the framework’s practical utility for systematic TCO management, strategic architectural decisions, and operational optimization of LLM-based services. The quantified elasticities, uncertainty bounds, and optimization potentials provide actionable insights for practitioners deploying similar systems.

E. ILLUSTRATIVE HYBRID DEPLOYMENT SCENARIO

To demonstrate how the updated methodology can evalu-ate heterogeneous local–cloud execution, we consider an illustrative hybrid serving scenario in which a fraction of low-complexity requests is routed to a local auxiliary model, while the remaining share is served by the external API. Because the empirical case study validates the technical submodel, the comparison below is likewise restricted to the technical recurring component of the deployment.

Using the notation introduced in Section III, the monthly hybrid technical execution cost has two parts: the API bill for sessions not routed locally and the local bill for fixed infrastructure plus routed sessions:

C hyb Linear,t = CAPI,t + CLocal,t, where capi CAPI,t = (1 − αt) N sess sess,t, t and

CLocal,t = f loc + αt N sess cloc sess,t. t t

For the fixed local component, we instantiate Eq. using the conservative lower-end acquisition cost C cap H100 = $2.500 × 104, a three-year amortization horizon, and zero-, coper, and cplat valued institution-specific labor terms cadmin t t t in order to isolate the technical-capital baseline. This gives

The choice of a small local branch is feasible because the Ollama artifact size of llama3.1:8b is 4.9 GB, which fits comfortably within the H100 SXM5 80 GB memory budget and leaves substantial headroom for practical concurrent serving.

For the variable local component, we instantiate Eqs. –. We assume an electricity price of pelec,t = $0.20/kWh, average local output length L loc out,t = 200 tokens per session, network-egress cost cloc,net $1 × 10−5, and session-= sess,t dependent data-services cost cloc,data = $2×10−5. Chen et al. sess,t report that Llama-3.1-8B on H100-SXM5 at 8K context achieves 6.46 tok/W, which corresponds to 2.326 × 107 tokens/kWh; the same benchmark also shows materially different efficiency values across newer accelerator classes under the same context-window setting, confirming that local serving cost depends on hardware-dependent cost-power efficiency. Under these assumptions, so that sess,t = cloc,ene sess,t + cloc,net sess,t + cloc,data cloc sess,t = 1.72 × 10−6 + 1 × 10−5 + 2 × 10−5 = $3.172 × 10−5.

As an illustrative enterprise-scale scenario, consider a total = 2 × 107 sessions/month, routing share volume of N sess t αt = 0.6, and API per-session cost capi sess,t = 5.183 × 10−4. The corresponding monthly hybrid technical execution cost is then whereas pure API execution would yield

Thus, at sufficiently high volume, the hybrid alternative can become economically preferable, with monthly savings of approximately $5.145 × 103 in this illustrative case. The break-even point is the session volume at which local per-session savings exactly cover the fixed local monthly cost: f loc  ≈ 2.38 × 106 sessions/month, N BE ≈ t  capi sess,t − cloc αt sess,t which remains far above the observed university workload but is plausible in larger enterprise-scale deployments. This result demonstrates that hybrid deployment is not attractive for the observed low-volume institutional use case, but it may become advantageous in heterogeneous, high-throughput settings where routing and hardware-specific cost-power efficiency can be exploited.

F. CROSS-CASE SCENARIO COMPARISON

To evaluate the structural generalizability of the frame-work beyond the empirical institutional baseline (Case A), we parameterize the technical submodel across three distinct operational archetypes: a Regulated Enterprise environment (Case B), a High-Scale Commercial API infrastructure (Case C), and an Autonomous Agentic execution workflow (Case D). Crucially, these broader configurations function as illustrative, non-empirical scenario simulations designed to stress-test the cost accounting engine under diverse opera-tional envelopes rather than production-validated baselines. The purpose of this comparative analysis is to demonstrate how the formal mathematical framework handles highly divergent throughput layers, governance constraints, and multi-step inference regimes using a unified parameter baseline.

Table 9 shows that the same formal framework remains applicable across markedly different deployment regimes, while the dominant cost drivers shift substantially. In the empirical university baseline, the recurring technical cost remains modest because both traffic volume and interaction depth are limited. In the regulated enterprise scenario, technical cost rises into a clearly enterprise-scale range, and the longer sessions and larger billable volumes indi-cate a setting in which governance and human-overhead terms would likely become even more prominent in the full organizational model. In the high-scale API scenario, aggregate throughput dominates the cost structure, mak-ing token-priced and hosting-related variables the pri-mary drivers.

In the enterprise-scale agentic scenario, repeated internal model-execution steps produce the highest per-session technical cost and illustrate how workload structure, not only traffic volume, can materially influence ownership cost. This comparison supports the claim that the framework generalizes across low-volume institutional, governance-intensive, throughput-dominant, and multi-step agentic settings.

To operationalize the technical submodel (CTech) across divergent deployment archetypes, practitioners should recali-brate key workload coefficients to match the specific process-ing style of the target environment. For throughput-dominant regimes (Case C), calibration focuses primarily on track-ing volumetric session frequencies (NSessionsMonthly) and factoring in provider-specific prompt-caching profiles to bound input token expenses. In contrast, agentic execution paths (Case D) require a shift from single-turn inference evaluations to tracking multi-step reasoning arrays; this entails dynamically profiling the model-execution steps (mt) and the cumulative input history expansion (dhistory) across nested tool-calling loops.

Finally, for governance-heavy setups (Case B), the primary calibration target is the retrieval window capacity (LRAG) to adequately absorb dense compliance prompts and verification guardrails. This targeted configuration ensures that the underlying math remains tightly aligned with localized architectural variations.

G. COMPARATIVE ANALYSIS AND SCALING ECONOMICS

As a complementary large-scale validation, we conducted a comparative analysis using a larger, synthetic dataset derived from our newest institutional deployment, the KFI chatbot. This analysis explores the economic trade-offs between the RAG architecture and a Fine-Tuned Model (FTM) approach under varying load conditions and provides an additional high-volume comparison beyond the cross-case scenario analysis introduced above.

1) SYNTHETIC VALIDATION DATASET.

We utilized early interaction logs from the KFI chatbot to generate a synthetically augmented validation dataset. Using an LLM-based augmentation pipeline, we expanded the initial topic seeds into 95150 unique user sessions across diverse administrative domains. This dataset represents a medium-scale deployment with significantly higher variabil-ity in message length and conversation depth than the primary SzAbI case study.

Figure 5 illustrates the distribution of variable token costs across 10 Monte Carlo simulations of the augmented dataset. This confirms that the TCO framework remains robust to usage variance even at higher volumes, with consistent inference costs across simulations.

Table 10 contrasts the primary (SzAbI) and validation (KFI) dataset parameters. The KFI dataset represents a significantly more robust deployment, featuring a larger knowledge base and a session volume nearly three orders of magnitude higher than the pilot study. Notably, despite the larger corpus, the average RAG context length decreased by approximately 50%. This reduction results from an imple-mented optimization strategy where a relevance confidence threshold was introduced, filtering out low-quality retrieval snippets to reduce unnecessary token consumption.

2) ARCHITECTURAL TRADE-OFFS: RAG VERSUS.

FINE-TUNING

We applied the TCO framework to compare two distinct architectural strategies for the KFI dataset over a 3-month horizon:

1) Standard RAG: Injects the relevant knowledge snippets.

into the input context for every query. Setup costs are minimal (embedding indexing), but variable costs scale linearly with usage as the same context tokens are processed redundantly for multiple interactions.

2) Fine-Tuned Model (FTM): Removes the RAG context.

requirement (LRAG ≈ 0) by baking knowledge into the model weights. The Setup Cost is fixed based on the Knowledge Base size (approx. 26 million training tokens for the current KFI scenario, costing ≈ $134), regardless of subsequent user traffic.

Results at Medium Scale: At the volume of 95150 monthly sessions, the architectures reach a state of economic inversion. The RAG approach incurs a TCO of $689, driven largely by variable inference costs. The FTM approach, assuming a static knowledge base with a single initial training run, achieves a lower TCO of $560—an 18.7% savings.

However, this advantage is fragile. The FTM cost pro-jection assumes zero updates to the underlying data over the 3-month horizon. A single requirement to modify or retract information would necessitate a full model re-training (≈ $134), immediately negating the projected savings and rendering the RAG architecture more cost-effective for dynamic environments.

3) SCALING DYNAMICS AND BREAK-EVEN ANALYSIS.

To generalize these findings, we modeled the cost trajectories for the KFI scenario across a continuous volume spectrum, specifically analyzing how knowledge volatility—the fre-quency of required updates—impacts the economic viability of the architecture.

As illustrated in Figure 6, the analysis demonstrates that the economically optimal strategy is highly sensitive to maintenance requirements. In a stable knowledge domain where model weights can remain frozen (0 updates), the higher efficiency of the Fine-Tuned Model (FTM) justifies the initial training investment for this specific corpus after approximately 48,500 monthly sessions.

However, this advantage diminishes in high-volatility scenarios. The figure shows that each required model re-training acts as a step-function increase in fixed costs. In a use case requiring monthly updates, the break-even threshold for the KFI dataset shifts drastically to approximately 193 000 monthly sessions.

These results indicate a clear architectural dichotomy: FTM is the financially superior choice for high-volume, stable domains (e.g., archival history), while RAG provides essential economic insulation for domains with high update frequency or moderate traffic.

H. BROADER IMPLICATIONS FOR LLM SERVICE ECONOMICS

The comprehensive analysis, spanning both the SzAbI pilot and the KFI validation scenarios, reveals several critical insights for enterprise LLM service cost management:

• Variable Cost Advantage: For moderate-scale applica-tions with variable demand, API-based services signif-icantly outperform self-hosted alternatives in total cost efficiency, with break-even thresholds in the hundreds of thousands of sessions per month.

• Cost Structure Optimization: Systematic elasticity analysis identifies session volume as a significant variable cost driver (elasticity 0.446), enabling targeted optimization strategies that achieve 16.4% cost reduc-tion through hybrid caching approaches.

• Predictive Capability: The derived framework enables accurate budget forecasting (4.8% MAPE) from busi-ness metrics, supporting strategic planning with quan-tified uncertainty bounds for risk-adjusted budgeting.

• Economies of Scale: Strong scaling efficiencies demon-strate 62.4% per-session cost reduction from low to medium volume, validating the economic rationale for API-based architectures in institutional deployments.

• Architectural Strategy (RAG vs. Fine-Tuning): Multi-scenario simulations identify a clear economic boundary between retrieval-based and fine-tuned architectures. While Fine-Tuning offers superior unit economics at scale (break-even ≈ 48,500 sessions for the KFI scenario), RAG remains the optimal choice for domains with high knowledge volatility, where re-training costs would negate the variable cost savings.

These findings establish a quantitative foundation for transforming LLM service cost management from ad-hoc estimation to systematic, data-driven financial planning with measurable optimization opportunities.

I. QUANTITATIVE COMPARISON WITH FINOPS BASELINES.

We benchmarked the predictive accuracy of our proposed model against the Cloud FinOps approach identified in Table 3. We operationalized the FinOps baseline using the official Google Cloud Pricing Calculator, represent-ing the ‘‘Manual Estimation’’ method where infrastruc-ture requirements are estimated directly from engineering assumptions rather than derived from activity drivers.

Table 11 compares the accuracy of our ABC Framework against this FinOps baseline relative to the actual invoiced TCO of $2.92 observed during the pilot.

The comparison reveals that the FinOps approach yielded an estimation error of 15.8%, largely driven by the difficulty in manually estimating aggregate resource consumption (e.g., total vCPU execution time) from high-level usage patterns. In contrast, our Activity-Based Costing framework achieved a significantly lower error of 4.1% by mathematically deriving these resource requirements from the underlying session activities (Nmsg, Lcontext), demonstrating the superior preci-sion of algorithmic cost modeling over manual calculator estimation.

V. CONCLUSION.

The rapid adoption of Large Language Models has created an urgent need for systematic financial governance, yet traditional software cost estimation models prove inade-quate for the unique economics of token-based services, variable workloads, and specialized LLM operations. This paper addresses this critical gap through a comprehensive Activity-Based Costing framework specifically designed for LLM Total Cost of Ownership analysis.

Our key contributions include: a formal, math-ematically rigorous TCO model that decomposes costs into technical, human operational, governance/compliance, organizational adoption, and expected incident pools; a comprehensive taxonomy of LLM-specific cost drivers spanning the full LLMOps lifecycle; and a multi-faceted empirical validation programme that anchors the technical baseline submodel in a 12-month real-world RAG chatbot deployment, extends it to a second institutional deployment evaluated on 95,150 synthetically augmented sessions, and complements it with cross-case scenario comparisons across governance-intensive, high-scale, and agentic deployment regimes, hybrid local–cloud break-even analysis, and a retrieval-versus-fine-tuning architectural comparison, which together demonstrate both predictive accuracy and broader model generalizability.

The resulting formulation translates high-level business metrics—such as knowledge base size and user session frequency—into concrete technical cost estimates while preserving a broader structure for full organizational TCO estimation.

Beyond theoretical contributions, this framework provides immediate practical value for organizations deploying LLM services. The case study demonstrates clear cost advantages of API-based architectures for variable workloads, while the systematic cost decomposition reveals optimization opportu-nities that spreadsheet-based approaches cannot capture. The framework’s convex structure enables rigorous sensitivity analysis and supports data-driven decisions about scaling, caching policies, and resource allocation.

While our deepest longitudinal validation is anchored in a single production deployment, it is complemented by a second institutional case study, large-scale synthetic aug-mentation, and representative cross-case scenario analysis; the framework’s modular design ensures broad applicability across diverse LLM architectures and use cases. Future research should focus on multi-organization validation to establish generalized cost coefficients, calibrate bottleneck and agentic workload effects more precisely, and extend the model to emerging LLM deployment paradigms. This work establishes a foundation for transforming LLM service cost management from ad-hoc estimation to systematic, transparent financial planning.

APPENDIX.

UNIT PRICES

Table 12 lists the baseline unit price parameters (̄pr) used in the technical case-study instantiation of the TCO model. The values serve as specific inputs for the case study and are based on pricing as of April 18, 2025, for services from Google Cloud Platform (europe-west1 region) and GitHub Actions.

ACKNOWLEDGMENT.

The authors thank HUN-REN–PE Complex Systems Mon-itoring Research Group and the University of Pannonia for providing the institutional environment and the SzAbI service-operation data that made the empirical case study possible.

DECLARATION OF GENERATIVE AI USE IN THE WRITING PROCESS

In accordance with the IEEE policy on AI-generated content, the authors disclose that generative AI tools were used during the preparation of this manuscript. Specifically, OpenAI ChatGPT (GPT-4 and GPT-5 class models) and Google Gemini (Gemini 2.5 Pro) were employed as writing assis-tants for narrative drafting, language polishing, and textual synthesis in the Introduction, Related Work, Methodology descriptions, Discussion, and Conclusion. These tools were also used to improve the clarity and grammatical consistency of author-written content throughout the paper.

No AI tool was used to generate new scientific claims, mathematical for-mulations, experimental data, code, figures, or bibliographic entries: the mathematical model, the empirical case-study parameters and measurements, the software implementation used for the numerical experiments, and the analysis of the results were designed and executed exclusively by the human authors. All AI-assisted text was critically reviewed, revised, and verified by the authors, who take full responsibility for the scientific content, the accuracy of all results, and the integrity of the final manuscript.

For the revision phase of this manuscript, the same generative AI tools were used in the same advisory role: drafting candidate language for the new Limitations paragraphs introduced in response to reviewer comments, refining the textual presentation of the new hardware comparison and tornado-style sensitivity ranking tables, and improving the structure and clarity of the response-to-reviewers document. As in the original writing phase, all reviewer-driven additions, the new equations, the elasticity values, the hardware-side numerical entries, and all bibliographic additions were derived, verified, and approved by the human authors, who take full responsibility for the revised manuscript.