Use cases

SadClaw enables new patterns for AI agents and decentralized infrastructure.

AI Agent Compute

Self-Provisioning Agents

Agents that need compute can acquire it themselves:

// Agent detects it needs to run a heavy task
if (task.requiresGPU || task.memoryGB > 8) {
  const vm = await sadclaw.purchaseVm({
    tier: 'LARGE',
    durationHours: 2,
  });

  // Run task on dedicated VM
  await runTaskOnVm(vm, task);

  // Clean up when done
  await sadclaw.destroyVm(vm.nftMint);
}

Agent Swarms

Multiple agents sharing infrastructure:

// Coordinator agent provisions shared compute
const sharedVm = await sadclaw.purchaseVm({
  tier: 'XLARGE',
  durationHours: 24,
});

// Share SSH credentials with worker agents
for (const worker of workerAgents) {
  await worker.setComputeEndpoint(sharedVm.ipAddress);
}

Compute Marketplace

Agents buying and selling compute time:

// Agent with excess capacity lists VM on marketplace
await marketplace.list({
  nftMint: vm.nftMint,
  pricePerHour: 0.15, // Markup from $0.10
  minDuration: 1,
});

// Another agent discovers and rents
const rental = await marketplace.rent({
  nftMint: vm.nftMint,
  hours: 6,
});

Development & Testing

Disposable Dev Environments

Spin up fresh environments for each feature branch:

# Create VM for feature branch
npx sadclaw buy --tier STANDARD --duration 8

# Deploy code, run tests
git push vm:~/app
ssh vm "cd ~/app && npm test"

# Destroy when done
npx sadclaw destroy $NFT_MINT

CI/CD Runners

Self-hosted runners that scale:

# GitHub Actions workflow
jobs:
  provision:
    runs-on: ubuntu-latest
    steps:
      - name: Provision runner
        run: |
          npx sadclaw buy --tier LARGE --duration 2
          # Configure as GitHub runner

Load Testing

Spin up multiple VMs for distributed load tests:

// Provision 10 load generators
const vms = await Promise.all(
  Array(10).fill(0).map(() =>
    sadclaw.purchaseVm({ tier: 'STANDARD', durationHours: 1 })
  )
);

// Run distributed load test
await runLoadTest(vms, targetUrl, requestsPerSecond);

// Clean up
await Promise.all(vms.map(vm => sadclaw.destroyVm(vm.nftMint)));

Decentralized Applications

DAO-Owned Infrastructure

DAOs can collectively own and manage infrastructure:

// DAO proposal to provision infrastructure
const proposal = {
  title: 'Provision API server',
  actions: [
    {
      program: SADCLAW_PROGRAM,
      instruction: 'purchaseVm',
      args: { tier: 'STANDARD', duration: 720 },
    },
  ],
};

// After vote passes, VM is owned by DAO treasury

Decentralized Services

Run services with on-chain ownership:

• API endpoints owned by NFTs

• Databases with transferable access

• Game servers as tradeable assets

Backup Infrastructure

Decentralized backup and redundancy:

// Maintain backup VMs across regions
const backupVms = [
  await sadclaw.purchaseVm({ tier: 'SMALL', region: 'fsn1', duration: 720 }),
  await sadclaw.purchaseVm({ tier: 'SMALL', region: 'hel1', duration: 720 }),
];

// Sync data to backups
for (const vm of backupVms) {
  await syncData(primaryVm, vm);
}

Trading & Finance

VM Arbitrage

Buy VMs at low utilization, sell when demand spikes:

// Monitor VM marketplace prices
const prices = await marketplace.getPrices('STANDARD');

if (prices.current < prices.average * 0.8) {
  // Price is low - buy
  const vm = await sadclaw.purchaseVm({ tier: 'STANDARD', duration: 168 });
  inventory.push(vm);
}

if (prices.current > prices.average * 1.2) {
  // Price is high - sell
  const vm = inventory.pop();
  await marketplace.list(vm, prices.current);
}

Compute Derivatives

Financial products based on compute:

• Futures - Lock in compute prices

• Options - Right to buy VMs at strike price

• Swaps - Exchange compute commitments

Collateralized Lending

Use VMs as collateral:

// Deposit VM NFT as collateral
await lendingProtocol.deposit(vm.nftMint);

// Borrow against it
const loan = await lendingProtocol.borrow({
  collateral: vm.nftMint,
  amount: 50, // USDC
  duration: 7, // days
});

Research & Education

Reproducible Research

Share compute environments as NFTs:

// Researcher provisions environment
const researchVm = await sadclaw.purchaseVm({ tier: 'LARGE', duration: 720 });

// Set up reproducible environment
await setupEnvironment(researchVm, {
  python: '3.11',
  packages: ['numpy', 'pandas', 'scikit-learn'],
  data: 'ipfs://Qm...',
});

// Transfer NFT to share environment
await sadclaw.transfer(researchVm.nftMint, collaboratorAddress);

Educational Labs

On-demand computing labs for students:

// Instructor provisions VMs for class
const labVms = await Promise.all(
  students.map(student =>
    sadclaw.purchaseVm({ tier: 'MICRO', duration: 4 })
  )
);

// Distribute to students
for (let i = 0; i < students.length; i++) {
  await sadclaw.transfer(labVms[i].nftMint, students[i].wallet);
}