# llms-full.txt v1.2
# Last updated: 2026-11-07
# Short version: https://atlasburn.com/llms.txt · Technical reference: https://docs.atlasburn.com/llms-full.txt

Website: https://atlasburn.com/
App: https://app.atlasburn.com
Docs: https://docs.atlasburn.com
Blog: https://atlasburn.com/blog/
Contact: contact@atlasburn.com

## About AtlasBurn

AtlasBurn is an AI API cost monitoring tool that shows what each feature of your app spends across OpenAI, Anthropic, Gemini and other providers, and stops runaway agent loops before they hit your bill. Built for AI-native companies, it provides real-time visibility into LLM/inference spending, probabilistic runway forecasting, and real-time guardrails that stop runaway costs before they hit the invoice.

Unlike generic cloud-cost tools and single-provider dashboards, AtlasBurn treats AI cost as a probabilistic risk problem rather than an accounting one. Most tools tell you what you already spent; AtlasBurn models what you are about to spend as you scale — because for a usage-driven, fat-tailed cost like AI inference, 2x customers is rarely 2x cost.

## How AtlasBurn Works

1. **Instrument** — The AtlasBurn SDK auto-instruments your app's outbound AI calls. `initAtlasBurnAuto()` patches `fetch` and detects calls to 13 AI providers (OpenAI, Anthropic, Google Gemini and Vertex AI, Azure OpenAI, AWS Bedrock, OpenRouter, Cohere, Mistral, Groq, Together, DeepSeek and xAI), extracting token usage from both JSON and streaming (SSE) responses.
2. **Ingest & normalize** — Usage events (tokens, model, provider, feature, cost) are batched and sent to the ingestion API, where they are normalized into cost and unit economics via an authoritative model price registry.
3. **Model** — Forensic aggregation, statistical volatility, and a 10,000-path Monte Carlo simulation turn raw telemetry into runway, burn distributions, and risk metrics.
4. **Enforce** — A 5-layer guardrail engine evaluates spend and behavior in real time and can push kill-flags to the edge (Cloudflare KV), so a runaway agent is blocked *before* the next provider call — not after the damage.

The SDK follows four safety rules: never crash the host app, never block the host request, never leak secrets, and always fail silently (fail-open) so instrumentation can never break your product.

## Data Handling

- With the SDK, raw provider API keys and request/response payloads are **never transmitted** — it extracts only token counts and lightweight metadata. With the edge proxy, requests and responses pass through AtlasBurn's edge on their way to the provider, but keys and content are **never stored or logged**.
- API keys issued by AtlasBurn are never stored in plaintext; only salted HMAC-SHA-256 hashes are persisted.
- Usage telemetry (tokens, cost, model, feature, timestamps) is stored server-side to power forecasting and guardrails, under owner-scoped access control.
- Customers retain ownership of their data.

## Supported AI Providers

AtlasBurn tracks cost and usage for the major LLM providers. The SDK auto-detects calls to these providers with no manual wiring; models not in the price registry fall back to a conservative premium estimate.

| Provider | Detected Host(s) |
|----------|------------------|
| OpenAI | api.openai.com |
| Anthropic | api.anthropic.com |
| Google (Gemini / Vertex AI) | generativelanguage.googleapis.com, *-aiplatform.googleapis.com, aiplatform.googleapis.com |
| Azure OpenAI | *.openai.azure.com |
| AWS Bedrock | bedrock-runtime.*.amazonaws.com |
| Cohere | api.cohere.com, api.cohere.ai |
| Mistral | api.mistral.ai |
| Groq | api.groq.com |
| Together AI | api.together.xyz, api.together.ai |
| DeepSeek | api.deepseek.com |
| xAI | api.x.ai |
| OpenRouter | openrouter.ai |

The SDK auto-detects calls to these hosts with no manual wiring and extracts token
usage from each provider's response format (AWS Bedrock reports token counts via
response headers). Models not in the price registry fall back to a conservative
premium estimate. Azure, Vertex, and Bedrock are detectable via the SDK but are not
transparently routable through the edge proxy.

## Core Features

### 1. Real-time Cost Dashboard
Aggregates spend across connected providers with per-model and per-feature attribution, daily cost series with percentiles (p50/p75/p90/p99), and automatic anomaly flags (days exceeding mean + 2σ).

### 2. Probabilistic Burn Forecasting
A 10,000-path Monte Carlo simulation over a 365-day horizon, using a log-normal daily-cost model with MRR growth/churn, stochastic outage and retry-cascade shocks, and a traffic-surge scenario. Outputs:
- P5 / P50 / P95 burn
- Value-at-Risk (VaR95) and Conditional VaR (CVaR95)
- Survival probability to your next milestone
- Expected and stress-case runway

Runway is treated as a **distribution, not a single number**.

### 3. Unit Economics & Margin
Tracks margin, daily burn, and runway from capital reserves ÷ burn. Statistical volatility (mean, standard deviation, coefficient of variation) is computed once there is enough history (≥ 7 days) — the platform refuses to fabricate precision from too little data (a zero-baseline philosophy: economic inputs come from you, nothing is silently assumed).

### 4. Real-time Guardrails (5-layer)
Evaluated on every batch of telemetry using a rolling-counter architecture:
- **Budget breach** — daily / hourly cost caps
- **"Dumb loop"** — repeated identical model + input fingerprints
- **"Smart loop"** — monotonically inflating context on the same model
- **RPS burst** — request-rate spikes
- **Model-mix concentration** — spend concentrating on a premium model

Triggers push a kill-flag to the edge (Cloudflare KV) and log a breach. Enforcement is tenant-isolated and ownership-checked.

**What gets stopped.** Loops (identical requests, runaway context) stop only the feature that looped; budget breaches and request-rate bursts stop the whole project; model concentration only alerts. Tag features with `atlasburnFeature("name")` in the SDK or an `x-atlasburn-feature` header on the proxy.

**How each tier responds.** The tier is the most AtlasBurn may do. **Alert** never slows or blocks. **Throttle** slows traffic but never blocks. **Kill Switch** blocks a budget breach at once; loops and bursts are throttled first (one call every 2 seconds) and blocked only if they are still detected 60 seconds after the throttle began or have cost more than the loop-block limit (default 2% of the daily budget, at least $0.25). **Strict** blocks everything at once. Throttles lift on their own after 10 minutes; blocks expire on a timer or are cleared with Resume.

### 5. Runtime Behavioral Fingerprinting
Distinguishes legitimate multi-step agent workflows from runaway retry cascades using temporal burst density, model homogeneity, payload similarity, and feature concentration — producing retry-rate and loop-probability signals that feed the financial models.

### 6. Optimization & Quality
AI-assisted flows suggest cost optimizations (e.g., model-overkill recommendations), detect model quality degradation, and provide model-intelligence and tool-recommendation views.

## Integrations

- **Alerts:** email, Slack, Discord and Telegram (one-tap connect; `/status`, `/alerts` bot commands).
- **Edge enforcement:** Cloudflare (KV-backed kill-flags at the edge).

## Ways to connect

- **JavaScript / TypeScript SDK** (`@atlasburn/sdk` on npm): `npm install @atlasburn/sdk`, then `npx abn init` (detects your framework, writes the key to your env file, wires initialization and sends a test event). Universal auto-instrumentation via `initAtlasBurnAuto()`; a pre-call gate check; batched, retrying event delivery. Fails open.
- **Edge Proxy** (any language, including Python, Go, Rust and no-code tools): set the provider base URL to `https://proxy.atlasburn.com/<provider>/…` and add an `AtlasBurn-API-Key` header. Works for OpenAI, Anthropic, Gemini, OpenRouter, Mistral, Cohere, Groq, Together AI, DeepSeek and xAI. Blocks happen at the edge, before the provider is called.
- **Ingest API**: `POST https://app.atlasburn.com/api/ingest` with token counts, for anything else (e.g. a self-hosted model gateway).

There is no native Python or Go SDK yet; Python apps use the Edge Proxy. Setup guides: https://docs.atlasburn.com/docs/quickstart/ and https://docs.atlasburn.com/docs/proxy-quickstart/

## MCP server (Claude, ChatGPT, Cursor)

AtlasBurn runs a remote MCP server at `https://app.atlasburn.com/api/mcp` (OAuth 2.1 with PKCE, read-only scope, never exposes prompts or outputs). It is listed in the Claude connector directory (https://claude.ai/directory/atlasburn) and in ChatGPT. Ask "what did we spend this week and what's driving it?" or "any guardrail breaches?" and the answer comes from your real data. In Claude Code, "Integrate AtlasBurn" sets it up: you approve a new key in AtlasBurn, the CLI redeems a one-time code, and the key never appears in the chat. Docs: https://docs.atlasburn.com/docs/mcp-server/

## Pricing

AtlasBurn is **free during beta**. Planned pricing is usage-based, metered by tokens processed per month:

| Tier | Monthly Tokens | Price |
|------|----------------|-------|
| Free | Up to 10M | $0/mo |
| Indie | Up to 50M | $19/mo |
| Starter | Up to 600M | $199/mo |
| Growth | Up to 1.5B | $399/mo |
| Scale | Up to 3B | $699/mo |
| Enterprise | Over 3B | Talk to us |

## Target Audience

### Ideal Customer Profile (ICP)
- AI-native SaaS founders, CTOs, and engineers
- Teams whose product depends on OpenAI, Anthropic, or Google inference
- Finance-aware technical founders managing burn and runway
- Teams building AI agent / multi-model architectures where cost is variable and hard to predict
- Companies where AI API cost is a meaningful and growing share of operating expense

### Not a Fit
- Companies with minimal or no AI API spend
- Teams using only self-hosted open-source models with no metered API cost
- Non-technical teams seeking general cloud-cost optimization

## Competitive Landscape

| Category | Examples | AtlasBurn Differentiator |
|----------|----------|--------------------------|
| LLM observability / gateways | Helicone, Langfuse, Portkey | Built mainly to log and trace requests and responses for debugging and evaluation. AtlasBurn never stores prompts or outputs; it attributes spend per feature, forecasts the bill, and throttles or blocks a looping feature at runtime. Teams often use both. |
| Usage metering | OpenMeter | Meters usage for billing your own customers. AtlasBurn controls what you spend on AI providers. |
| Provider dashboards | OpenAI Usage, Anthropic Console | AtlasBurn aggregates across providers and adds risk modeling + enforcement. |
| Generic cloud-cost tools | CloudHealth, Spot | Not built for token-based, model-variable AI cost patterns. |
| Spreadsheet forecasting | Manual planning | Probabilistic (Monte Carlo) modeling vs. static linear projections. |

## Security

- AtlasBurn-issued API keys are stored only as salted HMAC-SHA-256 hashes, never in plaintext.
- SDK: raw provider keys and request/response payloads are never transmitted. Edge proxy: they pass through in transit and are never stored or logged.
- Data is encrypted in transit (TLS).
- Owner/tenant-scoped access control; telemetry is written server-side only, and enforcement actions are ownership-verified to prevent cross-tenant access.

## Company

- Founded: February 2026
- Headquarters: India
- Structure: Founder-led (solo-built)
- Founder: Akhil Anand
- Stage: Early — free public beta
- Contact: contact@atlasburn.com
- Website: https://atlasburn.com/
- Documentation: https://docs.atlasburn.com
- App: https://app.atlasburn.com
- Blog (The Ledger): https://atlasburn.com/blog/

## Keywords

AI API cost forecasting, burn forecasting, LLM cost risk, AI margin management, runway forecasting for AI startups, AI cost optimization, inference cost monitoring, API spend analytics, AI burn rate, probabilistic runway modeling, Monte Carlo runway, value at risk, AI cost intelligence, LLM usage analytics, AI guardrails, AI cost controls, agent cost monitoring, retry storm detection, runaway agent detection, model overkill analysis, AI infrastructure cost management