The modern enterprise AI pipeline often begins with a period of unbridled experimentation. Teams deploy various LLMs via Amazon Bedrock, racing to build prototypes that prove value. However, as these prototypes migrate toward production, a recurring anxiety emerges during the monthly billing cycle. The AWS bill arrives as a monolithic sum, showing a spike in Bedrock costs, but providing almost no visibility into which specific application, user, or service role is driving the expenditure. This visibility gap creates a dangerous environment where a single inefficient prompt loop or an over-provisioned model choice can drain a budget without the platform team knowing exactly where the leak is occurring.

Engineering Granular Visibility with CUR 2.0 and Athena

Solving the Bedrock black-box billing problem requires moving beyond basic cost explorers and activating the IAM principal data within the Cost and Usage Report (CUR) 2.0. While standard reports show total service spend, enabling IAM principal data allows administrators to identify the specific requester of every API call. The process begins with the Data Exports tool, where CUR 2.0 must be configured and linked to Amazon Athena. By activating IAM principal data in the export settings, AWS generates the `line_item_iam_principal` column and associated IAM principal tags in the resulting reports. This technical shift transforms the billing data from a general ledger into a detailed audit trail, allowing teams to pinpoint the exact identity of the user or service role responsible for individual inference requests.

This level of granularity comes with a storage trade-off. Because usage data is expanded into individual rows for each IAM principal, the size of the CUR files in Amazon S3 increases significantly. In environments with a high volume of unique callers, this data growth can accelerate rapidly. To prevent S3 costs from offsetting the savings found in Bedrock, engineers must implement S3 Lifecycle policies to automatically transition older files to cheaper storage tiers or delete them after a set retention period. Once configured, there is a latency period of up to 24 hours before the first CUR 2.0 report is populated in the S3 bucket, after which the data becomes available for SQL-based analysis.

Amazon Athena serves as the primary engine for this analysis, operating as a serverless query service that charges 5 dollars per 1TB of data scanned. To maintain cost-efficiency during analysis, the system utilizes Hive partition projection on the `billing_period` column. When a query includes a specific month filter, Athena only scans the relevant Parquet files, often keeping the scan volume under 10MB and the cost per query around 0.00005 dollars. The most critical rule for analysts is to avoid `SELECT *` and instead specify only the necessary columns while strictly applying the `WHERE billing_period` filter.

To isolate Bedrock spending by caller, the following SQL query is used:

sql

SELECT line_item_iam_principal, line_item_usage_type, sum(line_item_unblended_cost) FROM your_cur_table_name WHERE line_item_product_code = 'AmazonBedrock' GROUP BY 1, 2

In this query, `your_cur_table_name` must be replaced with the actual Athena table name, such as `cid_data_export.cur2`. For more complex organizational structures, the `UNNEST` function is employed to flatten array-based tag data into individual rows, enabling precise cost allocation across different teams. To accelerate this setup, developers can leverage the `agent.md` skill repository. By connecting AI assistants like Claude Code, Kiro-CLI, or Codex to this repository, the entire pipeline from environment configuration to data connection can be automated, drastically reducing the time required to reach a state of billing visibility.

From Raw Data to Strategic Model Right-Sizing

While SQL queries provide the raw truth, the real insight emerges when this data is visualized through the CUDOS Dashboard v5.8. As part of the open-source Cloud Intelligence Dashboards (CID) framework, CUDOS v5.8 introduces a dedicated Amazon Bedrock section within its AI/ML tab. This integration removes the need for manual SQL writing, allowing managers to see Bedrock expenditure trends and IAM principal breakdowns through an intuitive interface. The dashboard specifically tracks the cost per 1 million tokens, which is the critical metric for determining if a model's performance justifies its price point.

The power of this visualization becomes clear when applying the IAM Principal Tag Project filter. For instance, if a team has tagged their resources with `chatbot-v2`, the dashboard can isolate the exact spend for that project, breaking it down by model and usage type. This is essential in multi-tenant AWS accounts where several teams share a single Bedrock instance. By deploying the database structure and visualization layouts via AWS CloudFormation templates, organizations can ensure a standardized analysis framework across the entire company, eliminating human error in manual setup.

Comparing two hypothetical services, ChatApp and DocProcessor, reveals the necessity of this approach. ChatApp, utilizing Claude 4.6 Sonnet, generates costs exceeding 80 dollars. In contrast, DocProcessor, utilizing Nova Lite, keeps its costs under 5 dollars. Because each service operates under a distinct IAM role, the platform team can see exactly where the money is going. A deeper dive into ChatApp's data reveals that 72 dollars of its total spend is attributed to output tokens. This indicates a significant inefficiency: the model is either generating excessively long responses or is being used for trivial tasks that do not require the reasoning capabilities of a high-end model like Claude 4.6 Sonnet.

Conversely, the DocProcessor's low spend proves that Nova Lite is the correct choice for its specific workload of structured text summarization. Nova Lite provides the necessary speed and efficiency for routine tasks at a fraction of the cost. This data-driven contrast provides the objective evidence needed to mandate a model swap. By migrating the simple query-and-answer portions of ChatApp from Claude 4.6 Sonnet to Nova Lite, the organization can immediately slash the 72-dollar output token waste without impacting the user experience for complex tasks.

For AI practitioners operating in multi-tenant environments, this visibility enables a sophisticated chargeback strategy. By assigning independent IAM roles to each service and combining them with Cost Allocation Tags such as `team`, `project`, or `costcenter`, the platform team can achieve total cost isolation. When these tags are activated, they appear in the CUR 2.0 data with an `iamPrincipal/` prefix. For example, a project tag becomes `iamPrincipal/project`. This allows for error-free monthly billing to specific departments based on actual resource consumption.

This operational framework allows platform operators to set budget ceilings and alert thresholds for individual projects, preventing a single runaway prompt or an unoptimized agent from consuming the entire corporate AI budget. By analyzing usage patterns and assigning appropriate quotas, the organization moves from reactive cost management to a strategic resource allocation model. When an application's output token cost exceeds its budget, the remedy is no longer a guess but a targeted architectural change: switching the workload from Claude 4.6 Sonnet to Nova Lite.