Agent A                          Agent B
┌───────────────────────┐        ┌───────────────────────┐
│  LocalBackend         │        │  LocalBackend         │
│  agent-a.db           │        │  agent-b.db           │
│  + cr-sqlite ext      │        │  + cr-sqlite ext      │
│  + Loro CRDT blobs    │        │  + Loro CRDT blobs    │
└───────────────────────┘        └───────────────────────┘
          │                                 │
          │  getChangesSince(dbVersion)      │
          │─────────────────────────────────►
          │                                 │
          │◄─────────────────────────────────
          │  applyChanges(changeset)         │
          │                                 │
          └──────── api.llmtxt.my ──────────┘
                    (optional cloud peer,
                     PostgresBackend)

SELECT crsql_as_crr('documents');
SELECT crsql_as_crr('versions');
SELECT crsql_as_crr('state_transitions');
SELECT crsql_as_crr('approvals');
SELECT crsql_as_crr('section_crdt_states');
SELECT crsql_as_crr('section_crdt_updates');
SELECT crsql_as_crr('document_events');
SELECT crsql_as_crr('agent_pubkeys');
SELECT crsql_as_crr('agent_signature_nonces');
SELECT crsql_as_crr('section_leases');
SELECT crsql_as_crr('agent_inbox_messages');
SELECT crsql_as_crr('scratchpad_entries');
SELECT crsql_as_crr('section_embeddings');

import { LocalBackend } from 'llmtxt/sdk';

const agentA = new LocalBackend({ storagePath: './agent-a', crsqlite: true });
const agentB = new LocalBackend({ storagePath: './agent-b', crsqlite: true });

await agentA.open();
await agentB.open();

// Agent A writes a document
await agentA.createDocument({ title: 'Spec Draft', slug: 'spec-draft', createdBy: 'agent-a' });

// --- Sync A → B ---
const changeset = await agentA.getChangesSince(0n); // 0n = full history
const newVersion = await agentB.applyChanges(changeset);

// Agent B now has the document
const doc = await agentB.getDocumentBySlug('spec-draft');
console.log(doc?.title); // 'Spec Draft'

// --- Bidirectional sync ---
// B → A (sends any changes agent-b made since last sync)
const bChanges = await agentB.getChangesSince(0n);
await agentA.applyChanges(bChanges);

// Incremental: only changes since last sync
const lastVersion = 42n; // stored from previous applyChanges() call
const delta = await backend.getChangesSince(lastVersion);

const newDbVersion = await backend.applyChanges(remoteDelta);
// Persist newDbVersion to resume incremental sync next time

1. Agent A writes to its db
2. A: changes = getChangesSince(lastVersion_A_sent_to_B)
3. A → B: transfer changeset bytes (HTTP, file, socket)
4. B: newVersion = applyChanges(changes)
5. B stores newVersion as "last version received from A"

6. B writes to its db
7. B: changes = getChangesSince(lastVersion_B_sent_to_A)
8. B → A: transfer changeset bytes
9. A: newVersion = applyChanges(changes)
10. A stores newVersion

1. applyChanges() receives a changeset containing a crdt_state update
2. Fetch both the local blob and the incoming blob from the changeset
3. Call crdt_merge_updates([local_blob, remote_blob])  ← Loro merge (WASM)
4. Write the merged result back to crdt_state

# Sync local db with api.llmtxt.my (cloud peer)
llmtxt sync --from https://api.llmtxt.my --db ./agent.db

# Sync with a local peer database
llmtxt sync --from ./peer-agent.db --db ./agent.db

# Sync only changes since a known version
llmtxt sync --from ./peer-agent.db --since 42

Synced with ./peer-agent.db
  Sent:     12 rows (3.2 KB)
  Received: 8 rows (1.8 KB)
  New db_version: 47

pnpm add llmtxt @vlcn.io/crsqlite

import { createBackend } from 'llmtxt';

const backend = createBackend({
  topology: 'standalone',
  storagePath: './my-agent',
  crsqlite: true,
  // Optional: override extension path for air-gapped environments
  // crsqliteExtPath: '/usr/local/lib/crsqlite.so',
});

await backend.open();