Skip to content
SearchSubscribe
TPL-2026-013·preprint·2026-05-01

Cost-per-Artifact Curves Across Claude Model Tiers (Opus 4.7 / Sonnet 4.6 / Haiku 4.5)

cost-optimizationmodel-selectionLLM-agentsmethodologycross-venture

Abstract

Selecting the right Claude model tier for a given artifact type is the single highest-impact cost decision an operator makes in an agent-mediated workflow. We analyze cost-per-completed-artifact data across 312 artifact production runs spanning six task types (greenfield drafting, debugging, code review, research synthesis, structured extraction, and configuration authoring) and three Claude tiers (Opus 4.7, Sonnet 4.6, Haiku 4.5) in the TruPath portfolio. Cost-per-artifact curves diverge sharply by task type: Sonnet 4.6 dominates greenfield drafting and structured extraction; Opus 4.7 dominates complex debugging and novel-architecture decisions; Haiku 4.5 followed by Opus escalation outperforms both single-tier strategies for code review. A routing matrix derived from these findings is estimated to reduce portfolio-wide LLM spend by 31–44% at constant output quality. All figures are illustrative; see §5.

1. Introduction

The proliferation of LLM model tiers within a single provider’s lineup has created a new class of cost-optimization decision for operators of agent-mediated workflows. Anthropic’s Claude family now spans three tiers — Haiku (fastest, cheapest), Sonnet (balanced), and Opus (most capable, most expensive) — with published capability and pricing that differ by approximately an order of magnitude between Haiku and Opus [3]. The naive approach is to default to a single tier for all tasks. Most operators who think carefully default to Sonnet as a middle ground. Neither strategy is cost-optimal.

The theoretical case for tier-routing is straightforward: task types differ in the capability requirements they impose on the model. A task that requires only template-completion (config authoring, structured field extraction) imposes minimal reasoning demands; the cost-per-artifact on Haiku will be low, and quality will be adequate. A task that requires multi-step causal reasoning under uncertainty (debugging a firmware-CV protocol mismatch; architecting a novel multi-sensor design) places high demands on the model; Haiku will fail at high rates, and the true cost of using Haiku — including the cost of failed attempts, escalation, and rework — will exceed the cost of using Opus directly. The optimal routing strategy uses the cheapest tier that meets the quality bar for each task type [6].

Empirical work on LLM cascade routing [7] and model selection [5] establishes that routing is effective in principle, but most published work uses open-ended benchmarks rather than the artifact-production workflows typical of a small-company operator. This paper presents cost-per-artifact curves from the TruPath portfolio — three ventures (Quantum Caddy, Mile High Golf, Parley / TruPath cross) spanning engineering, operations, and research work types — to derive a practical routing matrix. This extends the token-economics analysis in [8] with the addition of quality measurement and the Haiku tier.

2. Methods

2.1 Artifact taxonomy

We define six task types based on the operator’s workflow across the TruPath portfolio. The taxonomy is not exhaustive — it covers the six task types that together represented more than 85% of agent-hours over the measurement window. Table 1 defines each type with its input structure, acceptance criterion, and quality metric.

InputAcceptance criterionQuality metricn runs
Greenfield draftingProduct spec or intent description, no prior codeOperator accepts output as starting point without major rewrite% accepted without rework; rework-hour delta62
DebuggingFailing test, error log, or unexpected behavior description + relevant codebase contextRoot cause identified and fix verified by passing test or operator judgment% first-pass correct; passes-to-resolution58
Code reviewDiff or file set with review promptReview catches all operator-known issues; no false positives causing unnecessary reworkRecall vs. known issues; false-positive rate44
Research synthesisSet of source documents + synthesis questionOutput accurately synthesizes sources without hallucination; operator rates fidelityFidelity score (0–100, operator-rated)48
Structured extractionUnstructured document + target JSON schemaAll required fields populated; no hallucinated valuesField accuracy %; hallucination rate58
Config authoringIntent description + existing config templateOutput is syntactically valid; all intent-specified values presentSyntax-valid %; intent-compliance (%)42
Table 1 — Artifact taxonomy and data-collection methodology. Each task type is defined by its input, acceptance criterion, and the metric used to assess quality. Quality scoring was performed by the principal operator immediately after the session, using the rubric described in §2.2.

Total n=312. Runs distributed across three TruPath ventures: QC (firmware, CV config, debugging), MHG (document synthesis, research, extraction), TruPath cross-portfolio (drafting, review, config). Venture distribution not stratified — reflects actual workload distribution.

2.2 Quality scoring

Quality was assessed immediately after each run by the principal operator using a structured rubric. The rubric asked three questions: (1) was the output accepted without rework? (2) if rework was required, how many minutes? (3) did the output hallucinate any fact, value, or code path that was not present in the input? Responses to these three questions were combined into a 0–100 quality score: acceptance without rework = 100; acceptance with minor rework (<15 min) = 75–99; acceptance with major rework (15–60 min) = 40–74; rejection requiring full redo = 0–39.

Quality scoring is operator-subjective and therefore susceptible to inconsistency. We tested inter-session consistency by re-scoring a random sample of 20 outputs at the end of the measurement window (without access to the original scores) and found a mean absolute deviation of 6.4 points on the 0–100 scale, which we consider acceptable for the within-category comparisons the paper relies on.

2.3 Cost capture

Token costs were captured from session logs at the time of each run. For sessions that included escalation (a Haiku run followed by an Opus retry), the total cost included both runs. Engineering-hour cost was not included in the primary cost-per-artifact metric — the paper reports token cost only, with engineering-hour opportunity cost discussed separately in §3.4.

2.4 Illustrative data disclosure

All specific numeric values in this paper are illustrative figures synthesized from portfolio cost logs and professional judgment, not directly instrumented per-run measurements. The directional structure (which tiers dominate which task types, where escalation rates are high vs. low) is grounded in actual operator experience. See §5 for a full limitations statement.

3. Results by Task Type

Figure 10.000.501.001.502.002.503.00COST PER ARTIFACT ($)2.400.821.45Greenfield draft1.101.682.20Debugging1.800.950.74Code review2.100.911.30Research synthesis1.950.440.31Struct. extraction1.600.550.28Config authoringOpus 4.7Sonnet 4.6Haiku 4.5
Figure 1 — Cost-per-completed-artifact by model tier and task type (illustrative, n=312 runs). Each group is one task type; bars within a group show the three model tiers. Sonnet 4.6 achieves the lowest per-artifact cost for greenfield drafting and structured extraction. Opus 4.7 is cost-competitive on complex debugging (where Sonnet frequently requires a second pass) but dominates on novel architecture decisions. Haiku 4.5 is cheapest on code review but escalation rate is high. Numbers are illustrative; see §5.

3.1 Greenfield drafting

Sonnet 4.6 dominates this category at $0.82/artifact vs. $2.40 for Opus 4.7. The cost difference reflects not just per-token pricing but the fact that Sonnet produces drafts that are accepted at approximately the same quality rate as Opus for well-specified prompts. Haiku underperforms here: at $1.45 blended (including escalation), Haiku is more expensive than Sonnet on a per-accepted-artifact basis because the escalation rate to Opus is 71% — Haiku drafts frequently lack the structural coherence needed for a usable starting point.

The practical implication: for greenfield drafting, start on Sonnet. Escalate to Opus only when the spec is genuinely novel or the domain is one where Sonnet has shown pattern-following failure (e.g., novel hardware protocol design vs. standard CRUD endpoint authoring). The QC pattern confirms this: Sonnet authored the initial detector post-processing pipeline at approximately $0.90/component; the handful of Opus sessions (novel multi-sensor design work) cost $2.10–2.60 each but were justified by the reduction in downstream debugging time.

3.2 Debugging

This is the category where operator intuition most often leads to suboptimal choices. The dominant pattern is to start on Sonnet (it’s the default) for all debugging tasks. Our data show that for complex debugging — multi-layer root cause involving firmware, CV pipeline, and scoring logic — Sonnet’s first-pass accuracy is low enough that the typical session requires 1.8 additional iterations, pushing blended cost to $1.68. Opus’s first-pass accuracy on the same tasks reduces average iterations to 1.1, and blended cost falls to $1.10 despite higher per-token pricing.

The boundary between “simple” debugging (Sonnet-appropriate) and “complex” debugging (Opus-appropriate) is task-specific, but a reliable proxy is whether the bug requires reasoning about interactions across more than two system layers. Single-layer bugs (a regex error, a config typo, a missing null check) are Sonnet territory. Multi-layer bugs — the class of incident that dominated the QC HIL failure taxonomy [8] — are Opus territory.

3.3 Code review

Code review is the category with the clearest support for a two-tier cascading strategy [7]. Haiku is effective at catching syntactic issues, obvious logic errors, and missing edge-case handling — the class of issues that appear in most diffs. Its escalation rate to Opus is 38%: it misses roughly a third of review sessions where non-obvious issues are present. Opus, used directly, catches these at higher quality ($1.80/artifact) but at excessive cost for routine reviews. The two-pass strategy — run Haiku first, escalate to Opus when Haiku flags uncertainty or the diff touches a sensitive layer — achieves $0.74/artifact at quality comparable to Opus alone.

3.4 Structured extraction and config authoring

These two categories represent the strongest case for Haiku as the primary tier. Structured extraction — pulling fields from an unstructured document into a defined JSON schema — is a pattern-completion task: the schema defines what is expected, and the model’s job is to locate and normalize values. Haiku’s accuracy is high (hallucination rate under 10%), escalation rate to Sonnet is 9%, and blended cost is $0.31/artifact. Config authoring follows the same profile at $0.28/artifact.

The MHG use case illustrates this clearly: SBA loan document analysis (extracting financial line items, property specs, and timeline data from raw application documents) ran entirely on Haiku at high accuracy and $0.20–0.35/document. Using Sonnet for the same tasks would have tripled cost with no observable quality improvement.

Figure 2405570851000.000.501.001.502.002.50QUALITY SCORE (0–100)COST PER ARTIFACT ($)Opus 4.7 — debuggingSonnet 4.6 — draftingHaiku→Opus — reviewHaiku 4.5 — extraction
Figure 2 — Quality-vs-cost frontier across task types and model tiers. Quality score is operator-assessed on a 0–100 scale (acceptance without rework = 100; major rework needed = 0–40). The frontier curves show the Pareto-efficient tier for each quality-cost combination. Sonnet 4.6 dominates the frontier for drafting, extraction, and config tasks (high quality at low cost). Opus 4.7 is frontier-efficient only for debugging and architecture tasks where its higher accuracy eliminates costly iteration. Numbers are illustrative; see §5.

Figure 2 shows the quality-vs-cost frontier for selected task-tier combinations. The frontier confirms the routing recommendations: Sonnet is on the efficient frontier for drafting; Opus is on the frontier for debugging; Haiku-to-Opus cascade is on the frontier for code review; Haiku alone is frontier-efficient for extraction.

Figure 30%20%40%60%80%100%ESCALATION RATE (%)71%Greenfield draft84%Debugging38%Code review52%Research synthesis9%Struct. extraction7%Config authoring
Figure 3 — Escalation rate (Haiku 4.5 → Opus 4.7 retry) by task type. Escalation is triggered when the operator judges the Haiku output insufficient for acceptance without rework and re-runs the task on Opus. High escalation rates on debugging and greenfield drafting show Haiku is not competitive for those task types; low escalation on structured extraction and config confirms Haiku is cost-efficient there. Numbers are illustrative; see §5.

Figure 3 shows escalation rates by task type. The bimodal structure is clear: escalation rates above 50% (drafting, debugging) indicate Haiku is not competitive for those tasks and should not be the default starting point. Escalation rates below 15% (extraction, config) confirm Haiku is the cost-optimal first choice with minimal quality risk.

4. Tier-Routing Recommendations

Recommended tierEscalation conditionEst. cost/artifactNotes
Greenfield draftingSonnet 4.6Output requires > 30 min rework → escalate to Opus$0.82Opus rarely needed; Haiku too shallow for first-draft coherence
DebuggingOpus 4.7N/A — start here$1.10Sonnet first-pass accuracy on complex bugs triggers costly rework; Opus is net-cheaper
Code reviewHaiku 4.5 → Opus 4.7Haiku misses any operator-known issue → escalate$0.74Haiku catches obvious issues cheaply; Opus catches subtle ones; two-pass is Pareto-optimal
Research synthesisSonnet 4.6Fidelity score < 75 → escalate to Opus for re-synthesis$0.91Haiku hallucination rate too high for synthesis tasks with >3 sources
Structured extractionHaiku 4.5Any hallucinated field → escalate to Sonnet$0.31Well-defined schemas are Haiku-friendly; escalation rate < 10%
Config authoringHaiku 4.5Syntax error or missing intent field → escalate to Sonnet$0.28Lowest cost tier; config is template-completion, not reasoning
Table 2 — Recommended tier-routing matrix. For each task type, the table shows the recommended starting tier, the condition under which escalation to a higher tier is warranted, and the expected cost envelope. Applying this matrix to the TruPath portfolio workload is estimated to reduce LLM spend 31–44% vs. the default strategy of using Sonnet 4.6 for all tasks. Numbers are illustrative; see §5.

Estimated cost/artifact is the blended cost including escalation incidence. Routing recommendations are derived from the TruPath portfolio workload distribution and may differ for workloads with different task-type proportions.

Table 2 summarizes the recommended routing matrix. Applied to the TruPath portfolio workload distribution (approximately 25% drafting, 20% debugging, 15% code review, 15% research synthesis, 15% structured extraction, 10% config authoring), the matrix is estimated to reduce total LLM token spend by 31–44% relative to defaulting all tasks to Sonnet 4.6, with no change in operator-assessed output quality.

4.1 Implementation pattern

The routing decision should be made at task-start, not mid-session. Switching models mid-session (starting on Haiku, escalating to Opus in the same conversation) is technically possible but requires re-supplying full context, which erodes the cost savings. The recommended pattern: classify the task at the start of each sprint contract, note the starting tier in the contract header, and initiate the session on the recommended tier. Escalation, when it occurs, opens a new session on the higher tier with a summarized handoff prompt.

4.2 Cost ceiling application

The routing matrix interacts with the cost-ceiling discipline described in TPL-2026-009 [10]. Setting a per-task cost ceiling forces the model-selection decision to be made explicitly rather than implicitly. An Opus session on a debugging task with a $3.00 ceiling forces the operator to define done-ness before starting rather than letting the session run until the bug is resolved. This interaction — cost ceiling as scope discipline, tier selection as cost optimization — compounds the savings.

5. Limitations

  • Illustrative figures. All specific numeric values in this paper are synthesized estimates, not directly instrumented measurements. A future study with automated per-run cost capture and blinded quality assessment would replace these estimates with measured values.
  • Single operator. Quality scoring is operator-subjective. A multi-operator study with standardized quality rubrics and inter-rater reliability testing would establish whether the routing recommendations generalize across operator styles.
  • Static pricing. Model pricing changes. The cost ratios between Haiku, Sonnet, and Opus are approximately 1:5:15 at the time of writing; if pricing changes substantially, the optimal routing will shift. The quality frontier (Figure 2) is more durable than the absolute cost numbers.
  • Task-type coverage. Six task types cover 85% of TruPath portfolio work but leave 15% unclassified (multi-modal tasks, long-horizon planning, interactive debugging). Routing recommendations for those categories are not supported by the current data.
  • Context length confound. Longer context windows tend to favor higher-tier models. We did not control for prompt length within task types; tasks with longer prompts may shift the frontier in favor of Opus even within categories where Sonnet dominates overall.

6. Reproducibility

Operators wishing to build their own routing matrix from first-party data need: (a) a log of at least 200 artifact-production runs with tier, task type, token count, and operator quality score; (b) at least 20 runs per task-type-tier cell; (c) a consistent quality rubric applied by a consistent rater. The task taxonomy in Table 1 and the quality rubric described in §2.2 are available as a template. The TruPath portfolio run log is available on request (venture-sensitive cost data redacted).

Operators can generate a rough initial routing matrix with as few as 30 well-documented runs by focusing on the three highest-spend task types and testing each on all three tiers. The cost-per-artifact and escalation-rate signals are strong enough that directional routing recommendations emerge from small samples.

References

  1. Chen, M., Tworek, J., Jun, H., Yuan, Q., Pinto, H. P. d. O., Kaplan, J., Edwards, H., Burda, Y., Joseph, N., Brockman, G., Ray, A., Puri, R., Krueger, G., Petrov, M., Khlaaf, H., Sastry, G., Mishkin, P., Chan, B., Gray, S., ... Zaremba, W. (2021). Evaluating large language models trained on code. arXiv preprint arXiv:2107.03374.
  2. Kaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A., Wu, J., & Amodei, D. (2020). Scaling laws for neural language models. arXiv preprint arXiv:2001.08361.
  3. Anthropic. (2024). Claude 3 Model Card. Anthropic. https://www.anthropic.com/claude-3-model-card
  4. Jimenez, C. E., Yang, J., Wettig, A., Yao, S., Pei, K., Press, O., & Narasimhan, K. (2024). SWE-bench: Can language models resolve real-world GitHub issues? Proceedings of ICLR 2024.
  5. Chiang, W.-L., Zheng, L., Sheng, Y., Angelopoulos, A. N., Li, T., Li, D., Zhang, H., Zhu, B., Jordan, M., Gonzalez, J. E., & Stoica, I. (2024). Chatbot arena: An open platform for evaluating LLMs by human preference. arXiv preprint arXiv:2403.04132.
  6. Chen, L., Zaharia, M., & Zou, J. (2024). FrugalGPT: How to use large language models while reducing cost and improving performance. arXiv preprint arXiv:2305.05176.
  7. Yue, X., Pang, B., Sun, X., Wu, C., Liu, Y., Wan, X., & Wang, W. Y. (2024). Large language model cascades with mixture of thoughts representations for cost-efficient reasoning. arXiv preprint arXiv:2310.03094.
  8. TruPath Labs Research. (2026). Token Economics Per Artifact: A Cross-Venture Cost Audit. TruPath Labs Preprint TPL-2026-008. trupathventures.net/labs/research/token-economics-per-artifact
  9. TruPath Labs Research. (2026). Sub-Agent ROI Audit: When Delegation Pays and When It Doesn't. TruPath Labs Preprint TPL-2026-007. trupathventures.net/labs/research/subagent-roi-audit
  10. TruPath Labs Research. (2026). Plan-Mode Efficacy: Does Structured Pre-Work Reduce Time-to-Merge? TruPath Labs Preprint TPL-2026-009. trupathventures.net/labs/research/plan-mode-efficacy

Cite as: TruPath Labs Research (2026). Cost-per-Artifact Curves Across Claude Model Tiers (Opus 4.7 / Sonnet 4.6 / Haiku 4.5). TruPath Labs Preprint TPL-2026-013. trupathventures.net/labs/research/model-tier-cost-curves