AI Agents API

Deploy autonomous AI agents that can transact, negotiate, and manage commerce operations on StateSet

Early Access: The AI Agents API is in early access. Request access at [e-mail]

AI Agents API: Autonomous Commerce Infrastructure

🤖 Overview

StateSet’s AI Agents API enables you to deploy autonomous agents that can execute transactions, manage inventory, negotiate deals, and handle complex commerce operations 24/7. Built with native stablecoin integration and advanced safety controls.

Autonomous Execution

Agents operate independently within defined parameters

Built-in Safety

Multi-level controls prevent runaway spending

Real-time Learning

Agents improve performance through ML optimization

🚀 Quick Start

1. Deploy Your First Agent

   import { StateSet } from '@stateset/sdk';
   
   const stateset = new StateSet({ apiKey: 'sk_test_...' });
   
   // Deploy a procurement agent
   const agent = await stateset.agents.create({
     name: 'ProcurementBot-01',
     type: 'procurement',
     capabilities: ['negotiate', 'purchase', 'track'],
     limits: {
       daily_spend: '10000.00',
       per_transaction: '1000.00',
       requires_approval_above: '5000.00'
     }
   });
   
   console.log(`Agent deployed: ${agent.id}`);
   

2. Set Agent Parameters

   // Configure agent behavior
   await stateset.agents.configure(agent.id, {
     procurement_rules: {
       preferred_suppliers: ['supplier_123', 'supplier_456'],
       max_price_variance: 0.05, // 5% above market
       delivery_requirements: '3_days',
       quality_threshold: 0.95
     },
     negotiation_strategy: 'balanced', // aggressive, balanced, conservative
     learning_enabled: true
   });
   

3. Monitor Agent Activity

   // Real-time agent monitoring
   const activity = await stateset.agents.activity(agent.id, {
     timeframe: '24h'
   });
   
   console.log(`Transactions: ${activity.transaction_count}`);
   console.log(`Total spent: ${activity.total_spent}`);
   console.log(`Savings achieved: ${activity.savings}`);
   

📊 Agent Types

Procurement Agents

Automated Purchasing & Negotiation

Procurement agents handle supplier relationships, negotiate prices, and execute purchases based on inventory levels and demand forecasts.

const procurementAgent = await stateset.agents.create({
  type: 'procurement',
  name: 'SupplyChainOptimizer',
  capabilities: [
    'supplier_discovery',
    'price_negotiation',
    'order_placement',
    'delivery_tracking'
  ],
  config: {
    inventory_triggers: {
      reorder_point: 100,
      optimal_quantity: 500,
      safety_stock: 50
    },
    supplier_preferences: {
      min_rating: 4.5,
      max_delivery_days: 5,
      payment_terms: ['NET_30', 'NET_60']
    }
  }
});

Key Features:

• Automatic reordering based on inventory levels
• Multi-supplier price comparison
• Dynamic negotiation based on order volume
• Quality and delivery performance tracking

🔐 Safety & Controls

Multi-Level Security Framework

Spending Limits

// Configure comprehensive spending controls
await stateset.agents.setLimits(agent.id, {
  absolute_limits: {
    daily: '10000.00',
    weekly: '50000.00',
    monthly: '150000.00',
    per_transaction: '5000.00'
  },
  
  velocity_controls: {
    max_transactions_per_hour: 10,
    max_transactions_per_day: 50,
    cooldown_after_limit: '1_hour'
  },
  
  approval_thresholds: {
    auto_approve_below: '1000.00',
    human_approval_above: '5000.00',
    board_approval_above: '50000.00'
  }
});

Behavioral Boundaries

// Define operational constraints
await stateset.agents.setBehaviors(agent.id, {
  allowed_actions: [
    'purchase_from_approved_suppliers',
    'negotiate_within_parameters',
    'execute_recurring_orders'
  ],
  
  prohibited_actions: [
    'create_new_contracts',
    'modify_payment_terms',
    'access_sensitive_data'
  ],
  
  ethical_constraints: {
    sustainability_required: true,
    fair_trade_only: true,
    no_conflict_minerals: true
  }
});

Emergency Controls

// Emergency stop mechanisms

// Immediate halt
await stateset.agents.emergencyStop(agent.id);

// Gradual shutdown
await stateset.agents.gracefulShutdown(agent.id, {
  complete_pending: true,
  notify_counterparties: true,
  transfer_to_human: 'ops_team'
});

// Circuit breaker configuration
await stateset.agents.setCircuitBreaker(agent.id, {
  error_threshold: 5,
  error_window: '10_minutes',
  recovery_timeout: '1_hour',
  half_open_requests: 3
});

📡 Agent Communication

Inter-Agent Protocols

// Enable agent-to-agent negotiation
const negotiation = await stateset.agents.negotiate({
  buyer_agent: 'agent_buyer_123',
  seller_agent: 'agent_seller_456',
  item: {
    sku: 'WIDGET-001',
    quantity: 1000,
    target_price: '10.00'
  },
  parameters: {
    max_rounds: 10,
    timeout: '5_minutes',
    binding_agreement: true
  }
});

// Monitor negotiation progress
negotiation.on('round_complete', (round) => {
  console.log(`Round ${round.number}: Buyer ${round.buyer_offer}, Seller ${round.seller_offer}`);
});

negotiation.on('agreement_reached', (deal) => {
  console.log(`Deal closed at ${deal.price} for ${deal.quantity} units`);
});

Human-Agent Collaboration

// Set up human oversight
await stateset.agents.setOversight(agent.id, {
  notification_channels: {
    email: ['[e-mail]'],
    slack: '#agent-alerts',
    sms: ['[phone]']
  },
  
  escalation_triggers: [
    'unusual_price_variance',
    'new_supplier_request',
    'large_order_placement',
    'repeated_failures'
  ],
  
  human_intervention_points: {
    pre_execution: ['orders_above_5000'],
    post_execution: ['all_transactions'],
    on_error: ['payment_failures', 'delivery_issues']
  }
});

📊 Analytics & Performance

Real-Time Metrics

// Get comprehensive agent analytics
const analytics = await stateset.agents.analytics(agent.id, {
  period: '30_days',
  metrics: [
    'transaction_volume',
    'success_rate',
    'average_savings',
    'response_time',
    'learning_progress'
  ]
});

// Response
{
  "agent_id": "agent_123",
  "period": "30_days",
  "performance": {
    "transactions": 1543,
    "success_rate": 0.97,
    "total_volume": "543,234.56",
    "average_transaction": "352.15",
    "savings_achieved": "32,445.23",
    "savings_percentage": 0.06
  },
  "behavioral_insights": {
    "preferred_suppliers": ["supp_123", "supp_456"],
    "peak_activity_hours": [9, 10, 14, 15],
    "negotiation_success_rate": 0.78,
    "average_negotiation_rounds": 3.4
  },
  "learning_metrics": {
    "model_accuracy": 0.92,
    "prediction_confidence": 0.88,
    "adaptation_rate": 0.15,
    "knowledge_base_size": 15420
  }
}

Custom Reporting

// Create custom agent reports
const report = await stateset.agents.generateReport({
  agent_ids: ['agent_123', 'agent_456'],
  report_type: 'comparative_analysis',
  metrics: {
    financial: ['total_spend', 'roi', 'cost_savings'],
    operational: ['response_time', 'accuracy', 'throughput'],
    strategic: ['supplier_diversity', 'innovation_score']
  },
  format: 'pdf',
  schedule: 'weekly'
});

🧪 Testing & Simulation

Sandbox Environment

// Test agent behavior in sandbox
const simulation = await stateset.agents.simulate({
  agent_id: agent.id,
  scenario: 'market_volatility',
  parameters: {
    price_fluctuation: 0.20,
    supply_disruption: 0.10,
    demand_spike: 1.50
  },
  duration: '7_days'
});

// Monitor simulation results
simulation.on('day_complete', (day) => {
  console.log(`Day ${day.number}: Performance ${day.performance_score}`);
});

🚨 Error Handling

try {
  const result = await agent.execute(transaction);
} catch (error) {
  switch(error.code) {
    case 'LIMIT_EXCEEDED':
      // Handle spending limit
      await notifyFinanceTeam(error);
      break;
    
    case 'UNAUTHORIZED_ACTION':
      // Handle permission violation
      await logSecurityEvent(error);
      break;
    
    case 'LEARNING_FAILURE':
      // Handle ML model issues
      await fallbackToRules(transaction);
      break;
    
    default:
      // Generic error handling
      await agent.reportError(error);
  }
}

🔗 Integrations

ERP Systems

Direct integration with SAP, Oracle, Microsoft Dynamics

ML Platforms

TensorFlow, PyTorch, and Hugging Face model support

Communication

Slack, Teams, Email, and SMS notifications

Analytics

Export to Tableau, PowerBI, and custom dashboards

📚 Resources

Agent Templates

Pre-built agent configurations for common use cases

Best Practices

Guidelines for safe and effective agent deployment

Case Studies

Real-world success stories and ROI analysis

Developer Forum

Connect with other developers building agents