# azure-cost-management

Adopt this skill: https://proskills.md/skills/other/cloudchef-atlasclaw-providers-skills-azure-cost-management

Page: https://proskills.md/skills/other/cloudchef-atlasclaw-providers-skills-azure-cost-management
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: skills/azure-cost-management/SKILL.md
size: 35195
sha: b8bc48c59d58e035d14c595aab2aa74340ca91c3
upstream: https://github.com/cloudchef/atlasclaw-providers/blob/main/skills/azure-cost-management/SKILL.md
truncated: true

```text
---
name: azure-cost-management
description: Expert knowledge for Azure Cost Management development including troubleshooting, best practices, decision making, architecture & design patterns, limits & quotas, security, configuration, integrations & coding patterns, and deployment. Use when managing budgets/alerts, exports, Cost Management APIs, reservations/savings plans, or Hybrid Benefit, and other Azure Cost Management related development tasks. Not for Azure Advisor (use azure-advisor), Azure Monitor (use azure-monitor), Azure Quotas (use azure-quotas), Azure Portal (use azure-portal).
compatibility: Requires network access. Uses mcp_microsoftdocs:microsoft_docs_fetch or fetch_webpage to retrieve documentation.
metadata:
  generated_at: "2026-04-19"
  generator: "docs2skills/1.0.0"
---
# Azure Cost Management Skill

This skill provides expert guidance for Azure Cost Management. Covers troubleshooting, best practices, decision making, architecture & design patterns, limits & quotas, security, configuration, integrations & coding patterns, and deployment. It combines local quick-reference content with remote documentation fetching capabilities.

## How to Use This Skill

> **IMPORTANT for Agent**: Use the **Category Index** below to locate relevant sections. For categories with line ranges (e.g., `L35-L120`), use `read_file` with the specified lines. For categories with file links (e.g., `[security.md](security.md)`), use `read_file` on the linked reference file

> **IMPORTANT for Agent**: If `metadata.generated_at` is more than 3 months old, suggest the user pull the latest version from the repository. If `mcp_microsoftdocs` tools are not available, suggest the user install it: [Installation Guide](https://github.com/MicrosoftDocs/mcp/blob/main/README.md)

This skill requires **network access** to fetch documentation content:
- **Preferred**: Use `mcp_microsoftdocs:microsoft_docs_fetch` with query string `from=learn-agent-skill`. Returns Markdown.
- **Fallback**: Use `fetch_webpage` with query string `from=learn-agent-skill&accept=text/markdown`. Returns Markdown.

## Category Index

| Category | Lines | Description |
|----------|-------|-------------|
| Troubleshooting | L37-L66 | Diagnosing and fixing Azure billing, subscription, and reservation issues—errors, disabled subscriptions, payment failures, access problems, and low/zero utilization or recommendation anomalies. |
| Best Practices | L67-L77 | Best practices for analyzing and optimizing Azure costs, using Advisor and savings plans, onboarding under MCA, managing Azure Hybrid Benefit, and setting up org-wide cost management processes |
| Decision Making | L78-L149 | Deciding how to allocate and analyze Azure costs, choose subscriptions and billing models, and optimize spend with reservations, savings plans, Hybrid Benefit, and limited-time discounts. |
| Architecture & Design Patterns | L150-L154 | How Azure bills centrally assigned SQL Server licenses hourly, including license assignment, cost calculation, and optimization considerations |
| Limits & Quotas | L155-L170 | Azure cost limits, quotas, and timing: free tier usage, credits, spending limits, data transfer fees, savings plans, SQL licensing, subscription limits, and billing account dormancy. |
| Security | L171-L192 | Securing Azure billing and cost data: RBAC roles, admin access, directory transfers, fraud prevention, and permissions for subscriptions, reservations, and savings plans. |
| Configuration | L193-L234 | Configuring Azure Cost Management: budgets, alerts, tags, exports, cost analysis views, reservations/savings plans, billing ownership/transfers, payment methods, and EA/MCA/partner billing settings. |
| Integrations & Coding Patterns | L235-L251 | APIs, scripts, and Power BI for cost/billing analysis, plus programmatic creation and management of EA/MCA/MPA subscriptions and reservations across tenants. |
| Deployment | L252-L255 | Configuring automated, large-scale exports of Azure cost and usage data to storage (like Azure Storage), including setup, scheduling, and management for ongoing cost analysis. |

### Troubleshooting
| Topic | URL |
|-------|-----|
| Troubleshoot common Azure Cost Management error codes | https://learn.microsoft.com/en-us/azure/cost-management-billing/costs/cost-management-error-codes |
| Fix and reactivate disabled Azure for Students subscriptions | https://learn.microsoft.com/en-us/azure/cost-management-billing/manage/azurestudents-subscription-disabled |
| Troubleshoot and reactivate a disabled Azure subscription | https://learn.microsoft.com/en-us/azure/cost-management-billing/manage/subscription-disabled |
| Troubleshoot subscription access issues after MCA signup | https://learn.microsoft.com/en-us/azure/cost-management-billing/microsoft-customer-agreement/troubleshoot-subscription-access |
| Find who purchased an Azure reservation using logs | https://learn.microsoft.com/en-us/azure/cost-management-billing/reservations/find-reservation-purchaser-from-logs |
| Resolve issues downloading Azure reservation usage details | https://learn.microsoft.com/en-us/azure/cost-management-billing/reservations/troubleshoot-download-usage |
| Fix 'No eligible subscriptions' when buying reservations | https://learn.microsoft.com/en-us/azure/cost-management-billing/reservations/troubleshoot-no-eligible-subscriptions |
| Fix Azure reservation types appearing as not available | https://learn.microsoft.com/en-us/azure/cost-management-billing/reservations/troubleshoot-product-not-available |
| Troubleshoot unexpected Azure reservation recommendations | https://learn.microsoft.com/en-us/azure/cost-management-billing/reservations/troubleshoot-reservation-recommendation |
| Transfer Azure reservation orders between Entra tenants | https://learn.microsoft.com/en-us/azure/cost-management-billing/reservations/troubleshoot-reservation-transfers-between-tenants |
| Resolve Azure reservations showing zero or low utilization | https://learn.microsoft.com/en-us/azure/cost-management-billing/reservations/troubleshoot-reservation-utilization |
| Troubleshoot Azure savings plan utilization anomalies | https://learn.microsoft.com/en-us/azure/cost-management-billing/savings-plan/troubleshoot-savings-plan-utilization |
| Troubleshoot Azure billing payment update errors | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/billing-troubleshoot-azure-payment-issues |
| Fix VM creation errors for Azure EA users | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/cannot-create-vm |
| Resolve missing billing account in Azure portal | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/troubleshoot-account-not-found |
| Fix issues viewing Azure invoices in portal | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/troubleshoot-cant-find-invoice |
| Use pivot tables to troubleshoot CSP billing issues | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/troubleshoot-csp-billing-issues-usage-file-pivot-tables |
| Use pivot tables to troubleshoot MCA billing issues | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/troubleshoot-customer-agreement-billing-issues-usage-file-pivot-tables |
| Resolve declined credit cards for Azure billing | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/troubleshoot-declined-card |
| Use pivot tables to troubleshoot EA billing issues | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/troubleshoot-ea-billing-issues-usage-file-pivot-tables |
| Diagnose and fix Azure threshold billing issues | https://learn.microsoft.com/en-us/azure/cost-management-billing/troubleshoot-billing/troubleshoot-threshold-billing |
| Resolve 'account belongs to a directory' subscription sign-up error | https://learn.microsoft.com/en-us/azure/cost-mana
```

## File: README.md
upstream: https://github.com/cloudchef/atlasclaw-providers/blob/main/README.md

````text
# AtlasClaw Providers

Reusable provider packages and starter patterns for integrating external enterprise systems with AtlasClaw.

This repository is the home for concrete provider packages such as SmartCMP and
Jira. AtlasClaw core documents the loading contract; this repository documents
provider behavior, auth models, field semantics, workflow patterns, and
reference implementations.

![AtlasClaw provider runtime overview](docs/images/provider-runtime-overview.svg)

## What Is a Provider?

A provider is a self-contained integration package for one external system. It owns:

- connection and authentication conventions
- one or more skills for different business capabilities
- skill definitions exposed to the agent
- executable scripts or handlers that call the target system
- provider-specific documentation and reference material

## What Is in This Repository?

This repository contains reusable provider packages and reference implementations:

| Provider | Purpose | Status |
| --- | --- | --- |
| [`SmartCMP-Provider`](providers/SmartCMP-Provider/README.md) | Context-aware cloud requests, approvals, resource analysis and operations, monitoring, compliance, and FinOps workflows | Reference implementation |
| [`jira`](providers/jira/README.md) | Jira issue operations and provider wiring patterns | Working example |
| [`Weaver-Ecology`](providers/Weaver-Ecology/README.md) | Weaver Ecology OA workflow provider manifest and SSO configuration schema | Manifest scaffold |

If you are new to the model, start with:

1. [`providers/SmartCMP-Provider/README.md`](providers/SmartCMP-Provider/README.md)
2. [`providers/SmartCMP-Provider/PROVIDER.md`](providers/SmartCMP-Provider/PROVIDER.md)
3. [`providers/jira/skills/jira-issue/SKILL.md`](providers/jira/skills/jira-issue/SKILL.md)

## Provider Package Structure

AtlasClaw providers follow a simple package layout:

```text
providers/<provider-name>/
├── PROVIDER.md              # LLM-facing provider contract
├── provider.schema.json     # Runtime/API/UI manifest
├── README.md                # Human-facing package docs
├── assets/                  # Optional icons/images
├── assistant_context/       # Optional context-aware embed routes and resolver
│   ├── routes.json          # Enterprise System path → page object → existing Skill
│   └── resolve.py           # Provider-owned object and action resolver
└── skills/
    ├── <skill-a>/
    │   ├── SKILL.md         # Skill metadata, trigger rules, entrypoints
    │   ├── scripts/         # Python handlers or helper scripts
    │   └── references/      # Provider-specific API mapping, workflows, examples
    └── <skill-b>/
        └── ...
```

### File Responsibilities

- `provider.schema.json`: machine-readable manifest for runtime/API/UI and
  code-analysis agents. It owns catalog display metadata, config fields,
  auth modes, defaults, aliases, sensitive flags, and optional icon paths.
- `PROVIDER.md`: natural-language provider contract for LLM context and
  provider usage rules. Runtime must never parse schema from `PROVIDER.md`
  body tables.
- `README.md`: explains the provider package to human readers
- `SKILL.md`: declares the skill name, description, provider binding, and executable entrypoints
- `scripts/`: implements the actual integration logic
- `references/`: keeps API mappings, examples, and workflow notes close to the skill

Note: the directory name is a packaging concern, while the runtime identifier comes from `provider_type` in skill metadata and the corresponding key in `service_providers`. In this repository, `SmartCMP-Provider/` maps to the runtime provider type `smartcmp`.

## Embedded Menu and Floating UI

AtlasClaw Embedded mode provides two independent surfaces that can be deployed
together or separately:

- the menu UI opens a full AtlasClaw conversation without page Context;
- the floating UI stays compact and follows supported Enterprise System pages.

Both surfaces receive the same Enterprise System Cookie authentication context.
AtlasClaw `host_cookie` authentication resolves the same signed-in user, while
the configured HostApp Provider's Cookie auth mode forwards the current request
Cookie to the existing system APIs. The surfaces can also share a
bootstrap-validated active Chat Session, but one does not open, replace, or
control the other.

For the menu surface, the Enterprise System only needs a menu entry that embeds
`/atlasclaw/?embedded=1&surface=menu`. It does not provide page Context. For the
floating surface, the Enterprise System additionally owns the launcher and
compact iframe lifecycle, supplies the exact Host Origin and a fresh nonce, and
reports normalized route paths with monotonically increasing generations.
Enterprise System code does not resolve business objects, choose a Provider or
Skill, call Agent/Tool APIs, or duplicate confirmation UI.

Core owns surface bootstrap, the secure embedding protocol, deterministic
matching, Context lifecycle, and permission revalidation. The HostApp Provider
owns the floating page semantics. For the floating surface, the optional
`assistant_context/routes.json` manifest maps normalized Enterprise System
paths to:

- a stable page type;
- a provider-owned object type;
- the existing Provider Skill that owns the page workflow.

Each route uses static path segments and single-segment placeholders such as
`/main/items/{item_id}`. AtlasClaw evaluates the manifest again whenever the
Enterprise System reports a newer page generation. This makes Context matching
dynamic at runtime while keeping it deterministic and auditable; an LLM does
not guess which page or Skill is active.

The single Provider-level resolver loads the current business object with the
request-scoped user credential and returns a bounded display projection plus
the object's current `object_actions`. Actions can vary with object state,
permissions, and available workflows. They enter the normal Chat path and the
matched Skill's normal Tool, schema, confirmation, Provider, and RBAC checks;
the browser does not select or invoke a Tool directly.

Use these extension rules:

- A new path for an already supported object and owning Skill normally adds one
  route entry.
- A new object API extends the Provider resolver's read adapter and the owning
  Domain Skill's action builder.
- Do not add provider-specific page mappings, action labels, or object fields
  to AtlasClaw Core or the generic floating UI.
- Do not put cookies, tokens, credentials, query strings, fragments, or
  business DTOs in route manifests or embedding messages.

See the [Core Embedded integration
guide](https://github.com/CloudChef/atlasclaw/blob/main/docs/EMBED-INTEGRATION.md)
for surface bootstrap, Cookie, Context, and page-message contracts.

## Authentication Model

Authentication is a provider responsibility. AtlasClaw Core can pass user identity and runtime context, but each provider must obtain or derive credentials that the target system actually accepts.

That matters because one provider usually exposes multiple skills, and all of those skills must execute under the same user identity model for the target system.

### Mode 1: Embedded UI

Embedded mode uses a two-layer Cookie contract:

- AtlasClaw `auth.provider: "host_cookie"` reads the Enterprise System Cookie
  and identity cookies to resolve the signed-in AtlasClaw user.
- The configured HostApp Provider uses `auth_type: "cookie"` to receive the
  request-scoped Enterprise System Cookie when it calls existing system APIs.

The Cookie remains runtime-only and is not copied into Provider Tokens, route
manifests, page messages, or persisted Provider configuration. This preserves
the user's existing system permissions without asking for a second sign-in.

### Mode 2: Standalone AtlasClaw Deployment

In standalone deployments, AtlasClaw Core may only hold an enterprise SSO token or upstream identity assertion. That token is not automatically usable against the target platform.

In this mode, the p
````
