Cloudprice

Look up the on-demand Linux hourly + monthly price for an AWS EC2 instance type in us-east-1. Returns vCPUs, memory, hourly USD, and monthly USD (730 hours). For multi-cloud comparisons including OCI, Azure, and GCP, use compare_clouds instead.

Look up the on-demand Linux hourly + monthly price for an Azure VM size in eastus. Returns vCPUs, memory, hourly USD, and monthly USD.

Look up the on-demand Linux hourly + monthly price for a GCP Compute Engine machine type in us-east1. Returns vCPUs, memory, hourly USD, and monthly USD.

Find the cheapest equivalent VM across AWS, Azure, GCP, and OCI for a single target spec (vCPUs and memory). Returns the best-fit SKU per cloud sorted by monthly cost, plus the absolute and percent savings of the cheapest vs the most expensive option. OCI A1 Always Free is included — for specs that fit within 4 OCPU + 24 GB Arm, OCI returns $0/mo (real perpetual free tier, not a quirk).

Bulk-compare a list of compute workloads across AWS, Azure, GCP, and OCI. Each row is independently sized to the cheapest VM that meets its vCPU/memory spec on each cloud, multiplied by quantity and hours_per_month. Optional os_disk_gb adds attached storage cost. Returns per-row matches, per-cloud totals, and the cheapest cloud overall. Useful for sizing-sheet style inputs.

Bulk-compare a list of block-storage volumes across AWS, Azure, GCP, and OCI. Each row picks the cheapest SKU matching its disk_type (ssd or hdd) on each cloud, then prices it at capacity_gb × quantity. Returns per-row matches, per-cloud totals, and cheapest cloud. IOPS and throughput are accepted but not used for SKU matching. Snapshot pricing is upper-bound (real-world incremental snapshots cost less).

Compare data-transfer costs across AWS, Azure, GCP, and OCI for a given monthly volume. Two directions supported: 'out_to_internet' (tiered pricing with free-tier credits — AWS/Azure 100 GB, OCI 10 TB free) and 'inter_region' (flat rate for cross-region transfer within the same cloud). At 50 TB/mo of internet egress OCI is ~12× cheaper than the hyperscalers — a real competitive moat for content/CDN workloads. VPC peering is NOT yet modeled.

Compare object-storage pricing across AWS S3, Azure Blob, GCP Cloud Storage, and OCI Object Storage. Each request specifies capacity_gb and access tier (hot/cool/archive); the tool picks the cheapest SKU per cloud at that tier. OCI offers 20 GB Always Free in the 'hot' tier — surfaced when capacity fits. NOTE: egress, request, and retrieval costs are not modeled (often the actual hidden killer). Prices are hand-entered list prices (as of 2026-05-04), not part of the weekly refresh — verify against the provider's page before deciding.

Compare managed PostgreSQL pricing across AWS RDS, Azure Database for PostgreSQL, GCP Cloud SQL, and OCI Database with PostgreSQL. Each request specifies vCPUs, memory, and storage_gb; the tool picks the cheapest matching SKU per cloud and totals compute + storage. Prices are hand-entered estimates (as of 2026-05-04), not part of the weekly refresh — verify against the provider's page before deciding.

Combined compute + block-storage compare across AWS, Azure, GCP, and OCI. Pass a compute list and a storage list (either may be empty). Returns nested per-row breakdowns plus combined per-cloud totals and the overall cheapest cloud. Mirrors the structure of a two-sheet sizing workbook (compute BoM + storage BoM). Optional `commitment` parameter estimates 1-year or 3-year Reserved Instance / Savings Plan / Committed Use discount on compute (storage stays at on-demand). For object storage, use compare_object_storage. For managed databases, use compare_postgres_database.

Project cross-cloud cost + payback for moving a workload away from its source cloud. Inputs: source_cloud + workload inventory (compute / storage / object_storage / databases / egress) + optional one_time data to migrate. Returns per-target monthly cost, savings %, exit egress cost, payback months, ranked recommendation by 3-year TCO, and triggered caveats (e.g., 'OCI A1.Flex is ARM — verify your AMIs'). The kind of FinOps decision that normally lives in a half-built spreadsheet — now one tool call.

Compute per-scenario cost / savings / payback for compute commitment options (none, 1yr_no_upfront, 1yr_all_upfront, 3yr_no_upfront, 3yr_partial_upfront, 3yr_all_upfront). Returns each scenario's monthly cost, upfront, 3-year total, savings %, and payback months — plus the recommended scenario by lowest 3-year TCO. Compute-only (storage / database / object / egress are not discounted because most clouds don't offer meaningful commitments on these). Per-family RI tiers come in v0.6.x; v0.6.0 uses cloud-level conservative averages.

Project per-cloud per-year cost over a configurable horizon (default 3 years), with linear YoY growth assumptions for compute / storage / egress. Returns cumulative TCO per cloud, year-by-year breakdown by category, and sensitivity analysis identifying the most impactful growth variable. The kind of number that goes into board decks and budget conversations — now computed from a public catalog instead of a spreadsheet.

Specialized assess_migration scoped to egress patterns. Useful when a team's largest cost line is data transfer (CDN workloads, video streaming, content distribution). Returns per-target egress cost, monthly + annual savings, payback months on any one-time exit cost, and recommendation. The OCI 12× moat is the headline finding: at 50 TB/month internet egress, OCI is roughly $340 vs $4,000+ on the hyperscalers because of OCI's 10 TB/month free tier + $0.0085/GB beyond.

Return the multi-cloud price history for a specific (cloud, sku). cloudprice-mcp persists every weekly auto-refresh as a dated snapshot, so this is the only FinOps tool that can answer 'what did m5.xlarge cost in May?' — neither AWS Calculator nor GCP Estimator preserves historical pricing. Returns the timeseries, total change %, and the earliest/latest data points. Useful for: validating commitment timing, spotting quiet price increases, citing audit-traceable historical numbers to a CFO.

List every (cloud, sku) pair present in the bundled price-history dataset, with how many weekly snapshots exist for each. Use this to discover which SKUs you can call get_price_history on, or to find the biggest-mover SKUs since a given date. Filter by cloud to scope.

Generate a CFO-grade FinOps decision report in markdown. Combines assess_migration + compare_carbon_footprint into a single structured artifact the user can paste into a wiki / PR / Slack / email. Sections: executive summary, per-cloud cost table, carbon comparison (optional), the workload spec, aggregated honest_gaps, and an audit trail (package version, catalog as_of, requester, reproduce command). The 'trust' angle commercial FinOps tools can't easily replicate because their reports live in their UI; this one is markdown the user owns. Use when the question is 'we need a decision artifact a CFO can sign off on'.

Statistical anomaly detection over the bundled price-history dataset. Compounds the v0.7.1 history archive: as snapshots accumulate weekly, this tool auto-flags unusual price moves without you having to manually inspect every SKU. Two methods, auto-selected by dataset density: percent_change (for <5 snapshots) and z_score (>=5). Sensitivities: strict (10% / z>=2.5), moderate (5% / z>=2.0, default), permissive (2% / z>=1.5). Use for 'what changed this week?' and 'anything weird across any cloud since {date}?' queries. Excellent source for weekly LinkedIn / blog content auto-generation.

Cross-provider LLM token pricing comparison — the only FinOps tool that returns per-1M input/output rates AND monthly cost for the same model on each provider that hosts it (Claude on Anthropic vs Bedrock vs Vertex; GPT on OpenAI vs Azure OpenAI; Llama on Bedrock; Gemini on Google vs Vertex; Mistral / DeepSeek direct). Filter by model_family ('claude', 'gpt', 'gemini', 'llama', 'mistral', 'deepseek'), exact model_id, or provider list. If monthly_input_tokens + monthly_output_tokens are provided, ranks by total monthly USD. Otherwise ranks by per-1M output cost (output tokens dominate most workloads). Surfaces cache_read / cache_write rates when published — most workloads see 30-90% input cost reduction with proper prompt caching.

Analyse the user's actual cloud bill from a FOCUS 1.x CSV export (AWS Data Exports, Azure Cost Management, GCP BigQuery FOCUS view, OCI). Read from local disk only; nothing is sent anywhere. Returns total cost, top cost drivers grouped by service / category / provider / region / SKU / resource, cost by month, the biggest month-over-month movers, list vs effective cost (what discounts saved), and commitment coverage of usage when the export carries commitment columns. Use for: 'where is our cloud money going', 'what jumped last month', 'how much of our usage is covered by RIs / Savings Plans'. Ask the user for the path to their export file.

FinOps rate optimisation on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Returns commitment coverage of eligible compute and database usage, utilisation of existing Savings Plans / RIs / CUDs (and what unused commitment cost), and per cloud the steady on-demand spend that could be committed, with the $/hour commitment and annual saving for 1-year and 3-year no-upfront terms. Use for: 'are we under-committed', 'how much would a Savings Plan save us', 'are our reservations being used'.

FinOps anomaly management on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Compares each service's daily (or monthly) cost with its own recent normal and reports spikes, drops and new spend as events, ranked by excess cost, flagging events still going in the latest period. Use for: 'what blew up our bill', 'did anything unusual happen last week', 'what new spend appeared'.

FinOps allocation on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Measures how much allocatable cost carries the tags used for showback / chargeback, coverage per required tag, cost by the values of one tag (e.g. team), cost by sub-account, and the biggest untagged services and resources. Use for: 'how much of our spend is tagged', 'cost per team', 'what is missing a cost-center tag'.

FinOps forecasting on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Projects month-end spend and the next months from the trend in recurring spend, each with a 95% range, and lists the services whose spend is growing fastest. Daily exports (28+ days) give a daily trend and a month-end estimate. Use for: 'what will this month's bill be', 'where is spend heading next quarter', 'what is driving growth'.

FinOps unit economics on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Divides monthly recurring spend by business volumes the user supplies (customers, requests, orders) to give cost per unit by month, and whether spend is growing faster or slower than the business. Optionally scoped to one product or team by tag. Use for: 'cost per customer', 'are we scaling efficiently'. Ask the user for the monthly volumes.

FinOps benchmarking on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Works out the vCPU-hours and memory the bill's compute actually used and prices that same capacity at list price on AWS, Azure, GCP and OCI, per instance type and in total, next to what the user really paid. Reports what it could not reprice (GPUs, licensed OS, unknown types) with its cost. Use for: 'what would our bill cost on another cloud', 'are we on the cheapest cloud for this compute', 'is a migration worth looking at'.

FinOps for AI on the user's actual bill (a local FOCUS 1.x CSV export; nothing is sent anywhere). Finds the generative-AI lines (Amazon Bedrock, Azure OpenAI / AI Foundry, Vertex AI, OCI Generative AI) and gives spend per model split into input, output, cache-read and cache-write tokens; what was paid against list price; the same model's cost on other providers for the same tokens; how much input comes from prompt cache and what more would save; and list price changes for those models from the weekly LLM price archive. Use for: 'what is our LLM spend', 'are we overpaying for this model', 'would caching help'.

Well-Architected review of an Amazon Bedrock AgentCore deployment, run locally on `terraform show -json` output (a saved plan or state; nothing is sent anywhere, no AWS credentials). Coded rules check every Runtime, Harness and Gateway and the IAM, logs and alarms around them: public network, unauthenticated or debug gateways, InvokeModel on every model, secrets in environment variables, idle and lifetime settings, harness caps, log retention, alarms and cost tags. Each finding has severity, pillar, resource address, a Terraform fix and the AWS doc it rests on. Given a FOCUS bill (and a tag such as agent=genie) it adds what the agent costs by component and the prompt-caching and over-list-price savings. Use for: 'review our AgentCore setup', 'is this agent production-ready', 'what does this agent cost and what should we fix'.

Pay per token or rent GPUs and serve the model yourself? Prices a monthly token volume on an LLM API, then the GPU servers needed to serve the same volume on AWS, Azure, GCP and OCI, and the break-even volume. Needs the measured generation throughput of one server (output tokens/second, e.g. from a vLLM benchmark): it decides the answer and is never guessed. Use for: 'should we self-host Llama 3.3 70B instead of paying Together', 'at what volume do H100s beat the DeepSeek API', 'cheapest cloud to serve our open model'. Self-host cost is GPU rental only; see honest_gaps.

Where to host an AI agent, and what a month of it costs: the same agent priced on Amazon Bedrock AgentCore Runtime, Azure AI Foundry Agent Service (prompt agents and hosted agents), Google Vertex AI Agent Engine, and plain serverless (AWS Lambda, Azure Container Apps). Each platform is split into hosting, tools, memory and model tokens, with the model priced on that cloud's own model service (or marked unavailable), and the busy share of a run below which AgentCore costs less than each alternative. Use for: 'AgentCore vs Foundry vs Vertex for our agent', 'should this agent run on Lambda or AgentCore', 'what will hosting 50,000 agent runs a month cost'. For token counts per run, use estimate_agent_cost first.

Estimate what one run of an AI agent costs, and a month of runs. Models what per-call math misses: each agent step re-sends the whole conversation (system prompt, tool definitions, earlier outputs and tool results), so input tokens grow every step. Returns cost per run and per month, the per-step token breakdown, how much of the input is context growth, what prompt caching saves, and the same run priced on other current models (Claude, GPT, Gemini, DeepSeek by default). Use for: 'what will my agent cost at 50k runs a month', 'is Sonnet or Haiku cheaper for this agent', 'how much does caching save', 'budget for an AgentCore / LangGraph / Agents SDK agent'. Defaults describe a typical 8-step tool-using agent; pass measured token counts for a real figure.

Which LLMs providers are retiring: models whose retirement date (from LiteLLM's feed, refreshed weekly) falls within the window, across Bedrock, Azure OpenAI / AI Foundry, Vertex AI, OpenAI, Anthropic and others, plus those retired in the last 90 days. For each: the date, days left, and the newest same-family model on the same provider that is not retiring, with its list price change. Use for: 'which of our models are being retired', 'is Claude 3.5 Sonnet on Bedrock going away', 'what replaces gpt-4o on Azure'. analyze_ai_spend and review_agentcore flag retiring models on your bill and in your deployment automatically.

What changed in LLM token pricing between two weeks: models that were repriced (with old and new $/1M input and output, and % move), models added, and models removed, across ~3,600 model/provider rows from LiteLLM (direct provider prices) and OpenRouter (routed prices). Backed by a weekly archive kept since 2026-05-23. Use for: 'what got cheaper this week', 'did Anthropic or Bedrock change prices since October', 'new models on Groq this month', 'has Mistral Large's price moved'. Defaults to the latest week vs the week before.

Emit FOCUS 1.3-shaped rows from any pricing query, ready to import into Vantage Custom Providers / Microsoft Cost Mgmt / OpenCost / Apptio / any FinOps tool that consumes the FinOps Foundation's open billing schema (ratified Dec 2025). The rows populate the list-price columns (ListCost, ListUnitPrice, PricingQuantity, etc.) and leave billed/contracted/effective columns NULL since cloudprice produces projections, not real bills — that's explicitly documented in the result's notes field. Use this when the user says 'export my comparison to FOCUS', 'send this to Vantage', 'plug this into our FinOps stack'. Supports query_kind: compute_workload (calls assess_migration), token_pricing (compare_token_pricing), extended_model_lookup (lookup_extended_model_pricing). Format is 'json' (default) or 'csv'.

Search the extended LLM catalog (~2300 model/provider combinations auto-ingested weekly from two upstreams: LiteLLM's public JSON (direct-provider retail prices for Together AI, Fireworks, Replicate, Groq, Cerebras, Perplexity, regional Bedrock/Azure variants, etc.) and OpenRouter's /api/v1/models (routed prices including OpenRouter's margin). Every row tagged source='litellm' or source='openrouter' so callers can compare direct vs routed pricing for the same model. Complements compare_token_pricing (hand-curated, 19 vetted models). Use this when the user asks about: (a) a model or provider compare_token_pricing doesn't know — 'cheapest place to host Llama 3.1 405B', 'Together AI pricing', 'what Groq charges for Mixtral' — or (b) whether OpenRouter routing is cheaper or more expensive than going direct to Bedrock/Anthropic/OpenAI ('does OpenRouter add margin for Claude 3 Haiku?').

Cross-cloud GPU pricing comparison — finds the cheapest matching SKU per cloud for a (gpu_type, gpu_count) request. Supports NVIDIA T4 / A10 / A10G / L4 / L40S / V100 / A100 / H100 across AWS / Azure / GCP / OCI. Returns absolute hourly cost AND $/GPU/h so users can see both the absolute winner and the per-GPU packaging-efficiency winner (they're often different clouds). Surfaces over-provisioning when the only matching SKU has more GPUs than requested (e.g., asking for 1 H100 but only bare-metal 8x SKUs are available). Use for AI/ML workload pricing decisions — training, inference, fine-tuning.

Multi-cloud carbon footprint comparison — the only FinOps tool that returns both USD cost AND kg CO2e/month side-by-side. For a given vCPU + memory shape (and optional quantity), returns per-cloud best-matching SKU + monthly cost + grid-based kg CO2e + market-based residual kg CO2e (after the cloud's published renewable matching) + power class (x86 vs ARM). Ranked cheapest-carbon-first. Surfaces tradeoffs (AWS/Azure 100% renewable matched, GCP ~64% CFE, OCI unmatched outside EU). Use when the user cares about sustainability, Green FinOps, or carbon-cost dual optimization.

Cost Drift Sentinel — turns cloudprice from query tool into agent capability. First call (no baseline): captures the current per-cloud monthly cost for the workload as a baseline JSON the caller persists. Subsequent calls (with the saved baseline): compute today's cost, compare to baseline, return a structured drift report with per-cloud delta + SKU-level attribution from the price-history dataset. Stateless — no database, no server-side storage. Drop the baseline JSON into a git repo or any durable location. Designed for scheduled agents (GitHub Actions cron, Claude Code's autonomous mode, etc.) to detect 'has this cost moved since I signed off?' between runs.

Compare spot / preemptible pricing for a vCPU + memory shape across AWS, Azure, GCP, and OCI. Returns per-cloud best-matching SKU + on-demand cost + spot cost + savings + eviction characteristics, ranked cheapest-first. The only multi-cloud spot comparison anyone publishes openly — AWS Spot vs Azure Spot vs GCP Spot VMs vs OCI Preemptible all use different pricing + eviction models, and this tool surfaces every one of them with their tradeoffs.