Multi-Agent Deployments

How to scale Vanishd across dozens, hundreds, or thousands of AI agents.

API Key Strategies

Shared API Key (Recommended)

One API key per application or deployment. All agents share the same key and useagentId to identify themselves.

• Rate limits apply to the key, shared across all agents
• Simplest management - one key to create, rotate, and monitor
• Usage billing aggregates under one key
• Best for: Teams with many agents doing similar work

Separate API Keys (Enterprise)

One key per agent or agent cluster. Better isolation but more management overhead.

• Rate limits are per-key, so each agent gets its own quota
• Requires Pro+ tier for multiple keys (Free tier limited to 1 key)
• Better for: Isolating usage by team, environment, or agent type

Using agentId

The agentId field lets you track individual agents even when sharing an API key. It's included in the receipt for audit purposes.

Best Practices

Format: {app}-{environment}-{instance-uuid}
Example: chatbot-prod-a1b2c3d4-e5f6-7890
Max length: 256 characters
Must be unique per agent instance

Example: terminateAgent()

const result = await actor.terminateAgent(apiKey, {
  agentId: "chatbot-prod-a1b2c3d4",
  reason: { taskComplete: null },
  taskSummary: ["Task completed successfully"],
  finalStateHash: [],
  durationSeconds: [3600],
  parentAgentId: [],
  customMetadata: [],
});

Batch Attestation (certifyBatch)

Create multiple attestation receipts in a single API call. This is the key to high-throughput deployments — up to 500 receipts per call on the Scale tier.

Tier-Based Batch Limits

Tier	Max Batch Size	Rate Limit/min	Effective Receipts/min
Free	10	60	600
Pro	100	600	60,000
Scale	500	6,000	3,000,000
Enterprise	2,000	30,000	60,000,000

Billing: Each receipt in a batch is billed individually. A batch of 100 receipts = 100 receipts toward your quota. Batching saves API calls and rate limit consumption, not cost per receipt.

Example

// Batch certify 50 credential erasures
const requests = deletions.map(d => ({
  credentialHash: d.hash,         // 32-byte SHA-256
  erasedAt: d.timestamp,       // nanoseconds
  metadata: [],                   // optional
  idempotencyKey: [`batch-${d.id}`], // optional dedup
}));

const result = await actor.certifyBatch(apiKey, requests);
// result.ok = array of { receiptId, commitmentHash, status, createdAt }
console.log(`Created ${result.ok.length} receipts in 1 API call`);

Rate Limits with Multiple Agents

Rate limits are per account (principal), shared across all API keys and agents under that account.

Scale Tier Example (6,000 req/min)

60 agents at 1.5 req/sec each  = 5,400 req/min (OK)
100 agents at 1 req/sec each   = 6,000 req/min (at limit)
200 agents at 0.5 req/sec each = 6,000 req/min (at limit)

With certifyBatch(500):
  12 batch calls/min x 500 = 6,000 receipts/min (OK, uses 12 of 6,000 rate limit)
  6,000 batch calls/min x 500 = 3,000,000 receipts/min (max throughput)

If You Hit Rate Limits

Use certifyBatch() to multiply throughput
Implement exponential backoff with jitter
Distribute agents across multiple API keys
Upgrade to Enterprise for 30,000 req/min

Scaling Checklist

☐Use test receipts (vnd_sk_test_) during development
☐Implement certifyBatch() for production throughput
☐Use unique agentId per agent instance
☐Monitor usage in the dashboard
☐Implement exponential backoff for rate limit errors
☐Plan for tier upgrade before hitting limits
☐Store salts securely — see Quickstart Guide

API Reference · Quickstart Guide · Error Codes