---

Abstract #

Teams that must explain and trace production models can rent the capability or build it from open-source parts; we ask what each choice costs in latency, fidelity and money. We benchmarked the estimators that managed tabular services expose (Kernel SHAP, as in SageMaker Clarify, and sampled Shapley with a path count, as in Vertex Explainable AI) against exact TreeSHAP and gradient methods on XGBoost and MLP models trained on the UCI Adult and Wisconsin breast cancer datasets. We then priced span-billed LLM observability plans, at list prices read on 21 October 2026, against a self-hosted open-source stack, and compared their documented trace retention with the six-month log floor of the EU AI Act. Three results stand out. First, exact TreeSHAP explained a 30-feature row in 0.0351 ms, while Kernel SHAP at 4,096 samples took 55.5702 ms, 262.1 times one prediction. Second, sampled Shapley at Vertex’s suggested path count of 25 cost 1.4968 to 1.5876 ms with a normalised error of 4.67% to 5.06% against exact values, and the shap library’s default feature selection raised Kernel SHAP’s error at 1,024 samples from 2.16% to 11.81%. Third, in our base case a self-hosted stack becomes cheaper than managed plans at 2.2 to 5.9 million traced requests per month, and only one of four plans lists retention of six months or more.

1. Introduction #

Our previous article in this series, Causal Graph-Based Observability for Multi-Modal AI Pipelines[1]^[2], treated observability as a data structure: a graph that links symptoms to causes. This article treats it as a purchase. An earlier hub article argued that OpenTelemetry alone does not capture what AI systems need[2]; since then, the market has answered with two kinds of product, and an engineering lead now has to choose between them.

The first kind is the managed explanation service attached to a model-serving platform. Google’s pricing page states that feature-based explanations “come at no extra charge to prediction prices”, but that explanations “take longer to process than normal predictions”, so heavy use with auto-scaling can start more nodes and raise prediction charges[3]^[3]. The second kind is the LLM observability platform, which bills by span, trace or event and stores what the application did. Both have open-source equivalents.

Two developments make the comparison urgent. Google’s documentation now states that Vertex Explainable AI is deprecated as of 16 March 2026 and that access ends on or after 16 March 2027[4]^[4], so teams built on it must move somewhere. And Regulation (EU) 2024/1689 requires high-risk systems to “technically allow for the automatic recording of events (logs)” and requires providers and deployers to keep those logs for at least six months unless other law says otherwise (Articles 12(1), 19(1) and 26(6))[5]^[5]. Retention has become a compliance parameter, not a dashboard setting.

RQ1: How much latency does each explanation estimator add to a single online prediction, comparing the sampling estimators that managed services expose with the exact and gradient methods an in-house stack can run? RQ2: How close do the sampling estimators come to exact Shapley values at the sample budgets those services offer, and does their top-feature ranking agree? RQ3: At what traffic volume does a self-hosted LLM observability stack become cheaper than span-priced managed plans, and which plans document trace retention of six months or more?

2. Existing Approaches (2025–2026 state of the art) #

graph TD
    A[Explanation and observability options] --> B[Managed tabular XAI]
    A --> C[Managed LLM observability]
    A --> D[In-house stack]
    B --> B1[Kernel SHAP endpoint]
    B --> B2[Sampled Shapley and IG]
    C --> C1[Per-span billing]
    C --> C2[Per-unit or per-trace billing]
    D --> D1[Exact TreeSHAP and gradients]
    D --> D2[Amortized explainers]
    D --> D3[OTel GenAI traces in own store]

2.1 Managed attribution services for tabular and vision models #

Two hyperscaler services define this category. SageMaker Clarify states that it uses SHAP and “a scalable and efficient implementation of the Kernel SHAP algorithm”[6]^[6], the model-agnostic estimator introduced with the SHAP framework[7]^[7]. Vertex Explainable AI offers sampled Shapley for non-differentiable models such as tree ensembles, integrated gradients for differentiable models, and XRAI for images[4]^[4]. For sampled Shapley the user sets a path count, “the number of feature permutations”, between 1 and 50; the documentation says a higher value “might reduce approximation error but is more computationally intensive” and suggests 25[8]^[8]. Monitoring is a separate charge: Vertex bills model monitoring at $3.50 per GB of data analysed[3]^[3], and AWS’s Model Monitor paper describes managed detection of feature-attribution drift as part of the same family of services[9]^[9]. The weakness is structural: a service that accepts any model container must fall back on sampling estimators.

2.2 Exact and gradient explainers in open-source libraries #

An in-house team that controls the model class can use exact algorithms. TreeSHAP computes exact Shapley values for tree ensembles in polynomial time[10]^[10], and integrated gradients needs only “a few calls to the standard gradient operator” for differentiable networks[11]^[11]. Captum packages gradient and perturbation methods for PyTorch with memory-efficient, scalable computation[12]^[12]. Recent work makes model-agnostic estimation cheaper. Leverage SHAP gives provable accuracy with O(n log n) model evaluations and reports about 50% lower error than the shap library’s Kernel SHAP[13]^[13]. Amortized explainers train a network to output attributions in one pass: FW-Shapley reports 14 times faster data valuation at quality comparable to KNN Shapley[14]^[14], and OperatorSHAP extends the idea to neural operators because Shapley computation “during inference hinders their practical use”[15]^[15]. Streaming systems can also go exact: Incremental Delta-Shapley matches exhaustive enumeration to floating-point precision and is up to 4.3×10^5 times faster than per-window rescans[16]^[16].

2.3 Attribution for LLM applications #

For generative models, Shapley methods attribute output to prompt tokens or retrieved documents. TokenSHAP applies Monte Carlo Shapley estimation to substrings of a prompt[17]^[17]; MaxShapley uses a decomposable utility to attribute generative-search answers to sources in polynomial time, with up to a 9 times reduction in resource consumption at equal attribution accuracy[18]^[18]. Each attribution needs many extra model calls, so its cost scales with token prices; commercial LLM observability products sell traces, evaluations and retention instead.

2.4 LLM observability platforms and the OpenTelemetry layer #

The AgentOps literature defines what such platforms must record. A 2024 systematic mapping of AgentOps tools produced a taxonomy of artefacts to trace across an agent’s lifecycle[19]^[19], and a 2025 vision paper proposes a six-stage pipeline from behaviour observation to runtime automation[20]^[20]. Instrumentation is converging on OpenTelemetry: the GenAI semantic conventions, which now live in their own repository, still carry the status “Development”, and capture of message content is an explicit opt-in[21]^[21]. Research tools build on that layer, from fault injection over OTel traces for multi-agent systems[22]^[22] to readiness harnesses that combine OTel telemetry with CI quality gates on groundedness, cost and p95 latency[23]^[23]. AgentSight shows that tracing without code instrumentation is possible, using eBPF at under 3% performance overhead[24]^[24].

The vendors differ mainly in the billing unit. Datadog Agent Observability bills “only on LLM spans, not on tool spans, retrieval spans, or other workflow spans”[25]^[25]. Langfuse counts “any tracing data point”, including traces, observations and scores, as a billable unit[26]^[26]. LangSmith charges per seat and per trace, with base traces kept 14 days and extended traces 180 days[27]^[27]. The gaps are documented as well: platforms record traces but offer no structured labelling, which is why one 2026 workbench imports OTel GenAI, LangSmith and Langfuse traces to annotate them[28]^[28], and OTel JSON itself is verbose enough that an agent-oriented encoding cut wire payload by 96.4%[29]^[29].

2.5 Evaluation inside the observability loop #

Managed platforms increasingly bundle online evaluation by LLM judges. A production rubric-based judge spanned $0.45 to $78.96 per 1,000 evaluations, a 175-fold range, across 20 model configurations[30]^[30]. Judges agree with experts mainly on questions they can answer themselves unless given expert references[31]^[31], and a preregistered audit of black-box judges on shared endpoints found same-window repeat rankings agreeing at Spearman 0.400 against a required 0.90[32]^[32].

3. Method and Data #

All code, data and outputs are at stabilarity/hub/research/explainability-as-a-service-comparing-managed-xai-platforms-against-in-house-observability-stacks. The script runs offline and writes every number below to results.json.

Models and data. We trained XGBoost classifiers (200 trees, depth 6) on the UCI Adult census data (32,561 rows, 14 features, test AUC 0.9272) and on the Wisconsin breast cancer data shipped with scikit-learn (569 rows, 30 features, test AUC 0.9977), plus a 64-64 ReLU network on standardised Adult features (test AUC 0.9021).

A common target. Every estimator explains the log-odds output relative to one baseline row, the training median. This makes the exact answer computable: interventional TreeSHAP with that single baseline, which we checked against brute-force enumeration of all 2^14 coalitions on Adult (maximum absolute difference 6.4×10^-7). For the network, the reference is the brute-force exact Shapley value.

Estimators. Kernel SHAP at 64, 256, 1,024 and 4,096 samples (shap 0.54.1, feature selection off, plus one run with the library default); permutation-sampling Shapley at path counts 1, 5, 10, 25 and 50, our implementation of the algorithm behind Vertex’s parameter; path-dependent TreeSHAP built into XGBoost; and, for the network, Captum saliency, integrated gradients (32 steps), GradientSHAP (16 samples) and input times gradient relative to the baseline. We did not call either vendor’s endpoint, so the benchmark measures the algorithms they document, not their services.

Metrics. For 40 test rows per method we took the median of three single-row timings, then report the median and p95 across rows, the multiple of one prediction, the normalised mean absolute error (nMAE, mean absolute error divided by mean absolute exact attribution), the Spearman correlation of absolute attributions and the overlap of the top three features. Hardware: an AMD EPYC virtual machine at 2.0 GHz, one thread, Python 3.12.

Cost model (our estimate). Each traced request carries one trace, four LLM spans, six other spans and one evaluation score. Managed costs use list prices read on 21 October 2026: Datadog Pro at $160 per month with 100,000 LLM spans and $3.50 per additional 10,000 on an annual plan, or $240 and $5 on demand[25]^[25]; Langfuse Core at $29 per month with 100,000 units and graduated overage of $8, $7, $6.50 and $6 per 100,000 units[26]^[26]. LangSmith is excluded from the cost curve because its page lists no per-trace overage price[27]^[27]. The self-hosted stack is three m7i.xlarge instances at $0.2016 per hour plus one m7i.2xlarge at $0.4032 per hour for each started block of 100 million units per month[33]^[33], a 25% uplift for storage and backups, and 0.25 of a full-time engineer at the US median software-developer wage of $135,980 (May 2025)[34]^[34] times a 1.3 loading factor. We vary the engineering share from 0.10 to 0.50 and the LLM spans per request from 2 to 8.

graph LR
    A[Public datasets] --> B[XGBoost and MLP models]
    B --> C[Exact Shapley reference]
    B --> D[Sampling and gradient estimators]
    C --> E[Latency and fidelity metrics]
    D --> E
    F[Vendor price pages] --> G[TCO model]
    H[EC2 prices and BLS wage] --> G
    G --> I[Crossover volumes]
    F --> J[Retention vs six-month floor]

4. Results #

4.1 RQ1: the latency of an explanation #

The spread between estimators covers more than three orders of magnitude for the same model and the same row (chart 1). On the 30-feature breast cancer model, exact TreeSHAP took a median 0.0351 ms, less than our 0.212 ms single-row prediction call, whose time is mostly per-call overhead of the prediction interface. Kernel SHAP took 4.1341 ms at 64 samples, 18.2766 ms at 1,024 and 55.5702 ms at 4,096, which is 262.1 times a prediction and a p95 of 62.3581 ms. Sampled Shapley sat between them: 1.5876 ms at path count 25 (7.5 times a prediction) and 2.8926 ms at 50.

On the 14-feature Adult model the ordering held but compressed. Exact TreeSHAP took 0.1083 ms, sampled Shapley at path count 25 took 1.4968 ms (8.1 times a prediction), and Kernel SHAP stayed between 2.6 and 3.2 ms at every budget, because with 14 features the per-call overhead of the library dominates the model evaluations. Path-dependent TreeSHAP through XGBoost’s native interface took 1.2581 ms on Adult and 0.3248 ms on breast cancer, mostly input-matrix construction.

For the network, saliency took 0.2643 ms, GradientSHAP 0.8197 ms and integrated gradients with 32 steps 2.01 ms (59.6 times the 0.0337 ms prediction); brute-force exact Shapley took 28.2566 ms, affordable offline but not on a request path.

Estimator (breast cancer XGBoost, 30 features)	Median latency, ms	Multiple of one prediction	nMAE vs exact, %	Top-3 overlap, %
Exact TreeSHAP, 1 baseline	0.0351	0.2	0.00 (reference)	100.0
Sampled Shapley, path count 1	0.2576	1.2	23.14	85.0
Sampled Shapley, path count 25	1.5876	7.5	4.67	96.7
Sampled Shapley, path count 50	2.8926	13.6	3.05	95.8
Kernel SHAP, 64 samples	4.1341	19.5	43.16	90.8
Kernel SHAP, 1,024 samples	18.2766	86.2	2.16	99.2
Kernel SHAP, 1,024 samples, library default top-10 feature selection	17.9379	84.6	11.81	96.7
Kernel SHAP, 4,096 samples	55.5702	262.1	1.01	100.0

Source: our benchmark, results.json; one CPU thread, 40 rows per method.

Converted to money, compute is the smallest line item. At the per-vCPU share of an m7i.xlarge, the slowest estimator in the table costs $0.778 per million explanations and sampled Shapley at path count 25 costs $0.0222 (our estimate). The binding constraint is latency and node count, which is what Google’s pricing note warns about[3]^[3].

4.2 RQ2: what the sampling budget buys #

The two sampling families trade differently (chart 2). Sampled Shapley’s error fell steadily with path count: on breast cancer from 23.14% at one path to 4.67% at 25 and 3.05% at 50, and on Adult from 27.53% to 5.06% and 3.44%. Rank agreement was high from the start, with Spearman correlations of 0.9597 at one path and 0.9979 at 25 on breast cancer, but top-three overlap at path count 25 was 96.7% and 98.3% on the two models. In other words, at Vertex’s suggested setting, roughly one row in 10 to 20 gets a top-three list that differs from the exact one by one feature.

Kernel SHAP was poor at small budgets on the wider model, with an error of 43.16% and a Spearman correlation of 0.7382 at 64 samples, and from 1,024 samples it beat every path count on error, 2.16% at 1,024 and 1.01% at 4,096, at six or more times the latency of path count 50. On Adult, with 14 features, it was close to exact from 256 samples (0.26%). The library default deserves a warning. With the regularisation parameter left at its default, the error at 1,024 samples on breast cancer rose from 2.16% to 11.81% and the Spearman correlation fell from 0.9427 to 0.8764, because since version 0.47 the default keeps only the ten strongest features and sets the rest to zero. A team that relies on a managed endpoint cannot see which of these settings it gets unless the documentation says so.

Gradient methods answer a different question, so their gap to Shapley values is disagreement, not error. Integrated gradients reached a Spearman correlation of 0.9808 and 94.2% top-three overlap with exact Shapley on the network, GradientSHAP 0.9826 and 94.2%, while raw saliency had 0.3099 and 54.2%. That agrees with the disagreement problem documented for practitioners[35]^[35] and with 2025 work showing LIME and SHAP disagreeing on structured geophysical data[36]^[36]. Fidelity to a Shapley reference is also not the same as usefulness: in a 2026 fraud-review study with 3,735 case reviews, standard metrics such as faithfulness were decoupled from analysts’ perceived clarity, and no Shapley variant improved objective performance[37]^[37].

4.3 RQ3: when self-hosting pays, and who keeps logs for six months #

Managed plans win at low volume because the self-hosted stack carries a fixed engineering cost (chart 3). In the base case the self-hosted stack costs $4,602.59 per month up to 8.3 million requests, of which $3,682.79 is engineering time and $919.80 is infrastructure. At one million traced requests per month, Langfuse Core costs $861, Datadog Pro $1,525 on an annual plan and $2,190 on demand. At ten million, the order reverses: $7,531, $14,125 and $20,190 against $4,970.51 for self-hosting.

Plan (list prices, 21 Oct 2026)	Base, USD/month	Included volume	Overage	Default retention, days	Longest listed retention, days	Cost at 1M requests/month, USD	Crossover, M requests/month (0.10–0.50 FTE)
Datadog Agent Observability Pro, annual	160	100,000 LLM spans	$3.50 per 10,000	15 (90 with commitment)	90	1,525	3.2 (1.6–5.8)
Datadog Agent Observability Pro, on demand	240	100,000 LLM spans	$5.00 per 10,000	15	90	2,190	2.2 (1.1–4.0)
Langfuse Cloud Core	29	100,000 units	$8 to $6 per 100,000, graduated	90	90	861	5.9 (3.0–11.6)
Langfuse Cloud Pro	199	100,000 units	same as Core	1,095 (data access)	1,095	not modelled	not modelled
LangSmith Plus	39 per seat	10,000 base traces	not listed	14	180	not modelled	not modelled
Self-hosted, base case (our estimate)	4,602.59	not applicable	+1 node per 100M units	set by operator	set by operator	4,602.59	not applicable

Sources: [25]^[25], [26]^[26], [27]^[27]; crossover and self-hosted figures from results.json. Datadog’s plan card lists 15-day retention; its FAQ states 3 months with an annual or month-to-month commitment.

The crossover is most sensitive to engineering time and to how chatty the application is. For Datadog’s annual plan it moves from 3.2 million requests per month in the base case to 1.6 million at 0.10 of an engineer and 5.8 million at 0.50. Because Datadog bills only LLM spans, an agent that makes eight model calls per request reaches the crossover at 1.6 million requests and one that makes two at 6.4 million. Langfuse bills every observation, so the same change moves its crossover less, from 4.5 to 7.1 million.

Retention separates the plans more sharply than price (chart 4). Only Langfuse Pro, with three years of data access, lists a period above six months. LangSmith’s extended traces stop at 180 days, just short of six calendar months; Datadog’s listed add-ons stop at 90 days; Langfuse Core stops at 90. This does not prove non-compliance: the six-month duty applies to high-risk systems and to logs “under their control”, and exporting traces elsewhere can meet it[5]^[5]. It does mean that a team on a default plan must build an archive anyway, which weakens the case for renting.

5. Discussion #

What the numbers mean for practitioners. The managed tabular services sell generality: one explainer for any container. For the most common production model class, gradient-boosted trees, that generality costs between 7.5 and 262.1 predictions’ worth of latency per explanation and a 1% to 5% approximation error, where the exact answer took less time than our prediction call. A team that serves tree models and needs per-request explanations has little reason to rent a sampling estimator. The calculation flips for heterogeneous fleets and for containers the team cannot instrument. With Vertex Explainable AI on a published deprecation path[4]^[4], migration cost belongs in the comparison too: an open-source explainer behind one’s own endpoint is the only option here with no vendor end-of-life date.

For LLM observability, the decision is mostly about volume and retention. Below about one million traced requests per month every managed plan we priced is cheaper than our base-case self-hosted stack by a factor of two or more; above six million, every one is more expensive. The band between is wide because engineering effort is both the largest and the least certain cost.

graph TD
    A[Need explanations or traces] --> B{Model class you control?}
    B -->|Trees or differentiable| C[In-house exact or gradient explainer]
    B -->|Opaque containers| D[Managed sampling explainer]
    D --> E{Path count or sample budget documented?}
    E -->|No| F[Validate against an exact reference offline]
    A --> G{Traced requests per month}
    G -->|Under 1M| H[Managed plan]
    G -->|1M to 6M| I[Price both with your own FTE estimate]
    G -->|Over 6M| J[Self-hosted OTel stack]
    H --> K{High-risk system under the AI Act?}
    K -->|Yes| L[Plan with 6 months retention or an export archive]

Explanations have known blind spots as a monitoring signal. A 2026 monitoring study showed that TreeSHAP attributions can stay stable while false-positive rates spike for protected groups under drift[38]^[38], and faithfulness metrics for natural-language explanations vary in diagnostic power across tasks and models[39]^[39]. Legal scholarship warns that regulation built around explainability can turn into box-ticking when the methods themselves are unreliable[40]^[40]. A systematic review of the EU right to explanation found that of 57 full texts reviewed, only 19 integrated legal and technical perspectives substantively[41]^[41], and an analysis of the AI Act’s transparency mandates for oversight bodies argues that they implement qualified transparency while leaving several challenges open[42]^[42]. Attributions should therefore feed alerts alongside performance metrics, not replace them, and open-source pipelines already do so: one MLOps framework blocks deployment when demographic parity difference exceeds 0.05 and deploys explainability artefacts alongside those fairness gates[43]^[43], and an OpenTelemetry-based governance layer maps hashed trace evidence to Articles 12, 14, 19, 26(6) and 50 of the AI Act[44]^[44].

Limitations and threats to validity. The benchmark uses two tabular datasets, one tree configuration and one small network, timed on one CPU thread in Python, which inflates Kernel SHAP’s fixed overhead. Our sampled-Shapley code is not either vendor’s implementation, and network and service overhead of managed endpoints are excluded. Prices are one day’s list prices; all three vendors mention volume or commitment discounts. The self-hosted infrastructure sizing and the engineering share are assumptions, which is why we report the 0.10 to 0.50 FTE band rather than a point.

What would change the conclusion. A managed service offering exact TreeSHAP for tree models would close most of the RQ1 gap. A team that already runs ClickHouse and OpenTelemetry collectors has a lower marginal engineering cost, which moves its crossover towards the 1.1 to 3.0 million end of our range.

6. Conclusion #

RQ1 Finding: The sampling estimators that managed tabular services document add far more latency than exact in-house methods for tree models. Measured by median single-row latency = 0.0351 ms for exact TreeSHAP against 1.5876 ms for sampled Shapley at path count 25 and 55.5702 ms for Kernel SHAP at 4,096 samples on a 30-feature model (262.1 predictions). This matters for the series because explanation latency, not compute price, is what sets node counts on a serving path.

RQ2 Finding: At the budgets managed services suggest, sampling estimators are close to exact values but not identical, and library defaults matter. Measured by normalised mean absolute error = 4.67% to 5.06% at path count 25 (top-three overlap 96.7% to 98.3%), and 11.81% instead of 2.16% for Kernel SHAP at 1,024 samples with the library’s default feature selection. This matters for the series because an attribution monitor inherits the approximation error of whatever estimator feeds it.

RQ3 Finding: Self-hosting LLM observability pays only at millions of traced requests per month, and retention, not price, is where managed defaults fall short of the AI Act’s six-month floor for high-risk systems. Measured by base-case crossover = 2.2 to 5.9 million requests per month (1.1 to 11.6 million across the sensitivity range), and 1 of 4 priced plans listing retention of six months or more. This matters for the series because the observability stack is becoming a compliance record, and its retention must be chosen with the law in view.

The next question for this series is how to monitor the monitors: measuring the drift and reliability of attribution and judge signals themselves before alerts are built on them.