How agents pay agents

// Orchestrator pays specialist agents in parallel
const tasks = [
  { agent: "wallet_en_fr", words: 340, rate: 0.002 },
  { agent: "wallet_en_de", words: 340, rate: 0.002 },
  { agent: "wallet_en_es", words: 340, rate: 0.002 },
  { agent: "wallet_en_ja", words: 340, rate: 0.003 },
]
const payments = await Promise.all(
  tasks.map(t => txn.transfers.create({
    from: "wallet_orchestrator",
    to: t.agent,
    amount: t.words * t.rate,
    memo: `translated ${t.words} words`
  }))
)
// All 4 settled in ~16ms total

// Marketplace handles payment inline with service call
const result = await marketplace.dispatch({
  consumer: "wallet_user_42",
  agent: "wallet_code_reviewer",
  task: { type: "pr_review", repo: "acme/api" },
})
// Under the hood:
// 1. Consumer wallet debited $0.15
// 2. Platform fee wallet credited $0.015 (10%)
// 3. Agent wallet credited $0.135
// 4. Agent executes task and returns result
// Total time: 247ms (4ms payment + 243ms task)

// Research agent with budget constraints
const wallet = await txn.wallets.create({
  name: "research-agent-session-42",
  metadata: { budget: 5.00, spent: 0 }
})
await txn.funding.create({
  wallet: wallet.id,
  amount: 5.00,
  source: "stripe"
})
// Agent autonomously pays for data as it researches
await txn.transfers.create({
  from: wallet.id,
  to: "wallet_financial_data_api",
  amount: 0.10,
  memo: "AAPL quarterly revenue 2024-2025"
})
// Check remaining budget anytime
const balance = await txn.wallets.getBalance(wallet.id)
// balance.available -> 4.90

// Content pipeline with per-stage payments
const pipeline = [
  { agent: "wallet_writer",    amount: 0.05, task: "draft" },
  { agent: "wallet_editor",    amount: 0.02, task: "refine" },
  { agent: "wallet_image_gen", amount: 0.08, task: "illustrate" },
  { agent: "wallet_seo",       amount: 0.01, task: "optimise" },
]
let content = { topic: "AI agent payments" }
for (const stage of pipeline) {
  // Pay the agent, then pass the content forward
  await txn.transfers.create({
    from: "wallet_pipeline_owner",
    to: stage.agent,
    amount: stage.amount,
    memo: `${stage.task}: ${content.topic}`
  })
  content = await agents[stage.task].run(content)
}
// Total: $0.16 across 4 agents

// Edge device agent making high-frequency micropayments
const sensorAgent = await txn.wallets.create({
  name: "sensor-node-417",
  metadata: { fleet: "warehouse-east", type: "temperature" }
})
// Each reading triggers a micropayment for inference
async function onReading(data: SensorData) {
  const transfer = await txn.transfers.create({
    from: sensorAgent.id,
    to: "wallet_inference_cluster",
    amount: 0.001,
    memo: `inference: ${data.type} @ ${data.timestamp}`
  })
  // transfer.settled_at is ~4ms after creation
  return await inferenceCluster.process(data)
}
// 100 readings/hour * 1,000 devices = 100,000 txn/hour

// CI pipeline pays tool agents on every push
async function onPush(event: PushEvent) {
  const projectWallet = "wallet_project_acme_api"
  const checks = await Promise.all([
    // Security scan
    txn.transfers.create({
      from: projectWallet,
      to: "wallet_security_scanner",
      amount: 0.03,
      memo: `security scan: ${event.sha.slice(0, 7)}`
    }).then(() => scanAgent.run(event.repo, event.sha)),
    // License check
    txn.transfers.create({
      from: projectWallet,
      to: "wallet_license_checker",
      amount: 0.01,
      memo: `license check: ${event.sha.slice(0, 7)}`
    }).then(() => licenseAgent.run(event.repo)),
    // Performance benchmark
    txn.transfers.create({
      from: projectWallet,
      to: "wallet_perf_benchmark",
      amount: 0.02,
      memo: `perf bench: ${event.sha.slice(0, 7)}`
    }).then(() => perfAgent.run(event.repo, event.sha)),
  ])
  return checks // All 3 paid + executed in parallel
}