The Two-Ledger Model: Transaction-Grain Cost Accounting for Multi-Agent AI Systems Across Clouds, Models, and Systems of Record

Vivek AcharyaarXiv 2026 · arXiv

TL;DR

The Two-Ledger Model bridges the gap between aggregated AI billing and granular business transactions by joining a "settlement ledger" (standardized billing data) with an "attribution ledger" (runtime telemetry). This approach allows enterprises to calculate the exact AI cost of a specific order or claim, identify "shadow AI" spend, and use predictive gating to slash the costs of runaway agentic loops by over 60%.

What Problem Does This Paper Address?

As enterprises deploy complex, multi-agent AI systems, they face a "grain mismatch" problem. Finance departments receive AI invoices at the settlement grain—monthly totals aggregated by provider and SKU. However, business leaders need to understand costs at the transaction grain—for example, "How much did AI contribute to the cost of processing Order #48812?"

Because AI providers (like AWS, Azure, or OpenAI) cannot see internal enterprise transaction boundaries, their billing data lacks the context needed for unit economics. Existing standards like FOCUS (for billing) and OpenTelemetry (for runtime traces) are necessary but insufficient on their own: billing data lacks transaction IDs, while telemetry lacks pricing and invoice reconciliation.

Methods

The paper proposes the Two-Ledger Model, an architectural framework that maintains two distinct datasets joined by a novel Correlation Spine:

  1. Settlement Ledger: A lake of billing data normalized to the FOCUS standard. This is the "source of truth" for what was actually paid.
  2. Attribution Ledger: A runtime record of every model invocation, priced in near-real-time using a versioned Rate Card. It captures token counts and metadata using OpenTelemetry GenAI conventions.
The Two-Ledger Model joins billing and runtime data to provide business-language cost semantics.

The Correlation Spine is the "glue" that assigns model calls to business transactions across four layers of decreasing certainty:

  • L1: W3C Trace Context (direct technical propagation).
  • L2: Protocol metadata (A2A/MCP headers).
  • L3: Business-key correlation (matching order numbers or case IDs).
  • L4: Probabilistic matching (using timing and workload fingerprints as a last resort).
Fig. 2. Deployment reference architecture. Left: the runtime attribution path (execution →gateway metering →attribution ledger →correlation/allocation →unit economics). Right: the settlement path (provider billing →FOCUS lake →reconciliation →close). Middle: shared services — business events from systems of record, the versioned rate card, and the taxonomy and identity registry. The dashed return edge is the budget-gate feedback from cost SLOs to the gateway; inference traffic from the gateway to provider endpoints is omitted for clarity (see Fig. 1).

Datasets

The authors evaluated the model using a synthetic simulation study because no public datasets currently combine multi-cloud AI billing with internal enterprise transaction logs.

  • Generator: Produced 20,000 business transactions (Order-to-Cash, Procure-to-Pay, etc.).
  • Scale: Resulted in 109,792 model invocations across seven systems of record and three cloud providers.
  • Ground Truth: Every record carried its true business transaction ID, allowing for precise measurement of correlation accuracy and reconciliation recovery.

Key Insights and Ideas

  • Shadow AI Detection: By subtracting the attributed cost from the total bill, the model produces a "reconciliation residual." This residual identifies exactly how much AI spend is happening outside of sanctioned, metered paths.
  • Agentic Cost Metrics: The paper introduces three new metrics for multi-agent systems:
  • Token Efficiency (TE): Ratio of final output tokens to total tokens consumed.
  • Coordination Overhead (CO): The cost of agents planning and talking to each other vs. doing productive work.
  • Rework Cost (RW): The cost of failed or retried steps.
  • Mid-Flight Gating: By using a forecaster to estimate the total cost of a transaction while it is still running, the system can "pause" or terminate transactions that are likely to exceed their budget (e.g., an agent stuck in a runaway loop).

Key Results

  • Correlation Coverage: The layered spine maintained >99% cost coverage even when standard trace propagation fell to zero.
  • Reconciliation Accuracy: The model recovered "planted" unmetered spend (shadow AI) within 0.24 percentage points of the actual bill.
  • Cost Control: Mid-flight gating reduced the p99 transaction cost by 61% and total spend by 9.3%, while only pausing ~4% of transactions that would have finished within budget.
  • Billing Error Detection: The two-sided reconciliation successfully flagged provider overbilling errors at the exact planted amounts.

Limitations and Future Work

  • Simulation vs. Reality: The results are based on synthetic data. A real-world field pilot is needed to measure actual correlation precision and "collision rates" of business keys in production environments.
  • Standards Maturity: The model relies on FOCUS 1.5 and OpenTelemetry GenAI conventions, both of which were in development or pre-ratification at the time of writing.
  • Overhead Costs: The paper does not deeply explore the transaction-amortized costs of fine-tuning, embedding refreshes, or vector database storage, focusing primarily on inference.
  • L4 Benchmarking: Further work is required to benchmark the accuracy of the probabilistic matching layer (L4) across different types of enterprise workloads.

Summary updated

Abstract

Enterprises run business transactions through multi-agent AI systems spanning clouds, large language models (LLMs), orchestration harnesses, and systems of record. Finance receives AI cost only at settlement grain, aggregated by SKU and charge period. The business question (what did this order, claim, or case cost in AI?) cannot be answered from billing data, because providers never see enterprise transaction boundaries. The FinOps Open Cost and Usage Specification (FOCUS) gives billing data one schema across providers but remains settlement-grain even as it adds AI token and requester attribution. We formalize this grain mismatch, derive seven requirements, and propose the Two-Ledger Model: a settlement ledger of FOCUS-conformant billing data joined to an attribution ledger of invocation-grain usage records built on OpenTelemetry GenAI telemetry. A layered correlation spine (trace context, A2A/MCP metadata, business-key correlation, probabilistic matching) assigns each record to its business transaction with recorded method and confidence; a versioned rate card prices usage in near real time; period reconciliation ties both ledgers to the invoice, and the unexplained residual identifies shadow AI. Costs are reported per order, claim, or outcome with agentic cost metrics. A simulation with known ground truth shows the spine sustaining cost coverage above 99% as trace propagation falls to zero, the reconciliation residual recovering planted unmetered spend within 0.24 percentage points while flagging provider billing errors, and mid-flight gating cutting p99 transaction cost by up to 61% at a 2-4% false-pause rate. We propose the attribution ledger as an invocation-grain FOCUS profile for standardization.
BibTeX
@misc{acharya2026two,
  author = {Vivek Acharya},
  title = {{The Two-Ledger Model: Transaction-Grain Cost Accounting for Multi-Agent AI Systems Across Clouds, Models, and Systems of Record}},
  year = {2026},
  eprint = {2611.06989},
  archivePrefix = {arXiv},
  url = {https://arxiv.org/abs/2611.06989},
}
Figure