Docs
Core Concepts
Credit System

Credit System

AgenticAnts uses a flexible, usage-based credit system that scales with your needs.

What are Credits?

Credits are AgenticAnts' unit of measurement for platform usage. Think of credits like cloud compute units - they represent the resources consumed by your AI operations.

Why Credits?

  • Flexibility: Use credits across all platform features
  • Predictability: Know costs before you commit
  • Scalability: Pay for what you use
  • Simplicity: One unit for all operations

How Credits Work

Credit Allocation

Credits are included with your plan and can be purchased additionally:

Pro Plan: $49/month
├─ 100,000 credits included
├─ Additional credits: $5 per 1,000
└─ No expiration within billing cycle

Enterprise Plan: Custom pricing
├─ Custom credit allocation
├─ Volume discounts available
└─ Dedicated support included

Credit Consumption

Different operations consume different amounts of credits:

OperationCredits per UnitExample
Trace Ingestion1 per 1,000 traces5,000 traces = 5 credits
Span Ingestion0.1 per 1,000 spans10,000 spans = 1 credit
Metric Data Points0.05 per 1,000 points20,000 points = 1 credit
Data Storage5 per GB/month10 GB = 50 credits/month
API Requests0.5 per 1,000 requests2,000 requests = 1 credit
Evaluation Runs2 per 1,000 evaluations500 evaluations = 1 credit

Actual Usage: Your credit consumption depends on your actual usage patterns. Most teams use 5,000-15,000 credits per month.

Usage Examples

Example 1: Small Team

Profile: 5 developers, 3 AI agents, development and staging

Monthly Usage:
├─ Traces: 50,000 (50 credits)
├─ Spans: 200,000 (20 credits)
├─ Metrics: 100,000 (5 credits)
├─ Storage: 2 GB (10 credits)
└─ API calls: 10,000 (5 credits)

Total: 90 credits/month
Cost: $49/month (Pro plan with 100,000 credits)

Example 2: Growing Startup

Profile: 20 developers, 10 AI agents, production workload

Monthly Usage:
├─ Traces: 500,000 (500 credits)
├─ Spans: 2,000,000 (200 credits)
├─ Metrics: 1,000,000 (50 credits)
├─ Storage: 20 GB (100 credits)
└─ API calls: 100,000 (50 credits)

Total: 900 credits/month
Cost: $49 (Pro) + $0 (under 100,000 credits)

Example 3: Enterprise

Profile: 100+ developers, 50+ agents, high-volume production

Monthly Usage:
├─ Traces: 10,000,000 (10,000 credits)
├─ Spans: 50,000,000 (5,000 credits)
├─ Metrics: 20,000,000 (1,000 credits)
├─ Storage: 500 GB (2,500 credits)
└─ API calls: 5,000,000 (2,500 credits)

Total: 21,000 credits/month
Cost: Custom Enterprise pricing

Monitoring Credit Usage

Real-Time Dashboard

View your credit consumption in real-time:

// Get current usage
const usage = await ants.credits.getCurrentUsage()
 
console.log(`Credits used: ${usage.used}`)
console.log(`Credits remaining: ${usage.remaining}`)
console.log(`Reset date: ${usage.resetDate}`)
console.log(`Usage by category:`)
console.log(`  Traces: ${usage.breakdown.traces} credits`)
console.log(`  Metrics: ${usage.breakdown.metrics} credits`)
console.log(`  Storage: ${usage.breakdown.storage} credits`)

Usage Alerts

Set up alerts for credit consumption:

# Alert when 70% of credits are consumed
ants.credits.create_alert({
    'threshold': 0.7,
    'type': 'warning',
    'channels': ['email', 'slack']
})
 
# Alert when 90% of credits are consumed
ants.credits.create_alert({
    'threshold': 0.9,
    'type': 'critical',
    'channels': ['email', 'slack', 'pagerduty']
})

Usage Analytics

Analyze credit consumption patterns:

// Get usage trends
const trends = await ants.credits.getTrends({
  period: 'last_30_days',
  groupBy: 'day'
})
 
// Identify top consumers
const topConsumers = await ants.credits.getTopConsumers({
  period: 'last_7_days',
  limit: 10
})
 
// Project future usage
const projection = await ants.credits.projectUsage({
  basedOn: 'last_30_days',
  projectFor: '90_days'
})

Credit Optimization

Tips to Reduce Credit Usage

1. Sampling

Don't trace everything - use intelligent sampling:

const ants = new AgenticAnts({
  apiKey: process.env.AGENTICANTS_API_KEY,
  sampling: {
    rate: 0.1,  // Sample 10% of traces
    strategy: 'head-based',  // Decide at trace start
    rules: [
      // Always sample errors
      { condition: 'error', rate: 1.0 },
      // Always sample slow requests
      { condition: 'duration > 5s', rate: 1.0 },
      // Sample 50% of specific users
      { condition: 'user = "test_user"', rate: 0.5 }
    ]
  }
})

2. Data Retention

Configure appropriate retention periods:

# Set retention policies
ants.config.set_retention({
    'traces': '30_days',      # Keep traces for 30 days
    'metrics': '90_days',     # Keep metrics for 90 days
    'logs': '7_days',         # Keep logs for 7 days
    'raw_data': '24_hours'    # Keep raw data for 24 hours
})

3. Batch Processing

Batch operations to reduce API calls:

// Instead of individual calls
for (const trace of traces) {
  await ants.trace.create(trace)  // 1 API call per trace
}
 
// Batch them
await ants.trace.createBatch(traces)  // 1 API call for all

4. Compression

Enable compression for data transfer:

ants = AgenticAnts(
    api_key=os.getenv('AGENTICANTS_API_KEY'),
    compression='gzip',  # Enable compression
    batch_size=100       # Batch traces
)

5. Selective Instrumentation

Only instrument what matters:

// Don't trace everything
if (shouldTrace(request)) {
  const trace = await ants.trace.create({ /* ... */ })
}
 
function shouldTrace(request) {
  // Skip health checks
  if (request.path === '/health') return false
  
  // Skip internal requests
  if (request.internal) return false
  
  // Trace production traffic
  if (request.env === 'production') return true
  
  // Sample development traffic
  return Math.random() < 0.1
}

Purchasing Credits

Additional Credits

Need more credits? Purchase them as needed:

# Via Dashboard
1. Go to Settings → Billing
2. Click "Purchase Credits"
3. Select quantity (1,000 to 1,000,000 credits)
4. Complete payment

Volume Discounts

Bulk purchases receive discounts:

CreditsPrice per 1,000Discount
1,000 - 9,999$5.000%
10,000 - 49,999$4.5010%
50,000 - 99,999$4.0020%
100,000+$3.5030%

Enterprise Agreements

Custom credit packages for enterprise needs:

Enterprise Benefits:
├─ Custom credit allocation
├─ Flexible payment terms
├─ Volume discounts
├─ Dedicated support
├─ SLA guarantees
└─ Custom retention policies

Credit Rollover

Monthly Plans

  • Credits reset at the start of each billing cycle
  • Unused credits do not roll over (Scale plan)
  • Purchase additional credits anytime

Enterprise Plans

  • Flexible rollover policies
  • Annual credit pools
  • Custom terms available

Fair Use Policy

AgenticAnts credits are subject to fair use:

Normal Use

  • Monitoring production AI agents
  • Development and testing
  • Reasonable API usage
  • Standard data retention

Not Allowed

  • Reselling credits
  • Mining or scraping data
  • Excessive API hammering
  • Storing non-agent data
⚠️

Fair Use: Unusual usage patterns may be flagged for review. Contact support if you have questions about your use case.

Credit FAQs

Do credits expire?

Monthly plan credits reset each billing cycle. Enterprise plans can have custom terms.

Can I transfer credits?

No, credits are non-transferable between accounts.

What happens if I run out?

Your data collection pauses until credits are added or the billing cycle resets. Historical data remains accessible.

Can I get a refund?

Monthly subscription fees are non-refundable. Unused purchased credits can be refunded within 30 days.

How do I estimate my needs?

Start with the Scale plan and monitor your usage for a month. We'll help you optimize or upgrade as needed.

Monitoring Best Practices

Set Budgets

await ants.budgets.create({
  name: 'Monthly Credit Budget',
  credits: 10000,
  period: 'monthly',
  alerts: [
    { at: 7000, notify: 'slack' },   // 70%
    { at: 9000, notify: 'email' }    // 90%
  ]
})

Review Weekly

Check your credit usage every week:

# Weekly usage report
report = ants.credits.get_weekly_report()
print(f"This week: {report.current_week} credits")
print(f"Last week: {report.last_week} credits")
print(f"Change: {report.change_percent}%")

Optimize Continuously

// Get optimization recommendations
const recommendations = await ants.credits.getOptimizations()
 
for (const rec of recommendations) {
  console.log(`${rec.title}: Save ${rec.potentialSavings} credits/month`)
  console.log(`Action: ${rec.action}`)
}

Next Steps

Three PillarsObservability Model