Today, a company can acquire Claude in four ways: directly from Anthropic, via Amazon Bedrock, via Claude Platform on AWS, or via AWS Marketplace. Each route affects where data is processed and how billing works. On top of that, token usage from agentic tools such as Claude Code can quickly add up, with no cap. Many organizations also run into a more practical problem: they simply can’t purchase Claude today, because they lack a suitable master agreement or vendor relationship with Anthropic, or because something as basic as paying by credit card doesn’t fit their procurement process. In regulated organizations, adoption therefore gets stuck on a few questions: where does our data go, what will this cost, and how do we actually buy this?

From tool to managed service

The fact that AWS and Anthropic themselves released a self-hosted gateway for Claude Code and Claude Desktop confirms the direction: AI tools are no longer managed laptop by laptop, but through a governance layer the organization controls itself. Manthra brings that layer into production and manages it. Manthra also solves the procurement problem: the customer is billed via Cloudar or via AWS Marketplace, with whom a vendor relationship usually already exists, without having to set up its own master agreement with Anthropic or get stuck on practicalities such as paying by credit card.

“AI is maturing. What started as a tool employees tried out on their own is becoming a service the organization relies on, with the same expectations as the cloud: secure, predictable and managed. Yet many companies can no longer see the forest for the trees. There are several ways to acquire Claude, each with different implications for data and billing. Manthra takes over those choices and that management, so IT can focus on what AI delivers,” says Senne Vaeyens, co-founder at Cloudar.

What Manthra delivers

• Web interface: Manthra offers a simple web interface that lets IT and finance manage and track users, limits and usage: add new users, set spending limits, and see at a glance who is using what.
• Compliance: Inference runs within the EU. The customer chooses, per environment, between two retention profiles: Zero Data Retention (no storage of prompts and responses) or a Compliance & Audit profile with encrypted logging to a write-once S3 bucket with its own KMS keys, accessible only to audit teams. For the newest models that fall outside Zero Data Retention, use requires a deliberate opt-in. Amazon Bedrock Guardrails can detect and block personal or sensitive data [to confirm this is live]. Login runs via the existing identity provider (such as Entra ID or Okta), without persistent AWS keys on laptops.
• Cost control: Usage is billed per token at Bedrock rates, with no per-user license. Costs appear on the AWS bill or via Cloudar, whichever the customer prefers. Spending limits per user, group or organization are enforced in real time: once the cap is hit, the gateway blocks further requests until the period resets or an administrator raises the limit. Model access can be managed centrally, with alerts for runaway usage. Routine tasks can be routed to faster, cheaper models, while the heaviest models are reserved for complex work.
• Plug-and-play: The customer doesn’t need to handle complex technical configuration or deployment themselves, unless they want to: Cloudar sets up and manages the environment. Under the hood, the gateway runs as a container in a locked-down AWS VPC, with configuration that IT rolls out to laptops through existing tools (Intune or Jamf), invisible to the customer.
• Management: Cloudar deploys, patches and monitors the environment, makes new Claude models available as soon as they’re released, delivers periodic cost reports, and is the point of contact for incidents.

According to Senne Vaeyens, adoption in regulated organizations comes down to two questions: “Where does our data go, and what will this cost? With Manthra, we can show a CISO step by step where every prompt goes, and give a CFO a per-user cap before a single token is consumed. That’s when AI becomes something you dare to roll out broadly, with confidence.”

Manthra is available in two forms. With fully managed, Cloudar runs a dedicated AWS tenant. With configured on your tenant, Cloudar builds the environment in the customer’s own AWS account and hands it over, with optional support afterwards. Billing can run through Cloudar or through AWS Marketplace. Cloudar starts with a workshop involving business, IT and security, then delivers a plan covering phasing, timing and budget, and moves via a pilot with a handful of early adopters toward broader rollout.

The post Cloudar launches Manthra: Managed Anthropic on AWS appeared first on Cloudar.

The timing also matters. AWS fundamentally restructured its entire support portfolio at re:Invent 2025, and many customers are now re-evaluating how they buy support. So this post does three things: it maps out the new AWS support landscape, explains where partner-delivered support fits in it, and shows what we technically built to earn the label.

First, the lay of the land: AWS Support in 2026

If the plan names below look unfamiliar, that is because the lineup you knew is on its way out. AWS announced at re:Invent 2025 that the legacy Developer, Business, and Enterprise On-Ramp plans will be discontinued on January 1, 2027. The new portfolio is simpler: a free Basic tier plus three paid plans, each layering on the previous one.

Read those numbers as floors, not prices. AWS support has always billed the greater of the minimum or a percentage of your AWS charges (Business Support+ starts at 9% and tiers down as spend grows), so a $29 minimum does not mean a $29 bill. Model your own usage before comparing tiers.

Three changes stand out for anyone planning their 2026 support strategy:

• Full Enterprise Support now has roughly the minimum charge On-Ramp used to. The headline is that the Enterprise minimum fell from $15,000 to $5,000 per month, but the more useful comparison is with Enterprise On-Ramp at $5,500: at a similar floor you now get a designated TAM instead of a pooled one, and a 15-minute critical response target instead of 30 minutes.
• Enterprise On-Ramp disappears by automatic upgrade. On-Ramp customers are moved to full Enterprise Support during 2026, at contract renewal or in batches, gaining a designated TAM and the 15-minute SLA in the process. Check what that does to your spend before the migration lands.
• Business Support+ can be enrolled organization-wide. From the management account (AWS Organizations with all features enabled), one subscription covers the whole organization, which removes the old per-account plan patchwork at the low end.

Two ways to buy support through a partner

Against that backdrop, AWS defines two distinct partner models, and they are frequently confused:

AWS Resold Support means your partner owns the billing relationship, but you keep a direct technical relationship with AWS: you open your own cases in the AWS Support Center. Resold Support is available as Business Support+, Enterprise Support, or Unified Operations. It is a procurement construct more than an operational one.

AWS Partner-Led Support (PLS) means the partner is your support front door. The partner delivers level 1 and level 2, holds Premium Support behind your accounts, and escalates into AWS with priority when needed. This is the model that requires certification, and it is exactly what the Backed by AWS Support label signals: AWS has audited and equipped this partner to run support, not just to invoice it.

The right choice depends on where your operational capability sits. If you have a strong internal cloud team and only want purchasing convenience, Resold Support is the cleaner fit. If you want the team that operates your environment to also own your support cases end to end, PLS is the stronger model. Cloudar offers both, and the rest of this post explains what the PLS machinery looks like on our side.

The Partner-Led Support model

Where direct and Resold Support are two-party models (you open a case, AWS responds, your partner is somewhere on the side), PLS restructures support into a layered model:

1. You contact Cloudar. Our engineers, who already know your landing zone, your accounts, and your workloads, handle the case as level 1 and level 2.
2. Cloudar escalates to AWS when needed. As a PLS partner we hold Premium Support behind your accounts, with 24/7 access to AWS experts and a 15-minute response target for high severity escalations. Worth being precise about what that clock measures: it starts when we escalate to AWS, not when you report the issue to us. Your response times are the ones in your contract with us; the AWS target is what we get once our engineers decide the problem needs AWS on it.
3. AWS works with us, not around us. Our specialist Technical Account Manager collaborates on escalations, and we maintain a jointly defined incident response plan so severity mapping and escalation paths are agreed before an incident, not during one.

The difference with a plain resale construct: a PLS partner is certified, audited, and equipped by AWS to run support, not just to forward tickets. Attaining the label required passing the AWS Foundational Technical Review for our support practice and committing to the program’s response and quality targets. The rest of this post is about the “equipped” part.

Case management: the AWS Support API in our service desk

The first thing we wired in is programmatic case management. Cases we open on your behalf do not live in a console someone checks twice a day; they are synchronized into our Jira-based service desk through the AWS Support API, so the case history and the customer ticket are one timeline.

Opening a case from a ticket:

aws support create-case \
  --region us-east-1 \
  --subject "EKS node group failing health checks after AMI rotation" \
  --service-code "amazon-elastic-kubernetes-service" \
  --severity-code "urgent" \
  --category-code "cluster-management" \
  --communication-body "Managed node group X in eu-west-1 ..." \
  --attachment-set-id "$ATTACHMENT_SET_ID"

Two implementation details that matter if you ever build against this API yourself:

• It only exists in us-east-1. Whatever region your workloads run in, the AWS Support API is accessed through its us-east-1 endpoint. Hardcode the region in your client, not in your mental model of the workload.
• Attachments are a two-step flow. You first call add-attachments-to-set with base64 payloads, get an attachment set ID back, and reference it in create-case or in a later add-communication-to-case. An attachment set holds up to three files at 5 MB each, and the set expires an hour after you create it. Worth knowing before you design around it: the console accepts larger uploads than this API path does, so do not assume a log bundle your engineers can drag into Support Center will go through your automation unchanged.

For the synchronization back into Jira we did not reinvent the wheel. Our case sync is based on JustSupport, the open source tool Just Eat published for exactly this problem: bidirectional sync between AWS Support cases and Jira tickets. The architecture we retained from it is refreshingly simple and worth describing, because it solves the multi-account problem every MSP has:

• The link is a custom Jira field. Each Jira ticket carries a field holding the AWS Support case reference. Fill it in and the sync picks the case up, including a backfill of all prior correspondence (four months of lookback by default), so a case opened in the console before the ticket existed still ends up with a complete timeline.
• Cross-account by role assumption. A scheduled Lambda assumes a lightweight IAM role (deployed from a CloudFormation template in the repo) in every account configured, and pulls case updates from each. One deployment covers the whole managed estate; onboarding a new customer account is one role and one config entry.
• Idempotency via DynamoDB. Processed updates are tracked in a DynamoDB table, so the five-minute polling schedule (chained through SNS until all updates are drained) never produces duplicate comments. It even pauses while an AWS chat session is live and processes the transcript once the session ends.
• Replies go the other way too. An engineer writes a Jira comment starting with #DearAWS and the text is posted to the AWS case; the comment is edited to #SenttoAWS on success. Nobody leaves the ticket to talk to AWS.

Net effect: when an AWS Support engineer replies at 03:00, the update is in the customer-visible ticket minutes later, not when our morning shift logs in.

Resurrecting an eight-year-old serverless project

Full transparency: the upstream repository has been dormant since 2018, three commits and done. You cannot deploy it as-is in 2026, and we would not recommend trying. What we run is an internally maintained version, and getting there was a small case study in how serverless projects age:

• The Lambda runtime was long gone. The Node.js runtime of that era has been through several deprecation cycles since. Moving to a current Node.js LTS runtime was the easy part.
• The AWS SDK migration was the real work. The code was written against the AWS SDK for JavaScript v2, which reached end of support in 2025 and is not bundled in current Node.js Lambda runtimes anyway. Migrating to SDK v3 meant swapping the monolithic client for modular ones (Support, DynamoDB, SNS, STS) and rewriting the .promise() call chains around the v3 command pattern.
• Jira moved underneath it. The Jira Cloud REST API has evolved since 2018; the gotcha that costs the most time is that modern comment endpoints expect Atlassian Document Format JSON rather than plain text, so the comment-posting path needed reworking on both directions of the sync.
• The deployment tooling needed a refresh. The original Serverless Framework configuration predates several major versions; we redeployed on a current toolchain.

Here is the part worth internalizing: the core architecture needed no redesign. Runtimes, SDK clients, API payloads and deployment tooling all had to be replaced, but the shape of the solution did not: the custom field linkage, the cross-account role assumption, the SNS-chained processing and the DynamoDB idempotency table all still work exactly as designed in 2018. The runtimes, SDKs, and APIs around it rotted; the event-driven design did not. That is the strongest endorsement of simple serverless architecture we can give, and it is why we chose to revive the project rather than build our own. If you want to do the same, the upstream repo remains a solid architectural blueprint, but budget for the modernization pass rather than a quick deploy.

One design decision worth stealing: we keep a hard mapping table between AWS severity codes and our ITSM priorities, agreed in the incident response plan with our TAM.

Sounds obvious, but during an incident nobody should be interpreting what “urgent” means. The mapping is code, not judgement.

Proactive posture: CSPM across the managed estate

PLS pushes partners toward proactive support: catching problems before they become cases. For posture, our tool of choice is Trend Vision One Cloud Risk Management, the CSPM that carries the Cloud One Conformity lineage. It is a third-party platform, but its mechanics are AWS all the way down, which is exactly why it works well at MSP scale:

• Onboarding is a CloudFormation stack. Each managed account gets a read-only cross-account IAM role deployed from a template, the same pattern as our case sync. New customer, one stack, done. No agents for posture scanning.
• Coverage is broad and rule-based. The platform continuously evaluates accounts against 900+ AWS-specific rule checks, mapped to the Well-Architected Framework and to the compliance frameworks our customers actually get audited on. That mapping matters: a finding that says “S3 bucket policy allows cross-account write, fails CIS 2.1.x and your ISO 27001 control” is actionable in a way a raw misconfiguration list is not.
• Findings flow into the same operational rhythm. Posture findings are triaged into our service desk with the same priority model as reactive cases, so a critical misconfiguration is a P1 with an owner, not a dashboard entry. For customers running AWS Security Hub, findings can be published there as well, keeping their native AWS view complete.

This is also where the PLS program features land in practice. The Partner Security Reviews the program includes, aligned with the Well-Architected Security Pillar, are fed directly by this CSPM data rather than assembled by hand. And for the reactive path, PLS grants secure access to a subset of the diagnostic tooling AWS Support engineers themselves use, which shortens the loop on the classic “we need service-side visibility” cases that previously required a full escalation round-trip.

How you would build this AWS-native

Because this is the question every architect should ask before buying anything: what does the same capability look like with AWS-native services? Since the re:Invent 2025 restructure, the native stack looks like this:

• AWS Config is the foundation. A configuration recorder per account and region tracks resource state, and managed Config rules evaluate it continuously. Conformance packs bundle rules into deployable compliance sets (CIS, PCI, operational best practices), and an aggregator gives you the cross-account view.
• Security Hub CSPM is the posture layer, and the naming is worth getting right. The posture management capabilities previously known as AWS Security Hub are now AWS Security Hub CSPM: best practice checks against standards like AWS Foundational Security Best Practices and the CIS AWS Foundations Benchmark, producing findings in the AWS Security Finding Format. The name AWS Security Hub now refers to the broader unified service, generally available since December 2025, which correlates and enriches signals from Security Hub CSPM, GuardDuty, Inspector and Macie into prioritized risks. So it is not a rename: the old service became the CSPM component inside a bigger one.
• Organizations does the fleet wiring. A delegated administrator account plus central configuration policies auto-enable the services and standards on every new account in the organization, so posture coverage is a property of account creation, not a checklist item.
• Remediation is EventBridge plus SSM. Findings emit events; rules route critical ones to SSM Automation runbooks or ticket creation. Config also supports auto-remediation directly on rule breach.
• Amazon GuardDuty adds the threat detection layer. Posture tells you an environment is configured badly; it does not tell you a credential is being abused right now. GuardDuty answers that second question, analysing CloudTrail management and data events, VPC flow logs, and DNS query logs with no agent to deploy and no log pipeline to build. Well worth enabling alongside the stack above, with the optional protection plans (S3, EKS Runtime Monitoring, Malware, RDS, Lambda) switched on selectively rather than everywhere, since billing scales with the volume of events and logs analysed.

For a single organization, this stack is excellent and should be the default before any third-party purchase. So why do we run a third-party CSPM as an AWS Premier Partner? Two structural reasons, and one commercial one:

• The organization boundary. Native aggregation (Config aggregators, Security Hub delegated admin, and GuardDuty’s delegated administrator too) works within one AWS Organization. An MSP manages many customers, which means many organizations. GuardDuty has exactly the same limitation: you get clean organization-wide enablement and auto-enable for new member accounts, but only within each organization, so a partner still ends up with one delegated administrator per customer and no native way to see across them. Building one consolidated, customer-partitioned view means custom plumbing: forwarding findings to a central EventBridge bus and building your own aggregation, storage, and access model on top. At that point you are not configuring a service, you are building a product.
• Compliance mapping out of the box. Our customers get audited against ISO 27001, NIS2, and sector frameworks. The third-party platform ships the rule-to-framework mapping and the auditor-friendly reporting; natively you assemble that from conformance packs and Audit Manager per organization.
• The cost shape is worth modelling, not assuming. Config bills per configuration item recorded and per rule evaluation, Security Hub CSPM per check. That means native posture spend scales with how much your customers change their environments rather than with how many customers you have, which is a harder number to forecast in a managed services P&L. We are deliberately not putting a figure on the comparison here, because it depends entirely on resource churn in the estate you are modelling. Run it against your own account inventory before treating either option as the cheap one.

None of this makes the native stack wrong; it makes it right for a different shape of organization. If you run one AWS Organization, start with Config, Security Hub CSPM, and central configuration, and only look further when you hit a concrete limit. Our estate hits the multi-organization limit on day one, so we run Trend Vision One across it, and keep the AWS-native integration points (CloudFormation onboarding, CloudTrail-driven signals, optional Security Hub publishing) so nothing about the estate becomes opaque to AWS tooling.

And to be clear about where we would like this to go: as Cloudar, we would love to see AWS close this gap. First-class multi-organization support in Config aggregators, Security Hub CSPM, and GuardDuty, letting a partner operate one governed view across the organizations of the customers it manages, would remove our biggest reason to depend on third-party tooling for posture. The building blocks (delegated administration, central configuration, cross-account roles) all exist; they just stop at the organization boundary today. Consider this our feature request, filed publicly.

What this means for you

For Cloudar, the label validates an investment: AWS-grade tooling, a curated troubleshooting curriculum built from the cases AWS Support escalates most often, and a TAM relationship that spans our whole managed base. Support is core to what we sell, and this gives that investment external AWS validation rather than asking customers to take our word for it.

For you as a customer, the practical outcomes are:

• One front door, with context. You reach the engineers who operate your environment, backed by the pipelines described above rather than an anonymous queue starting from zero.
• AWS speed when it counts. When something needs AWS, our escalation reaches their experts under a 15-minute response target, with the diagnosis already framed rather than starting from scratch.
• Proactive by construction. Posture findings and security reviews flow through the same priority model as your incidents, so misconfigurations become owned tickets instead of dashboard entries.

With the legacy plans disappearing on January 1, 2027, every AWS customer currently paying for one of the retiring plans will touch this decision in the coming year: pick a new direct plan, buy Resold Support through a partner, or move to Partner-Led Support. If you currently run a direct plan next to a partner relationship, that re-evaluation is worth a structured conversation: consolidating typically simplifies contracts, escalation paths, and often the bill. And if you are a partner reading this on your own PLS journey, the Support API, a revived open source case sync, and a severity mapping your team never has to debate at 03:00 are the places to start.

Program details live on the AWS Partner-Led Support page.

The post Cloudar is now Backed by AWS Support: the engineering behind the label appeared first on Cloudar.

It is the most primitive cost optimization imaginable, and the fact that people reach for it tells you exactly where AI operations are heading. Developers are willing to make their assistant grunt like a Neanderthal to trim a few thousand tokens off a session. Something changed to make that feel worth doing.

For the past two years, most of us have been running AI workloads on someone else’s dime. Flat-rate subscription plans made generative AI feel free at the point of use. Fire off as many prompts as you want, let your coding agent churn through refactors overnight, and the bill stays the same.

That era is ending. LLM providers are increasingly pushing heavy workloads toward usage-based pricing, credits, stricter rate limits, or token-metered APIs, and the reason is simple: the plans were too cheap. The compute behind a heavy agentic workload costs real money, and providers can no longer subsidize power users with the margins of light users. Rate limits are tightening, “unlimited” tiers are disappearing, and token-based billing is becoming the norm.

If you have ever watched an AWS bill balloon because nobody rightsized their EC2 fleet, you know exactly what happens next. The token is the new gigabyte, and we are about to relive the FinOps learning curve, this time for AI.

That is why we need FinAIOps: FinOps for AI systems, where LLMOps meets cost discipline in production. It is the practice of running AI workloads with the same operational and cost rigor we apply to everything else in the cloud.

Lessons from building agents in production

At Cloudar we have been building and running agentic AI workloads in production. Doing that teaches you very quickly where tokens go to die. These are the practices that made the biggest difference.

1. Use smaller models for simpler tasks

Not every task needs your most capable model. Agent routing, classification, and simple extraction run perfectly well on smaller, cheaper models. Reserve the frontier model for the reasoning-heavy steps. The per-token price difference between a frontier model and a small model on Bedrock is easily an order of magnitude, so a lightweight router that dispatches work to the right specialist pays for itself immediately.

This is where Amazon Bedrock shines: switching between model families and sizes is a configuration change, not a re-architecture. You can experiment with the cost and quality trade-off per task and measure the result.

2. Gatekeep the agent: deterministic first

The cheapest LLM call is the one you never make. If a task can be solved deterministically, solve it deterministically. Fetching a metric, checking a threshold, parsing a known log format: none of that needs an agent. Put a gate in front of your agent that handles the predictable cases with plain code and only escalates genuine ambiguity to the model.

3. Keep prompts compact

Prompts are tokens, and tokens are money. Every instruction, every example, every “please be helpful and thorough” costs you on every single invocation. Ruthlessly edit your system prompts. Say what you need, cut what you do not, and test whether shorter prompts degrade quality. Usually they do not.

4. Limit the tools your MCP servers expose

This one is underestimated. Every tool definition you expose to an agent is injected into the context on every call. It might feel convenient to give your agent the full toolbox, but a wall of tool schemas eats tokens before the agent has done any actual work.

Only expose the tools the agent genuinely needs. And when you do not know upfront which tools an agent will use, for example with open-ended investigative workloads, take an iterative approach: expose everything, have the agent write a short analysis after each run, and after a set period feed those results to an advanced model to analyze which tools earn their place and which can be dropped. Treat your tool catalog like an IAM policy: least privilege, reviewed regularly.

5. Cap the loop

Agentic workloads can run away. An agent stuck in a retry loop is the token equivalent of a Lambda retry storm. Set a maximum number of steps and tool calls per run, and a hard token budget per invocation. Fail loud, not expensive.

6. Mind your outputs and your history

For many frontier models, output tokens are priced significantly higher than input tokens. Ask for structured output instead of prose, set max_tokens deliberately, and instruct the model to be terse. And do not drag the full conversation history through every turn: summarize or window older context, because in long-running agents the context snowballs and you pay for all of it on every call.

7. Use prompt caching

On Bedrock, prompt caching lets you cache the static parts of your context, such as system prompts and tool definitions, and pay a fraction of the input price on subsequent calls. If you have a large tool catalog you cannot trim further, caching softens the blow considerably. Combined with point 4, this is one of the highest-impact optimizations available today.

8. Batch what is not urgent

Amazon Bedrock batch inference runs asynchronous workloads at a 50 percent discount compared to on-demand pricing. You submit a JSONL file with your prompts, Bedrock processes them asynchronously, and the results land in S3, typically within 24 hours. Periodic analysis jobs are a textbook example: nobody is waiting on the result, so there is no reason to pay real-time prices for it.

Bedrock also offers a Flex service tier for supported models, trading latency for lower cost. Unlike batch, Flex uses the regular invocation API: you add a service tier parameter to your call and accept increased latency in exchange for the lower rate. Availability and discount levels depend on the model and tier, so check the current pricing page before assuming the same economics as batch. It is a good fit for background agent runs that are real-time in shape but not in urgency.

The practices above, at a glance:

Measure it or it did not happen

Optimization without measurement is guesswork. Two AWS capabilities matter here.

Amazon CloudWatch gives you deep visibility into every dimension of your Bedrock usage. Bedrock publishes runtime metrics to the AWS/Bedrock namespace, with ModelId among the available dimensions. Which dimensions apply, and whether ModelId alone is enough, depends on the model, Region, service tier, and whether you invoke through an inference profile, so treat any dashboard as a starting point rather than a template that works unchanged everywhere. The ones to watch:

• Invocations: how often each model is called
• InputTokenCount and OutputTokenCount: where your money actually goes
• InvocationLatency: the quality side of the trade-off
• InvocationThrottles and InvocationClientErrors: the signals that an agent is misbehaving

Build a dashboard on these, and set an alarm on token consumption. For example, a CloudWatch alarm on the hourly Sum of OutputTokenCount per model catches a runaway agent loop within the hour instead of on next month’s invoice:

aws cloudwatch put-metric-alarm \
  --alarm-name bedrock-output-token-spike \
  --namespace AWS/Bedrock \
  --metric-name OutputTokenCount \
  --dimensions Name=ModelId,Value=<your-bedrock-model-id-or-inference-profile> \
  --statistic Sum --period 3600 \
  --threshold 5000000 \
  --comparison-operator GreaterThanThreshold \
  --evaluation-periods 1 \
  --alarm-actions arn:aws:sns:eu-west-1:123456789012:ops-alerts

Replace the model ID with the exact model or inference profile dimension used in your account, since Bedrock model IDs are versioned and vary by Region and provider. Enable model invocation logging as well, so you can see the actual prompts behind an anomaly. Treat anomalous spend like any other operational incident.

Bedrock application inference profiles let you tag usage per agent, per workflow, or per customer. You create a profile that wraps a foundation model, attach cost allocation tags, and invoke through the profile ARN instead of the model ID:

aws bedrock create-inference-profile \
  --inference-profile-name customer-a-investigator \
  --model-source copyFrom=arn:aws:bedrock:eu-west-1::foundation-model/anthropic.claude-sonnet-4-5 \
  --tags key=customer,value=customer-a key=agent,value=investigator

Those tags flow through to Cost Explorer and CloudWatch, turning “the AI bill is high” into “agent X on task Y for customer Z is driving the cost.” For a managed service provider, this is essential: it enables proper chargeback and shows customers exactly what their AI workloads cost.

Finally, track the metric that actually matters: cost per outcome. Tokens per completed task beats tokens per month. An agent that uses three times the tokens but delivers twice the results is the cheaper agent. That is the KPI that makes FinAIOps a business discipline instead of a savings exercise.

The bill is coming. Be ready.

The shift from plans to tokens is not a pricing tweak, it is a forcing function. Teams that treat AI as free will get the same surprise bills we saw in the early cloud days. Teams that apply FinAIOps discipline, right-sized models, gated invocations, lean prompts, curated tool catalogs, caching, batching, and real cost attribution, will run AI workloads that are both powerful and predictable.

We learned the hard way with EC2 that capacity discipline pays off. Let us not learn it the hard way again with tokens.

The post FinAIOps: Why Token Economics Will Define Your AI Operations appeared first on Cloudar.