> ## Documentation Index
> Fetch the complete documentation index at: https://docs.igent.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Billing

Understanding Maestro's billing model and managing costs.

## Billing Model Overview

Maestro uses a **subscription + credit-based system**:

**Monthly subscription**:

* Base platform access
* Included credit allocation
* Feature tier access

**Credits**:

* Consumed by usage (models, sandbox, storage)
* Top-up when needed
* Optional auto-reload

## Plan Tiers

### Basic Plan

**Best for**:

* Individual developers
* Learning Maestro
* Small projects
* Occasional usage

**Includes**:

* Access to core models
* Standard sandbox (2 vCPU, 7 GB RAM)
* File storage (up to limit)
* Community support
* Monthly credit allocation

### Pro Plan

**Best for**:

* Professional developers
* Regular usage
* Medium to large projects
* Team collaboration

**Includes**:

* All Basic features
* Access to advanced models
* Higher sandbox resources
* Increased storage
* Priority support
* Larger monthly credit allocation
* Advanced features (custom sandboxes, etc.)

### Ultimate Plan

**Best for**:

* Power users
* Large-scale projects
* Intensive usage
* Enterprise needs

**Includes**:

* All Pro features
* Access to all models (including newest)
* Maximum sandbox resources
* Unlimited storage (fair use)
* Priority support + SLA
* Largest monthly credit allocation
* All advanced features
* Custom integrations (if needed)

**Visit** [https://igent.ai/](https://igent.ai/) for current pricing and plan details.

## How Credits Work

### Credit Consumption

**Credits are consumed by**:

* Model API calls (varies by model)
* Sandbox compute time
* Storage (beyond included amount)
* Bandwidth (large file operations)

**Consumption rates**:

* Different models have different costs
* Longer responses cost more (more tokens)
* Reasoning-heavy tasks cost more
* Sandbox execution billed per minute
* Storage billed per GB-month

**Real-time tracking**:

* Credit balance visible in UI
* Per-session usage tracking
* Detailed usage breakdown available

### Credit Top-Up

**Manual top-up**:

```
Use /topup command:
1. Shows current balance
2. "Top Up Credits" button
3. Redirects to Stripe checkout
4. Select credit amount
5. Complete purchase
6. Credits added immediately
```

**Top-up amounts** (example):

* 100 credits: \$10
* 500 credits: \$45 (10% bonus)
* 1000 credits: \$80 (20% bonus)

**Bulk discounts**: Larger purchases receive more credits per dollar.

### Auto-Reload

**What it is**:
Automatic credit purchase when balance drops below threshold.

**Configuration**:

```
Settings → Billing → Auto-Reload:
- Enable/disable auto-reload
- Set threshold (e.g., when balance < 50 credits)
- Set auto-reload amount (e.g., add 200 credits)
- Set maximum monthly auto-reload (safety limit)
```

**Advantages**:

* Never interrupted mid-session
* Seamless usage experience
* Predictable costs

**Safety limits**:

* Maximum per reload
* Maximum total monthly
* Email notifications
* Can disable anytime

**Recommendations**:

* Enable for uninterrupted work
* Set conservative limits initially
* Monitor usage patterns
* Adjust based on needs

## Understanding Costs

### Model Costs

**Cost tiers by model**:

* **Basic models**: Lower cost, faster, good for simple tasks
* **Standard models**: Balanced cost/capability
* **Advanced models**: Higher cost, better reasoning, complex tasks
* **Specialized models**: Variable (vision, code-specific, etc.)

**Maestro optimizes**:

* Routes tasks to appropriate models
* Uses cheaper models when sufficient
* Uses expensive models when necessary

**You control** via settings:

* Model selection preferences
* Cost vs capability trade-offs

### Sandbox Costs

**Billed per minute** of active sandbox time:

* Default sandbox: Standard rate
* Custom resource sandboxes: Higher rate (based on CPU/memory/GPU)
* Paused sandboxes: No charge

**Optimization strategies**:

```
Reduce sandbox costs:
- Use sandbox only when needed (don't leave idle)
- Stop long-running servers when done
- Close unused terminal windows
- Pause session when not actively working
```

**Sandbox pricing** (example):

* Default (2 CPU, 7 GB): \$0.02/minute
* High-memory (8 CPU, 32 GB): \$0.08/minute
* GPU (A100): \$0.50/minute

### Storage Costs

**Included storage** per plan:

* Basic: 10 GB
* Pro: 50 GB
* Ultimate: Unlimited (fair use)

**Overage charges**:

* \$0.10 per GB-month beyond included amount

**What counts**:

* Session checkpoints
* File iterations
* Element storage (images, uploads)

**Optimization**:

```
Reduce storage costs:
- Delete old sessions
- Use /refresh to reduce iterations
- Avoid storing large binaries
- Download and delete old projects
```

## Cost Optimization

### Session-Level Optimization

**Capacity management reduces costs**:

```
Smaller token counts per turn:
- Lower model API costs
- Faster responses
- Better quality

Techniques:
- /refresh regularly
- /compact for long sessions
- /forget unnecessary turns
- Activate only needed files
```

**Efficient tool use**:

```
Use lighter tools when appropriate:
- Google Search (fast) vs Perplexity Search (deep)
- Simple Execute Command vs Complex Coding
- View Files vs analyzing entire codebase

Match tool to task complexity
```

### Project-Level Optimization

**Organized approach saves credits**:

```
Inefficient:
- Exploratory wandering
- Repeated false starts
- Insufficient planning
- Late validation (costly rework)

Efficient:
- Clear requirements upfront
- Systematic planning
- Incremental validation
- Early error detection
```

**Example cost comparison**:

```
Unplanned approach:
- 50 turns of exploration
- 30 turns of implementation
- 20 turns of debugging and rework
Total: 100 turns, high model usage

Planned approach:
- 10 turns of requirements and research
- 5 turns of design
- 25 turns of implementation
- 10 turns of validation
Total: 50 turns, focused model usage

Savings: 50% fewer turns, much lower cost
```

### Tool Selection for Cost Efficiency

**Research tasks**:

```
Quick lookup: Google Search (cheap, fast)
Deep research: Perplexity Search (moderate cost)
Specific URL: Visit URL (cheap)

Choose based on information need
```

**Code generation**:

```
Simple tasks: Standard models (cheap)
Complex features: Advanced models (expensive but worth it)
Optimization: Use Complex Coding only when truly needed
```

**Validation**:

```
Unit tests: Fast execution, cheap
Integration tests: Moderate
Performance benchmarks: Can be expensive (sandbox time)

Run all, but be aware of costs
```

## Billing Management

### Monitoring Usage

**Real-time tracking**:

* Current credit balance (always visible)
* Per-session usage
* Detailed breakdown available

**Usage analytics**:

* Credits consumed per day/week/month
* Cost by category (models, sandbox, storage)
* Trend analysis
* Projected monthly cost

**Access**: Settings → Billing → Usage Statistics

### Billing Statements

**Monthly statements include**:

* Subscription fee
* Credit purchases
* Usage breakdown
* Remaining balance
* Next billing date

**Download**: PDF invoices for accounting

### Payment Methods

**Supported**:

* Credit card (Visa, Mastercard, Amex, Discover)
* Debit card
* ACH (some plans)
* Wire transfer (enterprise)

**Updates**: Manage payment methods in Settings → Billing

**Auto-reload**: Uses default payment method.

### Customer Portal

**Access**: Settings → Billing → Customer Portal

**Manage**:

* View current plan
* Upgrade/downgrade plan
* Update payment methods
* View invoices
* Cancel subscription
* Manage auto-reload

**Powered by Stripe**: Secure, industry-standard billing.

## Managing Your Subscription

### Upgrading Plans

**When to upgrade**:

* Need higher resource limits
* Want access to advanced models
* Require better support
* Need enterprise features

**Process**:

* Settings → Billing → Upgrade Plan
* Select new tier
* Pro-rated charge
* Immediate access to new features

**Credits**: Keep existing balance, get new allocation.

### Downgrading Plans

**Restrictions after downgrade**:

* May lose access to some models
* Resource limits reduced
* Feature access restricted

**Credits**: Keep balance, new allocation on next billing

**Recommendation**: Download important sessions before downgrading.

### Cancellation

**Process**:

* Settings → Billing → Cancel Subscription
* Confirm cancellation
* Access until end of billing period
* Credits valid until expiration

**Data retention**:

* Sessions preserved per retention policy (30-90 days typically)
* Download before cancellation to ensure preservation
* Can request immediate data deletion

**Reactivation**:

* Can reactivate anytime
* New credit allocation
* Preserved data may still be available

## Enterprise Billing

### Custom Plans

For organizations with special needs:

**Features**:

* Custom credit allocations
* Dedicated resources
* SLA guarantees
* Priority support
* Custom integrations
* Team management
* Usage analytics
* Consolidated billing

**Contact**: [sales@igent.ai](mailto:sales@igent.ai) for enterprise pricing

### Team Billing

**Multi-user accounts**:

* Shared credit pool
* Individual usage tracking
* Centralized billing
* Admin controls

**Administration**:

* Add/remove team members
* Set usage limits per user
* Monitor team usage
* Allocate budgets

### Invoicing and Payment

**Enterprise payment options**:

* Net-30 terms (approved customers)
* Purchase orders
* Wire transfer
* Annual prepayment discounts

## Cost FAQs

### Why does Maestro charge for API calls?

**Transparency**: We pass through model provider costs (OpenAI, Anthropic, etc.) with no markup.

**Benefit**: You don't need separate accounts with each provider. Maestro handles orchestration, you pay actual costs.

**Platform fee**: Covers Maestro infrastructure (sandboxes, storage, orchestration).

### Can I estimate costs before starting?

**Rough estimates**:

* Simple session (10 turns): 10-50 credits
* Medium session (30 turns with testing): 50-200 credits
* Complex session (100+ turns with heavy sandbox): 200-1000 credits

**Variables**:

* Model choices
* Testing thoroughness
* Research depth
* Sandbox usage

**Best practice**: Monitor first few sessions to understand your patterns, then estimate accordingly.

### What if I go over my credit allocation?

**Soft limit**: Low balance warnings appear

**Out of credits**:

* Session paused
* Can add credits via `/topup`
* Or enable auto-reload
* Session resumes after credits added

**No surprise charges**: Never charged without authorization (unless auto-reload enabled, which you control).

### How do I reduce costs?

**Session efficiency**:

* Clear requirements (fewer iterations)
* Proactive validation (catch errors early)
* Capacity management (reduce token usage)

**Tool selection**:

* Use appropriate tools for task
* Avoid complex tools for simple tasks
* Minimize unnecessary web research

**Sandbox optimization**:

* Stop processes when done
* Use `/reset-sandbox` judiciously
* Close unused terminal windows
* Pause sessions when not working

**Storage management**:

* Delete old sessions
* /refresh to reduce iteration storage
* Download and delete completed projects

### Are there hidden fees?

**No hidden fees**:

* Model costs: Passed through at actual cost
* Sandbox usage: Per published rates
* Storage: Per published rates
* No surprise charges
* No markup on model costs

**Transparency**: All costs disclosed upfront.

## Billing Support

### Questions about billing?

**Self-service**:

* Settings → Billing → FAQ
* Usage analytics and breakdowns
* Invoice history

**Support contact**:

* Email: [billing@igent.ai](mailto:billing@igent.ai)
* Response time: 24-48 hours (business days)
* Priority support for Pro/Ultimate plans

**Common issues**:

* Payment failed → Update payment method
* Unexpected charges → Review usage analytics
* Billing questions → Contact billing support

### Disputes

**Process**:

1. Email [billing@igent.ai](mailto:billing@igent.ai) with:
   * Account email
   * Invoice/charge in question
   * Detailed explanation
2. Support reviews within 3-5 business days
3. Resolution provided
4. Refund if error confirmed

**Common dispute reasons**:

* Duplicate charges (rare, system issue)
* Unexpected auto-reload (verify settings)
* Usage discrepancy (review analytics together)

## Next Steps

Billing understood:

* **[Models](reference/models)**: Understand AI models and costs
* **[Glossary](reference/glossary)**: Technical terms explained