Yes, under certain conditions—but you can’t just take that number straight into production. On November 16, 2026, OpenAI disclosed that GPT-6 Luna’s per-task cost on the HealthAdminBench healthcare administrative benchmark was $0.085, 98% lower than GPT-6 Astra. That figure comes from a benchmark test, not a quote for a production hospital deployment.
You also can’t simply convert Agent costs from the per-million-token unit price. A single Computer Use task includes multiple rounds of model invocation, screenshot input, tool execution, failed retries, and a runtime environment. What you actually need to calculate is the full task cost. For developers, sensible model tiering, caching, workflow consolidation, and cost monitoring matter more than choosing the model with the lowest unit price.

What will you learn about healthcare Agent costs from this article?
- Under what test conditions were the 8.5 cents obtained, which figures are officially disclosed, and which are back-calculated estimates
- What parts make up the cost of a complete healthcare Agent task, and how screenshots, multiple rounds of invocation, and retries drive up expenses
- How to do model tiering, and how to estimate your own Agent project budget using formulas and monthly task volume
Article Index: Where to Start Reading the Medical Agent Cost Breakdown
The objective facts come first: which benchmark the 8.5 cents refers to and what scoring criteria apply, followed by an explanation of why Token unit price can’t stand in for task cost. From there, I’ll break down the six cost sources behind a single Agent task, and use CVS Health’s open-source CUA Agent Kit to show why fixed workflows don’t need to call a Large Language Model every time. The analysis section then discusses how to divide work between high-capability and low-cost models, offers a budget formula and calculation scenarios you can apply directly, and closes with what API-level usage management can and cannot solve.
To Know: Key Concepts Around Medical Agent Costs
| Concept | Brief Explanation |
|---|---|
| Computer Use | The ability to complete tasks by observing software interfaces and performing clicks, typing, and other operations |
| EHR | Electronic Health Record system — the electronic medical record system hospitals use |
| MCP | A standard protocol for discovering and invoking external tools |
| RPA | An automation approach that runs repetitive workflows according to pre-configured rules or scripts |
| Rubric points | Scoring points earned under evaluation rubrics, measuring how well partial requirements are met |
| End-to-end success rate | The share of complete tasks that satisfy all success conditions — stricter than the share of rubric points |
| Trace | Trajectory evidence that records the execution process, operations, and interface states |
| Maximum Reasoning Effort | The model’s highest reasoning intensity setting, which typically consumes more reasoning Tokens |
| Cached input | A mechanism that bills recurring input prefixes at a lower unit price |
Impact at a Glance: What Medical Agent Costs Mean for Each Stakeholder
- Developers and technical leads: You can’t quote official benchmark numbers directly when building a budget. You need to validate the execution mechanism, end-to-end completion rate, and total cost on your own tasks, and factor screenshot volume, invocation turns, and retry rate into your accounting.
- Healthcare organizations and workflow owners: It’s important to separate synthetic demos, vendor evaluations, pilots, and production cases. A low per-task cost doesn’t replace human approval, least privilege, and audit logging; those governance measures themselves carry costs.
The Objective Facts: The Data Behind the 8.5-Cent Medical Agent
What Medical Agent Tasks Can 8.5 Cents Complete?
The 8.5 cents figure comes from OpenAI’s medical Computer Use Agent announcement, published on November 16, 2026. OpenAI evaluated two models using HealthAdminBench, proposed by Stanford’s Shah Lab, with both running at the highest reasoning effort. The benchmark tests administrative tasks such as insurance eligibility verification, prior authorization requests, medical device ordering, and cross-system document handling in simulated EHRs, insurance payer portals, and fax systems.
| Item | GPT-6 Luna | GPT-6 Astra | Data nature |
|---|---|---|---|
| HealthAdminBench score | 91.8% | 94.3% | Officially disclosed, share of rubric points |
| Cost per task | $0.085 | Approx. $4.25 | Luna is officially disclosed; Astra is back-calculated from a 98% reduction |
| Cost for 1,000 tasks | $85 | Approx. $4,250 | Linear conversion under benchmark assumptions, not a production quote |
| Input price (per million tokens) | $0.10 | $10.00 | Official Standard short-context pricing, queried 2026-11-17 |
| Output price (per million tokens) | $0.50 | $50.00 | Same as above |
| Cached input (per million tokens) | $0.01 | $1.00 | Same as above |
Astra’s roughly $4.25 comes from calculating 0.085 ÷ (1 − 0.98). It’s an approximation, not a price OpenAI published separately. Nor are 94.3% and 91.8% full-task success rates. They measure the share of available rubric points, and shouldn’t be written as “94.3% of hospital administrative work is now fully automated.”
HealthAdminBench has several public versions, so you need to distinguish their scope and definitions. The paper version, 2604.09937v1, contains 135 tasks and 1,698 subtasks, of which 1,177 are judged by deterministic rules and 521 are scored by a model judge. In the paper, the 36.3% full-task success rate belongs to Claude Opus 4.6 CUA, while the 82.8% subtask success rate belongs to GPT-5.4 CUA. An earlier Shah Lab webpage described a version with 70 tasks and 947 rubric points; that can only serve as a historical reference. Results from different models, dates, execution conditions, and metrics can’t be lined up into a single leaderboard.

Why Can’t Medical Agent Tasks Be Judged by Token Unit Price Alone?
Looking at the price table, the input, output, and cached-input unit prices for the two models differ by 100x. Working out the 98% price cut, the per-task cost gap comes to only about 50x. That tells us the two models aren’t actually consuming the same amount of resources within the same benchmark. Invocation rounds, input/output token counts, reasoning consumption, and retry counts can all differ — which means per-task cost can only be calculated from real usage.
The root cause lies in how Computer Use actually runs. According to the OpenAI developer docs, a typical loop goes like this: receive the task, observe a screenshot, generate an action instruction, let the application perform the click or typing, return a new screenshot, and have the model decide the next step — repeating until the task is done or human approval is requested. At every step, the task description, historical context, and new screenshot may all be fed back into the model.
A simple Q&A might need just one call, while a cross-system pre-authorization flow can go through a dozen consecutive rounds of “observe, act, verify.” Screenshots are image inputs, so they incur separate vision token charges — and they show up every single round, which makes them the easiest cost to underestimate. Also keep in mind that the model generating an action instruction doesn’t mean the action succeeded. The application still has to execute it and verify the result, and that verification itself consumes calls.

Where Does the Money Actually Go in a Medical Agent Task?
Break a single task down, and you can sort it into six categories of direct costs. Engineering maintenance is an ongoing investment, so it’s clearer to account for it separately.
| Cost Category | Source | Key Accounting Notes |
|---|---|---|
| Input tokens | System prompt, task instructions, historical context, tool returns | Accumulate per turn; separate out the cacheable portion |
| Output tokens | Operation instructions, generated code, decisions and reasoning | High reasoning effort significantly increases output |
| Visual input | Screenshots per turn and UI understanding | Count separately according to the model’s image billing rules |
| Tool calls | Built-in tools, hosted browser, code execution | Tokens consumed by built-in tools are billed at the corresponding model’s rates |
| Runtime environment | Browser, virtual machines, containers | Only counted when the corresponding service is actually used |
| Failed retries | Page load failures, targeting failures, operation errors | If retry tokens are already included in the total, don’t count them again |
Runtime environment billing varies a lot. OpenAI’s pricing page lists Hosted Shell and Code Interpreter container fees as: 0.03 USD per 20 minutes for 1 GB, 0.12 USD for 4 GB, 0.48 USD for 16 GB, and 1.92 USD for 64 GB. File and image upload storage is billed at 0.10 USD/GB-day. If developers run Playwright or a desktop executor on their own servers, this portion becomes their own infrastructure cost, with a completely different structure.
So when you’re doing the accounting, you need to separate three layers: model cost is the fee for processing input and output, runtime cost is the fee for infrastructure like browsers, servers, and containers, and engineering cost is the human effort invested in workflow design, testing, monitoring, and maintenance. If you only look at the first layer, your budget will definitely come out too low.
Why Shouldn’t Some Medical Agents Call the Large Language Model Every Time?
CVS Health disclosed production case studies in its announcement. One Agent cleared a backlog of file-sending tasks that had piled up over several months in a single weekend, while another Agent handles tens of thousands of system operation steps across specialty consultations every day. The “tens of thousands” here refers to operation steps, not clinical decisions made independently by AI. The system also includes validation checks, human oversight, and status verification based on screenshots and action logs.
What developers should pay more attention to is CVS’s open-source CUA Agent Kit (Apache-2.0 license). It splits automation into two phases: first, the OpenAI Computer Use Agent executes tasks described in natural language and records screenshots, actions, target locations, and traces; then Codex Skill generates or updates deterministic workflow code based on successful trajectories, with engineer review. The README states that the deterministic execution phase doesn’t require a model API key.
This design directly targets the cost problem: exploring unknown workflows requires LLM reasoning, while repeatedly executing known workflows is left to ordinary code. As long as the workflow stays stable, a single run no longer pays for visual input and reasoning costs, and result variability goes down too. A core idea of the project is that “discovering how to complete a task” and “repeating it stably over the long term” are two different problems.
The relationship between traditional RPA and Agents can also be understood from this angle. In an RPA comparative study (DOI: 10.1080/23311975.2026.2724760), tasks P2 and P3 each ran 10 times per technology, while the Agent for task P1 ran only once and failed, so it wasn’t included in the subsequent statistics—meaning you can’t broadly claim that “all tasks were executed 10 times.” The study used 2025 tool configurations, so it shouldn’t be treated as a direct score for 2026 models. Still, it makes one point: when evaluating automation solutions, the stability of repeated runs matters just as much as single-run success.
Analysis: How to Calculate Costs for a Medical Agent
How Should High-Capability and Low-Cost Models Divide Work in a Medical Agent?
Benchmark data shows that Luna’s score points are 2.5 percentage points lower than Astra’s, while its cost is only about 2% of Astra’s. This suggests that for highly structured administrative tasks, low-cost models already have considerable execution capability. But a gap in score points isn’t the same as a gap in end-to-end success rate — if the missing points happen to fall on critical steps like file upload or status updates, the business outcome could be completely different. That’s our judgment, and it needs to be validated with your own task data.
A more reliable approach is to allocate by stage rather than using a single model for the whole task:
| Work stage | Suggested owner | Rationale |
|---|---|---|
| Understanding complex tasks, breaking down steps | High-capability model | Mistakes are costly; few invocations |
| Handling ambiguity and fuzzy information in medical records | High-reasoning model + human confirmation | Ambience’s approach stops and asks the doctor when there’s ambiguity |
| Routine interface operations | Low-cost model | Many invocations; most sensitive to unit price |
| Repeatedly filling fixed forms | Deterministic code | Following the code-hardening approach of CUA Agent Kit |
| Common exception handling | Low-cost model or rules | Patterns are fixed and can gradually be codified into rules |
| Approval of critical operations | Human | Actions like submit, send, and sign retain final human authority |
| Final result verification | Structured checks + human spot checks | Go by system state, not the model’s claim that it’s “done” |
The benefit of this layering is that high unit-price models only appear in low-frequency, high-value steps, while high-frequency steps go to low-cost models or code. When multiple models coexist, a unified invocation interface lowers switching costs. For example, through an OpenAI-compatible gateway like APIYI apiyi.com, developers can change only the model parameter to compare different models. Which models are actually available depends on the platform’s current model list and account permissions.

How Should Developers Calculate the Budget for Their Medical Agent Project?
We recommend using the per-task cost framework below. Here, T is the actual token count and P is the price per million tokens:
C_task = C_input + C_output + C_image + C_tools + C_runtime + C_retry
C_input = T_input × P_input / 1,000,000 (cacheable portions are itemized at cache rates)
C_output = T_output × P_output / 1,000,000
C_image = per the model's vision billing rules, tally each round's screenshots separately
C_retry = count only retry overhead not yet folded into the token totals above
Cost per successful task = total cost of all tasks ÷ number of successful tasks
Monthly budget = cost per successful task × monthly successful-task target + engineering maintenance spend
What really determines budget accuracy is a handful of measured metrics: average invocation rounds per task, average screenshot count, failure retry rate, human-intervention rate, and end-to-end success rate. Using “cost per successful task” rather than “cost per run” as the denominator lets you fold failed runs’ consumption into the number.
The table below is a budget scenario we built ourselves. All usage figures are hypothetical and only meant to demonstrate the calculation method. Unit prices use the official Standard rates from earlier:
| Scenario assumptions (self-built, not measured) | Low-cost model (Luna pricing) | High-capability model (Astra pricing) |
|---|---|---|
| 15 rounds per task, 20K tokens of vision + text input per round | 300K × $0.10/M = $0.030 | 300K × $10/M = $3.00 |
| 500 tokens of output per round | 7,500 × $0.50/M ≈ $0.004 | 7,500 × $50/M = $0.375 |
| Model cost per single run | about $0.034 | about $3.38 |
| Cost per successful task assuming an 80% end-to-end success rate | about $0.042 | about $4.22 |
| Model cost for 10,000 successful tasks per month | about $420 | about $42,200 |
| Managed container (4 GB, 4 tasks run serially every 20 minutes) | about $300/month | about $300/month |
This scenario reveals something easy to overlook: once the model is cheap enough, runtime environment costs can land in the same order of magnitude as model costs — or even exceed them. That shifts where you optimize: instead of “switch to a cheaper model,” it becomes “cut screenshot rounds, reuse containers, and turn fixed steps into code.” That’s a judgment drawn from scenario modeling; the actual proportions depend on your own measured data.
The most direct way to collect real usage is to record the usage field after every model invocation. Here’s the simplest example:
from openai import OpenAI
client = OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1", # APIYI's OpenAI-compatible endpoint
)
resp = client.chat.completions.create(
model="YOUR_MODEL_NAME", # see the model list in the APIYI dashboard
messages=[{"role": "user", "content": "根据以下字段生成预授权申请核对清单:..."}],
)
u = resp.usage
print("input:", u.prompt_tokens, "output:", u.completion_tokens)
View the full implementation code for accumulating cost per task
from dataclasses import dataclass, field
from openai import OpenAI
# 2026-11-17 official Standard short-context pricing (USD per million tokens); refer to the applicable billing tier for actual rates
PRICES = {
"gpt-6-luna": {"input": 0.10, "cached": 0.01, "output": 0.50},
"gpt-6-astra": {"input": 10.00, "cached": 1.00, "output": 50.00},
}
client = OpenAI(
api_key="YOUR_API_KEY",
base_url="https://api.apiyi.com/v1", # Unified access; you can cross-check token and cost logs in the dashboard
)
@dataclass
class TaskCostMeter:
model: str
rounds: int = 0
screenshots: int = 0
retries: int = 0
input_tokens: int = 0
cached_tokens: int = 0
output_tokens: int = 0
runtime_usd: float = 0.0
log: list = field(default_factory=list)
def record(self, usage, has_screenshot=False, is_retry=False):
self.rounds += 1
self.screenshots += int(has_screenshot)
self.retries += int(is_retry)
details = getattr(usage, "prompt_tokens_details", None)
cached = getattr(details, "cached_tokens", 0) or 0
self.cached_tokens += cached
self.input_tokens += usage.prompt_tokens - cached
self.output_tokens += usage.completion_tokens
self.log.append((self.rounds, usage.prompt_tokens, usage.completion_tokens))
def model_cost(self):
p = PRICES[self.model]
return (self.input_tokens * p["input"]
+ self.cached_tokens * p["cached"]
+ self.output_tokens * p["output"]) / 1_000_000
def total_cost(self):
# Tokens from retry rounds are already accumulated in record, so don't add them again here
return self.model_cost() + self.runtime_usd
def cost_per_success(meters, success_flags):
total = sum(m.total_cost() for m in meters)
wins = sum(success_flags)
return total / wins if wins else float("inf")
🎯 Budget tip: pick 20 to 50 real task samples for a small trial run first, then work out your monthly estimate. When you route everything through APIYI apiyi.com, you can check your own metering numbers against the token usage and cost logs in the dashboard — and the free test credits new users get are enough to cover this step.
From Model Pricing to API Cost Management: What a Medical Agent Gateway Can Do
Once an Agent project reaches the multi-model stage, costs rarely spiral because the unit price is high — they spiral because nobody can say which step or which model burned how much. That’s where an API Gateway earns its keep: it pulls scattered calls into one place, with unified keys and endpoints, usage logs broken down by model, and traceable expense records. Only with that in hand can a team notice that one step is taking too many screenshots, or that a particular kind of anomaly keeps triggering retries.
Take APIYI as an example. According to its quick start docs, onboarding means registering an account, grabbing an API key from the Token page, then swapping your original OpenAI endpoint for https://api.apiyi.com — some apps also need /v1 appended to the address. The official SDK and code samples work as-is, the dashboard shows model, token consumption, and cost logs, and the page states that OpenAI and Claude rates match the official ones, with invoicing available. For teams that need to tier and compare across multiple models, APIYI (apiyi.com) offers a pay-as-you-go, uniformly metered access layer.
Its limits deserve a clear mention too. An API gateway handles access and metering for model invocation — it isn’t an Agent executor. Browser and desktop environments, screenshot capture, business permission control, human approval flows, and workflow maintenance are still on the developer to build. In medical settings, HIPAA compliance also depends on product eligibility, a BAA, security configuration, and data governance — it doesn’t become satisfied just because you changed how you connect. And whether a given GPT-6 model can be called depends on the platform’s current model list.
Coming back to that 8.5 cents figure: it proves the potential of low-cost models in high-frequency administrative automation, but it can’t tell you what your own workflow will cost. That answer only comes from your own task samples, your own success rate, and your own usage logs. As the old English saying goes:
The proof of the pudding is in the eating.
(You only know a pudding is good by eating it — real results have to be verified in practice.)
References
- OpenAI Healthcare Computer Use Agent announcement: the original source for HealthAdminBench scores and per-task cost
- Link:
openai.com/index/advancing-computer-use-for-healthcare-teams
- Link:
- OpenAI API pricing page: GPT-6 Astra and GPT-6 Luna token prices plus container fees
- Link:
developers.openai.com/api/docs/pricing
- Link:
- OpenAI Computer Use developer docs: the execution loop, and the two paths — Computer Tool and Code Execution
- Link:
developers.openai.com/api/docs/guides/tools-computer-use
- Link:
- HealthAdminBench paper v1: the specific version with 135 tasks and 1,698 subtasks
- Link:
arxiv.org/html/2604.09937v1
- Link:
- CVS Health CUA Agent Kit: an open-source implementation of AI exploration paired with codified, frozen-in-place code
- Link:
github.com/cvs-health/cua-agent-kit
- Link:
- RPA comparative study: the repeated-run design and the caveats around exceptions
- Link:
doi.org/10.1080/23311975.2026.2724760
- Link:
- Proverb meaning check: Cambridge Dictionary
- Link:
dictionary.cambridge.org/us/dictionary/english/proof-of-the-pudding-is-in-the-eating
- Link:
Author: APIYI Technical Team
Technical discussion: Feel free to reach us through the APIYI apiyi.com homepage — for more integration details, head over to the docs.apiyi.com documentation center.