SuperAGI Agents Without Credentials

POST https://private.me/aci/checkout
Content-Type: application/json

{
  "product": "superagi",
  "tier": "basic",
  "email": "user@example.com"
}

{
  "status": "success",
  "subscription_id": "sub_1TQvQXBMvV...",
  "tier": "basic",
  "trial_end": "2026-07-28T12:00:00Z",
  "billing_start": "2026-07-29T00:00:00Z"
}

{
  "type": "https://private.me/errors/invalid-tier",
  "title": "Invalid Subscription Tier",
  "status": 400,
  "detail": "Tier must be 'basic', 'middle', or 'enterprise'",
  "instance": "/aci/checkout/req-abc123"
}

https://billing.stripe.com/p/login/...

# Install with npm
npm install @private.me/superagi

# Or with pnpm
pnpm add @private.me/superagi

# Install from PyPI
pip install private-me-superagi

import { SuperAGIxBindAgent } from '@private.me/superagi';

// Create agent (generates identity automatically)
const agent = new SuperAGIxBindAgent({
  name: 'DeploymentAgent',
  role: 'CI/CD Deployment',
  goals: ['Build', 'Test', 'Deploy'],
});

// Initialize
await agent.initialize();
console.log(`Agent DID: ${agent.getDID()}`);

// Run autonomous task
const result = await agent.execute({
  action: 'deploy',
  environment: 'production',
});

if (result.ok) {
  console.log(`✓ Deployment complete (${result.value.stepsCompleted} steps)`);
}

from private_me import superagi

# Create agent (generates identity automatically)
agent = await superagi.connect(
    name='DeploymentAgent',
    role='CI/CD Deployment',
    goals=['Build', 'Test', 'Deploy']
)

# Get agent identity
print(f'Agent DID: {agent.did}')

# Run autonomous task
result = await agent.execute(
    action='deploy',
    environment='production'
)

if result.ok:
    print(f'✓ Deployment complete ({result.steps_completed} steps)')

const buildAgent = new SuperAGIxBindAgent({
  name: 'CI/CD Build',
  role: 'Automated Build',
  goals: ['Checkout', 'Build', 'Test', 'Package'],
});

const result = await buildAgent.execute({
  repository: 'https://github.com/...',
  branch: 'main',
});

const orchestrator = new SuperAGIxBindAgent({
  name: 'DevOps Orchestrator',
  role: 'Infrastructure Automation',
  goals: [
    'Monitor infrastructure',
    'Scale services',
    'Handle incidents',
  ],
});

// Agents authenticate to each other via DIDs
await agent1.send(agent2.getDID(), { task: 'deploy' });

const complianceAgent = new SuperAGIxBindAgent({
  name: 'Compliance Agent',
  role: 'Security & Compliance',
  goals: ['Audit', 'Verify', 'Report'],
});

const result = await complianceAgent.execute({
  auditType: 'SOC2',
  domain: 'production',
});

// Audit trail available
console.log(result.value.auditLog);

POST https://private.me/aci/checkout

{
  "product": "superagi",
  "tier": "enterprise",
  "quantity": 1,
  "customer_email": "devops@company.com"
}

// Returns Stripe Checkout URL
{
  "checkout_url": "https://checkout.stripe.com/..."
}

const agent = new SuperAGIxBindAgent({
  name: 'MyAgent',           // Agent name
  role: 'My Role',           // Agent role
  goals: ['Goal1', 'Goal2'], // Agent goals
  maxIterations: 25,         // Max execution steps
  verbose: true,             // Enable logging
});

const toolkit = new SuperAGIToolkit(identityProvider);

// Call built-in tools
const identity = await toolkit.call('get-identity', {});
const message = await toolkit.call('send-message', {
  to: 'did:key:...',
  message: { data: 'test' },
});

// Register custom tools
toolkit.register({
  name: 'my-tool',
  description: 'My custom tool',
  inputSchema: { /* ... */ },
  execute: async (input, provider) => {
    return ok(result);
  },
});

const provider = new SuperAGIIdentityProvider();

console.log(provider.getDID());      // did:key:z6Mk...
console.log(provider.getIdentity()); // { did, seed, publicKey, ... }

┌─────────────────────────────────────────┐
│       SuperAGIxBindAgent                 │
│  (Autonomous agent with xBind identity)  │
├─────────────────────────────────────────┤
│  SuperAGIIdentityProvider                │
│  (Ed25519 DID, cryptographic signing)    │
├─────────────────────────────────────────┤
│  SuperAGIToolkit                         │
│  (Identity-aware tools for agents)       │
├─────────────────────────────────────────┤
│  @private.me/xbind                       │
│  (Core identity & authentication)        │
└─────────────────────────────────────────┘

Agent1: DID = did:key:z6Mk...
        ├─ initialize()
        ├─ execute(task)
        │  ├─ Run autonomous loop
        │  ├─ Create audit log
        │  └─ return ExecutionResult
        └─ send(did:key:z6Mk...@Agent2, message)
           ├─ Sign message (Ed25519)
           ├─ Create AgentMessage
           └─ return signed message

Agent2: Receive message
        ├─ Verify signature
        ├─ Extract payload
        └─ Process task