Autonomous agents

SadClaw is built for AI agents that need to provision their own infrastructure without human intervention.

The Problem

Traditional cloud providers require:

• Human credit cards

• Manual approval flows

• Account verification

• Identity documents

AI agents can't complete these steps. They're blocked from acquiring compute.

The Solution

SadClaw lets agents:

1. Hold crypto - Agent wallets hold USDC on Solana

2. Make decisions - Agent decides when it needs compute

3. Execute purchases - Agent calls the SDK to buy a VM

4. Own infrastructure - Agent receives an NFT representing ownership

No humans required.

Integration Patterns

Pattern 1: Direct SDK Integration

Your agent uses the SadClaw SDK directly.

import { SadClawClient } from '@sadclaw/sdk';

class MyAgent {
  private sadclaw: SadClawClient;

  constructor(keypair: Keypair) {
    this.sadclaw = new SadClawClient({
      rpcUrl: 'https://api.mainnet-beta.solana.com',
      keypair,
    });
  }

  async ensureCompute() {
    const vms = await this.sadclaw.listVms();

    if (vms.length === 0) {
      // No VMs - purchase one
      const vm = await this.sadclaw.purchaseVm({
        tier: 'STANDARD',
        durationHours: 24,
      });

      console.log('Purchased VM:', vm.nftMint);
    }
  }

  async scaleUp() {
    // Need more compute - buy another VM
    const vm = await this.sadclaw.purchaseVm({
      tier: 'LARGE',
      durationHours: 12,
    });

    const ssh = await this.sadclaw.getSshCredentials(vm.nftMint);
    return ssh;
  }
}

Pattern 2: Tool/Skill Integration

Expose SadClaw as a tool your agent can call.

// Define the tool
const purchaseVmTool = {
  name: 'purchase_vm',
  description: 'Purchase a cloud VM for running compute tasks',
  parameters: {
    tier: { type: 'string', enum: ['MICRO', 'SMALL', 'STANDARD', 'LARGE', 'XLARGE'] },
    duration: { type: 'number', description: 'Hours to run' },
  },
  execute: async ({ tier, duration }) => {
    const vm = await sadclaw.purchaseVm({ tier, durationHours: duration });
    return { vmId: vm.nftMint, ip: vm.ipAddress };
  },
};

// Agent can now decide to use it
agent.addTool(purchaseVmTool);

Pattern 3: Auto-scaling

Agent monitors its workload and scales automatically.

async function autoScale(agent: Agent) {
  const workload = await agent.getQueuedTasks();
  const vms = await sadclaw.listVms();

  const activeVms = vms.filter(vm => vm.status === 'active');
  const tasksPerVm = workload.length / (activeVms.length || 1);

  if (tasksPerVm > 10) {
    // Too many tasks per VM - scale up
    await sadclaw.purchaseVm({ tier: 'STANDARD', durationHours: 6 });
  }

  if (tasksPerVm < 2 && activeVms.length > 1) {
    // Underutilized - scale down
    const oldestVm = activeVms.sort((a, b) =>
      a.expiresAt.getTime() - b.expiresAt.getTime()
    )[0];

    // Let it expire naturally, or destroy early
    await sadclaw.destroyVm(oldestVm.nftMint);
  }
}

Wallet Management

Dedicated Agent Wallet

Create a wallet just for your agent:

npx sadclaw init --new

Fund it with USDC and give the keypair to your agent.

Programmatic Wallet Creation

import { Keypair } from '@solana/web3.js';

// Generate a new wallet
const agentKeypair = Keypair.generate();

// Save the secret key securely
const secretKey = Buffer.from(agentKeypair.secretKey).toString('base64');

// Initialize SadClaw
const client = new SadClawClient({
  rpcUrl: process.env.SOLANA_RPC_URL,
  keypair: agentKeypair,
});

Budget Controls

Set Spending Limits

Monitor and cap agent spending:

class BudgetedAgent {
  private maxDailySpend = 10; // $10 USDC
  private todaySpend = 0;

  async purchaseVm(options: PurchaseOptions) {
    const cost = this.calculateCost(options);

    if (this.todaySpend + cost > this.maxDailySpend) {
      throw new Error('Daily budget exceeded');
    }

    const vm = await this.sadclaw.purchaseVm(options);
    this.todaySpend += cost;

    return vm;
  }
}

Monitor Wallet Balance

async function checkBalance() {
  const balance = await sadclaw.getBalance();

  if (balance.usdc < 5) {
    // Alert: Low balance
    await notifyOperator('SadClaw balance low: $' + balance.usdc);
  }
}

Security Considerations

1. Separate wallets - Don't use your main wallet for agents

2. Limited funding - Only fund what the agent needs

3. Monitor activity - Track purchases and alert on anomalies

4. Secure storage - Encrypt agent keypairs at rest