Integrate Elydora.
Step by step.

The most common pattern. Wrap each outbound action your agent takes with an Elydora operation record: third-party API calls, database mutations, payment processing. The operation is created and submitted as part of the action flow, so the audit trail stays consistent with the behavior.

// Wrap an external API call with an Elydora operation
async function approvePayment(paymentId: string, amount: number) {
  // 1. Record the decision before executing it
  const record = client.createOperation({
    operationType: 'payment.approve',
    subject: { system: 'payments', resource: 'payment', id: paymentId },
    action: { decision: 'approve', amount, currency: 'USD' },
    payload: { payment_id: paymentId, amount, approved_by: 'agent_underwriter' },
  });

  // 2. Submit to Elydora (proof of intent)
  const { receipt } = await client.submitOperation(record);

  // 3. Execute the payment
  const result = await paymentGateway.charge(paymentId, amount);

  // 4. Record the outcome
  const outcomeRecord = client.createOperation({
    operationType: 'payment.executed',
    subject: { system: 'payments', resource: 'payment', id: paymentId },
    action: { status: result.status, transaction_id: result.txId },
    payload: { receipt_id: receipt.receipt_id, gateway_response: result },
  });
  await client.submitOperation(outcomeRecord);

  return result;
}

For agents that run as background workers processing queues or scheduled jobs. Each job execution is wrapped in an Elydora operation, recording what the agent processed, what it decided, and what it produced. Suited to batch pipelines, cron-based agents, and event-driven architectures.

// Background job worker with Elydora auditing
async function processJob(job: QueueJob) {
  const record = client.createOperation({
    operationType: 'batch.process',
    subject: { system: 'pipeline', resource: 'job', id: job.id },
    action: { type: job.type, batch_size: job.items.length },
    payload: {
      job_id: job.id,
      queue: job.queue,
      items_count: job.items.length,
      started_at: new Date().toISOString(),
    },
  });

  const { receipt } = await client.submitOperation(record);
  const result = await executeJob(job);

  return { receipt, result };
}

For agents making many decisions per second (trading, real-time fraud detection, content moderation). Keep one client per agent and submit sequentially; the chain forbids reordering. Partition operations across several logical agents, each with its own chain, to raise throughput.

// One client per logical agent; each agent owns its chain
const scorers = ['agent_fraud_a', 'agent_fraud_b'].map((agentId) => {
  const client = new ElydoraClient({ orgId: 'org_acme', agentId, privateKey: keyFor(agentId) });
  client.setToken(process.env.ELYDORA_TOKEN!);
  return client;
});

// Submit sequentially within an agent: the chain forbids reordering
async function scoreBatch(client: ElydoraClient, decisions: Decision[]) {
  for (const decision of decisions) {
    const record = client.createOperation({
      operationType: 'fraud.score',
      subject: { system: 'fraud', resource: 'transaction', id: decision.txId },
      action: { score: decision.score, flagged: decision.score > 0.8 },
      payload: { features: decision.features },
    });
    await client.submitOperation(record);
  }
}

// Agents run in parallel with each other
await Promise.all(scorers.map((client, i) => scoreBatch(client, partitions[i])));

For systems where several agents collaborate on one workflow. Each agent keeps its own chain, and operations reference each other through the subject field. This gives a cross-agent audit trail showing how decisions flowed through the pipeline. Use one correlation_id in the payload to link related operations.

// Agent A: triage agent
const triageRecord = triageClient.createOperation({
  operationType: 'ticket.triage',
  subject: { system: 'support', resource: 'ticket', id: 'TKT-5001' },
  action: { priority: 'high', assigned_to: 'agent_resolver' },
  payload: { correlation_id: 'workflow_abc123', sentiment: 'negative' },
});
await triageClient.submitOperation(triageRecord);

// Agent B: resolver agent (references the same ticket)
const resolveRecord = resolverClient.createOperation({
  operationType: 'ticket.resolve',
  subject: { system: 'support', resource: 'ticket', id: 'TKT-5001' },
  action: { resolution: 'refund_issued', amount: 150 },
  payload: {
    correlation_id: 'workflow_abc123',
    triage_operation_id: triageRecord.operation_id,
  },
});
await resolverClient.submitOperation(resolveRecord);