Cost-per-Artifact Curves Across Claude Model Tiers (Opus 4.7 / Sonnet 4.6 / Haiku 4.5)
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.
| Input | Acceptance criterion | Quality metric | n runs | |
|---|---|---|---|---|
| Greenfield drafting | Product spec or intent description, no prior code | Operator accepts output as starting point without major rewrite | % accepted without rework; rework-hour delta | 62 |
| Debugging | Failing test, error log, or unexpected behavior description + relevant codebase context | Root cause identified and fix verified by passing test or operator judgment | % first-pass correct; passes-to-resolution | 58 |
| Code review | Diff or file set with review prompt | Review catches all operator-known issues; no false positives causing unnecessary rework | Recall vs. known issues; false-positive rate | 44 |
| Research synthesis | Set of source documents + synthesis question | Output accurately synthesizes sources without hallucination; operator rates fidelity | Fidelity score (0–100, operator-rated) | 48 |
| Structured extraction | Unstructured document + target JSON schema | All required fields populated; no hallucinated values | Field accuracy %; hallucination rate | 58 |
| Config authoring | Intent description + existing config template | Output is syntactically valid; all intent-specified values present | Syntax-valid %; intent-compliance (%) | 42 |
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
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 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 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 tier | Escalation condition | Est. cost/artifact | Notes | |
|---|---|---|---|---|
| Greenfield drafting | Sonnet 4.6 | Output requires > 30 min rework → escalate to Opus | $0.82 | Opus rarely needed; Haiku too shallow for first-draft coherence |
| Debugging | Opus 4.7 | N/A — start here | $1.10 | Sonnet first-pass accuracy on complex bugs triggers costly rework; Opus is net-cheaper |
| Code review | Haiku 4.5 → Opus 4.7 | Haiku misses any operator-known issue → escalate | $0.74 | Haiku catches obvious issues cheaply; Opus catches subtle ones; two-pass is Pareto-optimal |
| Research synthesis | Sonnet 4.6 | Fidelity score < 75 → escalate to Opus for re-synthesis | $0.91 | Haiku hallucination rate too high for synthesis tasks with >3 sources |
| Structured extraction | Haiku 4.5 | Any hallucinated field → escalate to Sonnet | $0.31 | Well-defined schemas are Haiku-friendly; escalation rate < 10% |
| Config authoring | Haiku 4.5 | Syntax error or missing intent field → escalate to Sonnet | $0.28 | Lowest cost tier; config is template-completion, not reasoning |
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
- 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.
- 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.
- Anthropic. (2024). Claude 3 Model Card. Anthropic. https://www.anthropic.com/claude-3-model-card
- 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.
- 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.
- 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.
- 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.
- 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
- 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
- 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