ACEM: A Cost Estimation Model for Agentic Software Engineering
Source: arXiv:2608.02582 · Published 2026-08-03 · By Mohammad El-Ramly
TL;DR
This paper addresses a critical gap in software cost estimation models caused by the rise of agentic software engineering, where autonomous AI agents perform substantial implementation work and humans shift focus to oversight and validation. Traditional models like COCOMO II and Function Points assume effort is primarily human labor-based and do not incorporate the new cost dimensions introduced by agentic pipelines such as large language model (LLM) token consumption, human-in-the-loop (HITL) oversight time, and infrastructure costs. ACEM (Agentic Cost Estimation Model) is proposed as a structured framework that decomposes total cost into three additive components: LLM token costs, HITL costs, and infrastructure costs. It also introduces new constructs to handle characteristic challenges of agentic software engineering such as non-determinism and growing context length, which impact token usage unpredictably.
ACEM formalizes three novel factors: the Revision Factor (RF) to model token overhead from rejected outputs and retries; the Context Factor (CF) to capture increased token consumption as context accumulates in multi-step pipelines; and the HITL Intensity Score (HIS), a four-level scheme classifying human oversight intensity per task. Additionally, it provides calibrated mappings from existing software sizing metrics (Use Case Points, Story Points, Function Points) to estimated LLM token consumption, enabling reuse of established project scoping data for agentic cost forecasting. The model is fully specified but not yet empirically validated, with constants left symbolic and an evaluation plan proposed. The work lays the groundwork to integrate traditional SE estimation with the emerging realities of AI-driven development.
Key findings
- Agentic development cost can be decomposed into three additive components: LLM token cost (CLLM), human-in-the-loop cost (CHITL), and infrastructure cost (CInfra).
- Revision Factor (RF) models token overhead caused by rejected outputs and retry cycles, which can significantly increase LLM usage beyond nominal task size.
- Context Factor (CF) captures the increase in token consumption due to context accumulation over multi-step agentic pipelines, which leads to compounding cost growth.
- HITL Intensity Score (HIS) classifies human oversight effort into four discrete levels to reflect variability in manual review and correction costs.
- LLM token consumption is inherently non-deterministic: identical tasks can consume up to 30x different tokens across runs due to stochastic sampling and pipeline complexity.
- Mapping existing sizing metrics like Use Case Points and Story Points to token consumption enables use of legacy project scoping data for agentic cost prediction.
- Token cost magnitude varies widely with agent autonomy and pricing model, ranging from negligible under light human supervision to exceeding human labor costs in fully autonomous API-billed workflows.
- Empirical data shows AI coding token costs can reach $200–$500 per developer per month or more, approaching or surpassing labor costs, motivating independent treatment of LLM and HITL costs.
Methodology — deep read
The paper proposes the ACEM framework to model agentic software engineering project costs by decomposing total cost into three additive components: LLM token cost (CLLM), human-in-the-loop cost (CHITL), and infrastructure cost (CInfra).
Threat Model and Assumptions: The primary adversary model is not security-focused; rather, the framework assumes project planners and estimators face uncertainty from inherent LLM non-determinism, variability in human oversight needs, and shifting operational cost factors. It does not explicitly consider adversarial attacks on cost models.
Data and Provenance: This is a theoretical model proposal without empirical datasets used for calibration or validation yet. It relies on prior published data from industry telemetry, benchmarking studies, and literature on LLM costs, AI-assisted coding productivity, and software sizing metrics.
Architecture / Algorithm: ACEM defines variables and equations to model cost components. The LLM cost CLLM sums token usage across all agent actions multiplied by per-token prices, adjusted by corrective factors:
- Revision Factor (RF), estimating token overhead due to output rejections and retries.
- Context Factor (CF), modeling token growth from accumulated conversation and code context across agent pipeline steps. The HITL cost CHITL is modeled by multiplying the human time per intervention by an estimated labor rate, scaled by the HITL Intensity Score (HIS) that categorizes oversight intensity on a four-level discrete scale. Infrastructure cost CInfra accounts for cloud and orchestration resource costs per project duration. The model presents formal mappings from traditional sizing metrics (Use Case Points, Story Points, Function Points) to estimated base token counts, allowing existing scope data to be input.
Training/Calibration Regime: There is no training; model constants and scaling factors remain symbolic and are meant to be empirically grounded through data collection from real agentic projects. The calibration methodology involves gathering usage logs, token counts, HITL effort measurements, and infrastructure costs to fit the model parameters.
Evaluation Protocol: The paper proposes a plan for future evaluation comparing estimated costs against actual recorded costs in agentic SE projects spanning different autonomy levels, task complexities, and oversight intensities. Evaluation would consider statistical fit, error analysis across project types, and sensitivity to model parameters. Baselines would include traditional estimation models to highlight gaps.
Reproducibility: Currently, ACEM is a theoretical framework without public code, datasets, or empirical results. The author calls on the community to collect data and validate the model robustly.
Example Walkthrough (conceptual): Given a project defined by 100 Story Points, ACEM maps this to a baseline token consumption using calibrated constants. It then applies a Revision Factor of 1.3 to model retries, a Context Factor of 1.5 estimating token growth over sequential agent calls, and a HITL Intensity Score of 2 reflecting moderate human oversight requirements. Multiplying estimated tokens by per-token cost yields LLM cost; HITL cost is computed from expected review hours at a defined labor rate; infrastructure cost is added from cloud usage metrics. Summing all three yields total agentic cost estimate.
Technical innovations
- Decomposition of agentic software engineering costs into three additive dimensions: LLM token cost, HITL cost, and infrastructure cost, reflecting the novel cost drivers specific to AI-driven development.
- Introduction of the Revision Factor (RF) to model the token overhead caused by output rejection and retry cycles unique to stochastic LLM agent pipelines.
- Introduction of the Context Factor (CF) to capture the increasing token consumption due to accumulated contextual information in multi-step agentic workflows.
- Definition of the HITL Intensity Score (HIS), a four-level discrete classification of human oversight effort per task, enabling quantification of human intervention costs.
- Formal mappings from traditional software sizing metrics (Use Case Points, Story Points, Function Points) to estimated LLM token counts, allowing reuse of existing project scoping data in agentic cost forecasts.
Limitations
- ACEM is currently an early-stage theoretical model, with all constants left symbolic pending real-world empirical calibration and validation.
- No empirical datasets have yet been collected or analyzed, so the model's predictive accuracy and practical applicability remain unverified.
- The model does not yet incorporate systematic error modeling or probabilistic uncertainty quantification beyond heuristic correction factors.
- Infrastructure cost modeling follows standard cloud cost estimation approaches and is not a novel contribution; integration complexities with proprietary cloud pricing schemes remain unaddressed.
- Potential variability in HITL effort due to organizational processes, tooling maturity, and developer expertise is simplified into a discrete score, which may not capture fine-grained human cost variation.
- The framework assumes additive independence of cost components, which may overlook complex interactions or feedback loops between token usage, human interventions, and infrastructure scaling.
Open questions / follow-ons
- How to empirically calibrate the Revision Factor, Context Factor, and HITL Intensity Score across diverse agentic SE projects and tasks?
- How well do existing sizing metrics (Use Case Points, Story Points, Function Points) correlate quantitatively with token consumption across heterogeneous agentic pipelines?
- What are the best practices for real-time monitoring and dynamic adjustment of ACEM parameters to reflect evolving agent autonomy and human oversight needs?
- How can ACEM be extended to probabilistically model cost uncertainty and support risk-aware project planning in agentic software engineering?
Why it matters for bot defense
For bot-defense and CAPTCHA practitioners, this paper's insights highlight the changing cost structure when autonomous agents (such as AI bots) perform complex tasks previously done by humans. While the security focus differs, parallels exist in modeling the resource consumption and human oversight involved in multi-step autonomous workflows. ACEM's constructs like Revision Factor and Context Factor provide a conceptual framework to estimate operational costs in scenarios where AI agents interact repeatedly and iteratively, with variable outputs.
Beyond pure cost estimation, the idea of quantifying human review effort via a HITL Intensity Score may inform how much manual intervention is needed to maintain quality or security assurance in automated processes. Practitioners designing systems to detect or mitigate automated abuses could consider how token consumption and iterative retries factor into the cost and detectability of bot-like agentic behavior. Overall, ACEM introduces a structured lens on agentic AI-driven workflows relevant to modeling costs, efficiencies, and oversight in automated interaction settings.
Cite
@article{arxiv2608_02582,
title={ ACEM: A Cost Estimation Model for Agentic Software Engineering },
author={ Mohammad El-Ramly },
journal={arXiv preprint arXiv:2608.02582},
year={ 2026 },
url={https://arxiv.org/abs/2608.02582}
}