AI consumption cost model

Purpose

This article presents the AI consumption cost associated with running the Cubyts platform in customer landscapes. The objective is to provide a transparent, repeatable, and customer-specific method for estimating AI costs rather than relying on a top-down platform-level assumption.

The model is built bottom-up from the Cubyts platform implementation. Each model invocation point has been identified, its expected input and output token consumption estimated, and the configuration parameters that influence consumption documented. These unit-level costs are then applied to customer-specific volumes to derive the expected cost at the workspace level.

Costing Methodology

The costing model follows a four-step approach:

1. Identify AI consumption points
   Model invocation sites within the Cubyts platform are identified across the relevant workflows.

2. Estimate token consumption
   Input and output token volumes are estimated for each invocation. Consumption is expressed using measurable operational units such as files, pull requests, repositories, and branches.

3. Apply the applicable price book
   Token consumption is converted into monetary cost using the pricing applicable to the models and providers used by the platform.

4. Scale using customer volumes
   Unit costs are rolled up using the customer's actual operating profile, including repository and branch volumes, pull request activity, team size, sprint cadence, and other relevant consumption drivers.

This approach allows the cost estimate to be traced from the customer profile through consumption assumptions to the resulting AI cost.

Cost Units

The model expresses consumption at the operational level at which it is generated:

• Per file — AI consumption associated with processing an individual file.

• Per pull request — AI consumption associated with analysing an individual pull request and its related artefacts.

• Per repository/branch onboarding — one-time AI consumption associated with onboarding repositories and their branches.

• Per workspace — the resulting cost after applying the above unit costs to the customer's operating volumes.

This structure makes it possible to calculate costs for customers with different repository sizes, engineering team structures, and levels of development activity without changing the underlying methodology.

One-Time and Recurring Costs

The model distinguishes between one-time onboarding consumption and recurring steady-state consumption.

One-Time Onboarding

Onboarding costs represent the AI consumption incurred when repositories and branches are initially processed by the Cubyts platform.

The calculation is driven primarily by the number of repositories and branches being onboarded and the volume of files and other artefacts that require AI processing.

Steady-State Operation

Steady-state costs represent the recurring AI consumption generated during normal platform operation.

These costs are driven by ongoing customer activity, including pull requests, code changes, repository activity, sprint cadence, and other configured workflows.

Separating these two categories prevents one-time onboarding consumption from being incorrectly treated as a recurring operating expense.

Customer-Specific Inputs

The workspace-level cost is calculated using the customer's own operating profile. Relevant inputs include, where applicable:

• Number of repositories

• Number of branches

• Number of pull requests

• File/codebase volumes

• Engineering team size

• Sprint cadence

• Repository activity

• Other configuration parameters that influence AI consumption

The same methodology can therefore be applied to different customer landscapes without assuming that all customers have the same engineering footprint or usage pattern.

Statistical Basis

p50 (median) consumption is used as the baseline throughout the model. This represents the central expected consumption level and avoids using unusually high-consumption observations as the default case.

Where sufficient data is available, p95 consumption is shown separately to provide visibility into a higher-consumption scenario.

Maximum consumption is not used as the baseline. A maximum can be disproportionately influenced by outliers and does not provide a representative basis for estimating normal customer consumption.

Where an input has not yet been measured or sufficiently validated, it is explicitly identified as unknown. Unknown inputs are not treated as zero and are not replaced with an unstated assumption.

Price Book

The monetary cost is derived using the price book for the models and providers used by the Cubyts platform.

The price book is maintained separately from customer volumes and consumption assumptions so that the model remains transparent and can be recalculated if the underlying model/provider pricing changes.

Accordingly, the total estimated cost can be understood as:

Customer Volume × AI Consumption per Unit × Applicable Model Price

with the calculation performed at the relevant consumption level and then aggregated to the workspace.

Supporting Workbooks

Two workbooks accompany this article and provide the detailed calculations and assumptions behind the model.

Workbook 1 — One-Time Onboarding and Steady-State Cost

This workbook provides the calculated cost for a defined customer profile. It presents the one-time cost of repository and branch onboarding separately from the recurring cost of steady-state operation.

The workbook exposes the material assumptions used in the calculation, including customer volumes, token consumption, model/provider pricing, and the applicable p50 and p95 values.

Workbook 1 — Onboarding and Steady-State Cost

Workbook 2 — Cost Calculator

This workbook provides a self-service mechanism for customers to model AI consumption.

Customers can enter their own operating volumes, including repositories, branches, pull requests, team size, sprint cadence, and other relevant drivers. The calculator then applies the same consumption assumptions and price book used in the primary model to derive the corresponding cost.

Workbook 2 — Cost Calculator

Using the Cost Model

The model should be used as a transparent consumption-based estimate, not as a fixed or guaranteed cost.

The estimated cost for a customer will change when the underlying consumption drivers change. In particular, differences in repository size, number of branches, pull request volumes, team activity, configuration, model selection, and token consumption can materially affect the result.

Assumptions and Limitations

The accuracy of the estimate depends on the quality of the underlying measurements and customer inputs.

The model therefore follows these principles:

• Measured values are preferred over assumptions.

• Median (p50) values are used as the baseline.

• Maximum values are not used as the baseline.

• Unknown inputs remain explicitly identified as unknown.

• Customer-specific volumes should be used whenever available.

• Model and provider pricing should be updated when the applicable price book changes.

• Estimates should be recalculated when significant platform configuration or AI workflow changes are introduced.

This ensures that the AI consumption estimate remains traceable, reproducible, and adaptable to the customer's actual operating landscape.