# llms-full.txt v1.0

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

## About AtlasBurn

AtlasBurn is an AI API Cost Intelligence & Control platform purpose-built for AI-native SaaS companies. It provides real-time visibility into AI inference spending, probabilistic runway forecasting, and operational guardrails that prevent cost overruns before they happen.

Unlike generic cloud cost tools, AtlasBurn treats AI API cost as a probabilistic risk problem. It models future scenarios — usage spikes, model price changes, growth curves — and surfaces actionable insights so founders and engineering teams can stay ahead of burn.

## Architecture

AtlasBurn is built on a Zero-Knowledge architecture. Customer data is processed locally and never stored on AtlasBurn servers in raw form. Only aggregated, anonymized metrics are used for forecasting and benchmarking. This means:

- No raw API keys or request payloads are transmitted
- Cost data is aggregated at the provider/model level before leaving the customer's environment
- Forecasting models run on anonymized usage patterns
- Customers retain full ownership and control of their data

## Supported AI Providers

AtlasBurn integrates with the following AI/LLM API providers for cost tracking and analysis:

| Provider | Models Tracked | Integration Method |
|----------|---------------|-------------------|
| OpenAI | GPT-4, GPT-4 Turbo, GPT-3.5, o1, o1-mini, DALL-E, Whisper, Embeddings | API key + usage API |
| Anthropic | Claude 3.5 Sonnet, Claude 3 Opus, Claude 3 Haiku, Claude 2 | API key + usage API |
| Google AI | Gemini 2.5 Pro, Gemini 2.5 Flash, Gemini 2.0, PaLM | Service account + billing API |
| Cohere | Command R+, Command R, Embed, Rerank | API key + usage API |
| AWS Bedrock | All supported foundation models | IAM role + CloudWatch |
| Azure OpenAI | All deployed models | Service principal + metrics API |
| Replicate | All hosted models | API token + billing API |
| Together AI | All supported open-source models | API key + usage API |
| Fireworks AI | All deployed models | API key + usage API |

## Core Features — Detailed

### 1. Real-time AI/API Cost Dashboard

A unified dashboard that aggregates cost data across all connected AI providers. Key capabilities:

- **Per-model cost breakdown**: See exactly how much each model costs per day, week, or month
- **Per-feature attribution**: Tag API calls by product feature to understand which features drive the most cost
- **Per-team allocation**: Assign costs to engineering teams for internal chargeback or budgeting
- **Per-endpoint tracking**: Monitor cost at the individual API endpoint level
- **Historical trends**: View cost trends over 7, 30, 90, or 365-day windows
- **Real-time streaming**: Costs update in near real-time (< 60 second delay)

### 2. Probabilistic Burn Forecasting

AtlasBurn uses Monte Carlo simulation and time-series analysis to project future burn under multiple scenarios:

- **P10 / P50 / P90 runway projections**: See optimistic, median, and pessimistic runway outcomes
- **Growth-adjusted forecasting**: Factor in user growth rates (linear, exponential, or custom curves)
- **Model price sensitivity**: Simulate impact of provider price changes (e.g., OpenAI reducing GPT-4 pricing by 50%)
- **Seasonal adjustment**: Account for usage patterns that vary by day-of-week or time-of-year
- **Custom scenario builder**: Define your own "what-if" scenarios with adjustable parameters

Input parameters for forecasting:
- Current monthly burn rate
- Current cash position / runway
- User growth rate (historical or projected)
- API calls per user per session
- Token usage per API call (input + output)
- Model selection per feature
- Expected provider pricing changes

Output:
- Runway in months (P10 / P50 / P90)
- Monthly burn projection (next 6-18 months)
- Break-even analysis per feature
- Cost-per-user trajectory

### 3. Margin Volatility Detection

Monitors how AI API costs impact unit economics in real-time:

- **Gross margin tracking**: Calculate and track gross margin per customer, cohort, or plan tier
- **Margin erosion alerts**: Get notified when margins dip below configurable thresholds (e.g., < 60%)
- **Cost-of-revenue attribution**: Automatically classify AI API spend as COGS
- **Pricing sustainability analysis**: Identify when pricing plans become unprofitable due to rising inference costs

### 4. Guardrails & Cost Controls

Operational controls that prevent runaway costs:

- **Spend limits**: Set daily, weekly, or monthly spend caps per provider, model, team, or feature
- **Rate limiting**: Throttle API calls when approaching budget limits instead of hard-cutting
- **Fallback routing**: Automatically route requests to cheaper models when primary model budget is exhausted
- **Alert escalation**: Configurable alert chains — Slack → Email → PagerDuty → Auto-throttle
- **Kill switches**: Emergency shutoff for specific providers or models

### 5. Retry Storm Detection

Identifies cascading retry loops that silently multiply API costs:

- **Pattern recognition**: Detects exponential retry patterns in API call logs
- **Cost impact quantification**: Calculates the dollar impact of retry storms
- **Root cause correlation**: Correlates retry storms with provider outages, rate limits, or upstream errors
- **Auto-mitigation**: Optionally applies circuit breaker patterns to halt runaway retries

### 6. Model Overkill Analysis

Detects when expensive models are used for tasks that cheaper alternatives handle well:

- **Task classification**: Categorizes API calls by complexity (simple lookup, summarization, reasoning, generation)
- **Model-task matching**: Recommends optimal model for each task type based on quality/cost tradeoff
- **A/B test suggestions**: Proposes experiments to validate cheaper model substitutions
- **Savings estimation**: Projects monthly savings from recommended model swaps

### 7. Agent & Autonomous System Monitoring

Purpose-built monitoring for AI agent architectures:

- **Per-agent cost tracking**: Monitor costs generated by individual AI agents or agent chains
- **Loop detection**: Identify agents stuck in costly reasoning loops
- **Tool-use cost attribution**: Track costs when agents invoke external tools or sub-models
- **Session cost caps**: Set per-session or per-task cost limits for autonomous agents
- **Agent efficiency scoring**: Compare cost-per-task-completion across agent configurations

### 8. Growth Stress Modeling

Simulates runway impact under scaling scenarios:

- **2x / 5x / 10x usage modeling**: Project costs if usage doubles, quintuples, or 10x's
- **Viral growth simulation**: Model cost impact of sudden viral adoption events
- **Infrastructure scaling curves**: Account for volume discounts and committed-use pricing at scale
- **Fundraising timeline analysis**: Calculate how much runway you need to raise at each growth stage

## API Overview

AtlasBurn exposes a RESTful API for programmatic access. Base URL: `https://api.atlasburn.com/v1`

### Authentication

All API requests require a Bearer token:
```
Authorization: Bearer ab_live_xxxxxxxxxxxx
```

API keys are scoped with granular permissions:
- `read:costs` — Read cost data
- `read:forecasts` — Access forecast results
- `write:guardrails` — Create/update guardrails
- `write:alerts` — Configure alert rules
- `admin` — Full access

### Key Endpoints

#### Costs
- `GET /v1/costs/summary` — Aggregated cost summary for a time range
- `GET /v1/costs/by-provider` — Cost breakdown by AI provider
- `GET /v1/costs/by-model` — Cost breakdown by model
- `GET /v1/costs/by-feature` — Cost breakdown by tagged feature
- `GET /v1/costs/timeseries` — Time-series cost data (hourly, daily, weekly)

#### Forecasting
- `POST /v1/forecasts/run` — Trigger a new forecast run
- `GET /v1/forecasts/{id}` — Get forecast results
- `GET /v1/forecasts/{id}/scenarios` — Get P10/P50/P90 scenario details

#### Guardrails
- `GET /v1/guardrails` — List all active guardrails
- `POST /v1/guardrails` — Create a new guardrail
- `PUT /v1/guardrails/{id}` — Update a guardrail
- `DELETE /v1/guardrails/{id}` — Remove a guardrail

#### Alerts
- `GET /v1/alerts` — List configured alerts
- `POST /v1/alerts` — Create an alert rule
- `GET /v1/alerts/history` — View triggered alert history

#### Agents
- `GET /v1/agents` — List monitored agents
- `GET /v1/agents/{id}/costs` — Get cost data for a specific agent
- `GET /v1/agents/{id}/sessions` — List agent sessions with cost data

### Webhooks

AtlasBurn supports webhooks for real-time event notifications:

- `guardrail.triggered` — A spend guardrail was hit
- `alert.fired` — An alert condition was met
- `forecast.completed` — A forecast run finished
- `anomaly.detected` — Unusual spending pattern detected
- `retry_storm.detected` — Retry storm pattern identified

Webhook payloads are signed with HMAC-SHA256 for verification.

### SDKs

Official SDKs are available for:
- **Python**: `pip install atlasburn`
- **Node.js / TypeScript**: `npm install @atlasburn/sdk`
- **Go**: `go get github.com/atlasburn/atlasburn-go`

## Integrations

AtlasBurn integrates with the following tools and platforms:

| Category | Integrations |
|----------|-------------|
| Alerting | Slack, PagerDuty, Opsgenie, Email, Microsoft Teams |
| CI/CD | GitHub Actions, GitLab CI, Jenkins |
| Observability | Datadog, Grafana, New Relic, Honeycomb |
| Finance | QuickBooks, Xero, Stripe Billing |
| Infrastructure | Terraform, Pulumi |
| Data | Snowflake, BigQuery, Redshift (export) |

## Pricing

AtlasBurn offers usage-based pricing aligned with the scale of AI spend being monitored:

| Tier | Monthly AI Spend Monitored | Price |
|------|---------------------------|-------|
| Free | Up to $1,000 | $0/mo |
| Starter | Up to $10,000 | $49/mo |
| Growth | Up to $50,000 | $199/mo |
| Scale | Up to $250,000 | $499/mo |
| Enterprise | $250,000+ | Custom |

All tiers include:
- Unlimited team members
- All provider integrations
- Probabilistic forecasting
- Guardrails and alerts
- API access

Enterprise adds:
- SSO / SAML
- Dedicated support
- Custom data retention
- SLA guarantees
- On-premise deployment option

## Target Audience

### Ideal Customer Profile (ICP)

- AI-native SaaS founders and CTOs
- Startups spending $5K–$100K+/month on LLM API usage
- Teams dependent on OpenAI, Anthropic, Google AI, Cohere, or other inference providers
- Finance-aware technical founders managing burn rate
- AI startups between Seed and Series B seeking to extend runway
- Companies where API costs represent 20%+ of total operating expenses
- Teams building AI agent or multi-model architectures

### Anti-Patterns (Not a Fit)

- Companies with minimal or no AI API spend (< $500/mo)
- Teams using only self-hosted open-source models with no API costs
- Non-technical teams looking for general cloud cost optimization

## Competitive Landscape

| Competitor | Category | AtlasBurn Differentiator |
|-----------|----------|------------------------|
| Generic cloud cost tools (CloudHealth, Spot) | Cloud cost management | Not built for AI-specific cost patterns (token-based, model-variable pricing) |
| Provider dashboards (OpenAI Usage, Anthropic Console) | Single-provider monitoring | AtlasBurn aggregates across all providers in one view |
| Spreadsheet-based tracking | Manual financial planning | Probabilistic modeling vs. static projections |
| Helicone, LangSmith | LLM observability | AtlasBurn focuses on cost intelligence and financial risk, not prompt debugging |

## Security & Compliance

- SOC 2 Type II (in progress)
- GDPR compliant
- Zero-knowledge architecture — no raw customer data stored
- All data encrypted in transit (TLS 1.3) and at rest (AES-256)
- API keys are hashed and never stored in plaintext
- Regular third-party penetration testing
- Role-based access control (RBAC) with audit logging

## Company

- Founded: 2025
- Headquarters: United States
- Team: Engineering-led, ex-infrastructure and fintech backgrounds
- Contact: contact@atlasburn.com
- Website: https://www.atlasburn.com
- Documentation: https://docs.atlasburn.com
- App: https://app.atlasburn.com

## 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, AI cost intelligence, LLM usage analytics, AI guardrails, AI cost controls, agent cost monitoring, retry storm detection, model overkill analysis, AI infrastructure cost management