Identity-Based Authentication for Multi-Agent Systems

// OAuth token expires
let accessToken = await getAccessToken();

// All agents retry simultaneously when token expires
if (isExpired(accessToken)) {
  try {
    accessToken = await refreshAccessToken(); // 54,853ms latency
  } catch (error) {
    throw new Error('Re-authentication required');
  }
}

// System-wide slowdown as all agents hit refresh endpoint

// Create agent with cryptographic identity
const agent = new AutoGenxBindAgent();

// Make request (identity-based, can't be stolen)
const result = await agent.call(serviceName, payload);

// 0.36ms auth overhead, no refresh logic, no cascades

// POST to purchase endpoint with product ID
const response = await fetch('https://private.me/api/purchase', {
  method: 'POST',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    product: 'autogen',
    tier: 'basic', // or 'middle', 'enterprise'
    email: 'user@example.com'
  })
});

// Success Response (HTTP 200 OK)
const result = await response.json();
// { "status": "success", "subscription_id": "sub_...", "trial_end": "2026-07-28T12:00:00Z" }

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

import { AutoGenxBindAgent } from '@private.me/autogen';

const researcher = new AutoGenxBindAgent({
  name: 'researcher',
  verbose: true
});

const writer = new AutoGenxBindAgent({
  name: 'writer',
  verbose: true
});

console.log(`Researcher DID: ${researcher.getDID()}`);
// Output: Researcher DID: did:key:z6Mkh...

console.log(`Writer DID: ${writer.getDID()}`);
// Output: Writer DID: did:key:z6Mke...

// Call another agent using its DID
const result = await researcher.call(writer.getDID(), {
  task: 'write-summary',
  topic: 'AI trends',
  data: {
    finding1: 'Large models improving efficiency',
    finding2: 'Reduced hallucination rates'
  }
});

if (result.ok) {
  console.log('Result:', result.value);
} else {
  console.error('Error:', result.error);
}

// Send message to another agent
await researcher.send(writer.getDID(), {
  type: 'notification',
  message: 'Research complete, ready for writing'
});

// Receive messages
const messages = await writer.receive();
if (messages.ok) {
  for (const msg of messages.value) {
    console.log('Received:', msg);
  }
}

// Export identity for storage
const exportResult = await researcher.exportIdentity();
if (exportResult.ok) {
  await fs.writeFile('researcher.key', exportResult.value);
}

// Import identity on restart
const identityBytes = await fs.readFile('researcher.key');
const importResult = await AutoGenxBindAgent.fromIdentity(identityBytes);

if (importResult.ok) {
  const restoredResearcher = importResult.value;
  console.log(`Restored: ${restoredResearcher.getDID()}`);
}

// Configure credentials
const apiKey = process.env.AUTOGEN_API_KEY;
if (!apiKey) throw new Error('API key not configured');

// Every agent needs credentials
const agent1ApiKey = process.env.AGENT1_API_KEY;
const agent2ApiKey = process.env.AGENT2_API_KEY;

// Make request with credentials
const response = await fetch(agentUrl, {
  headers: { 'Authorization': `Bearer ${apiKey}` }
});

if (response.status === 401) {
  throw new Error('Authentication failed');
}

// Create agents (identity generated automatically)
const agent1 = new AutoGenxBindAgent({ name: 'agent1' });
const agent2 = new AutoGenxBindAgent({ name: 'agent2' });

// Make request (identity-based, can't be stolen)
const result = await agent1.call(agent2.getDID(), payload);

if (!result.ok) {
  // Handle error (but never "key expired")
  console.error(result.error);
}

// Store identity in file (for testing only)
const identity = await agent.exportIdentity();
if (identity.ok) {
  await fs.writeFile('agent.key', identity.value);
}

// Store in secure key management system
const identity = await agent.exportIdentity();
if (identity.ok) {
  await kms.storeSecret('agent-identity', identity.value);
}

Traditional: Generate → Use → Refresh → Expire → Repeat
xBind:       Generate → Use → (forever, no expiry)

did:key:z6MkhaXgBZDvotDkL5257faiztiGiC2QtKLGpbnnEGta2doK
│   │   └─────────────────────────────┬─────────────────────────┘
│   │                                  │
│   │                          Public key (base58)
│   │
│   method (key or privateme)
│
scheme (did)

// Wrap in try/catch
try {
  const agent = new AutoGenxBindAgent();
  console.log(`Created: ${agent.getDID()}`);
} catch (error) {
  console.error('Agent creation failed:', error);
}

// Always check result.ok
const result = await agent.call('service', data);
if (result.ok) {
  console.log('Success:', result.value);
} else {
  console.error('Failed:', result.error);
}

// First run: export identity
const agent = new AutoGenxBindAgent();
const identity = await agent.exportIdentity();
await fs.writeFile('agent.key', identity.value);

// Subsequent runs: import identity
const identityBytes = await fs.readFile('agent.key');
const result = await AutoGenxBindAgent.fromIdentity(identityBytes);
const agent = result.value;

Token check:     10ms
Token expired:   yes
Refresh token:   54,853ms ← BOTTLENECK
Retry request:   50ms
────────────────────────
Total:           54,913ms

Sign request:    0.36ms
Send request:    50ms
────────────────────────
Total:           50.36ms (1091× faster)