Give agents branches, checkpoints, semantic diffs, and rollback without dealing with Git internals.
import { openLix, SqliteBackend } from "@lix-js/sdk";
const lix = await openLix({
backend: new SqliteBackend({ path: "app.lix" }),
});
const main = await lix.activeBranchId();
await lix.fs.writeFile("/orders.xlsx", bytes);
const original = await lix.fs.readFile("/orders.xlsx");
const draft = await lix.createBranch({ name: "Explore" });
await lix.switchBranch({ branchId: draft.id });
await lix.fs.writeFile("/orders.xlsx", draftBytes);
await lix.switchBranch({ branchId: main });
const merge = await lix.mergeBranch({
sourceBranchId: draft.id,
});
const changes = await lix.execute(
"SELECT schema_key, count(*) AS count FROM lix_change GROUP BY schema_key"
);AI agents are creating an explosion in version-control demand: isolated workspaces, branchable explore steps, reviewable changes, rollback. They need versioning as infrastructure, not as a CLI.
Teams reach for Git - and end up managing a sidecar that was never meant to live inside their app:
Lix is built the other way around. Sessions, not worktrees. A SQL engine you embed, with semantic diffs and branches as first-class state - backed by infrastructure you already run.
Import, open, run. Programmatic and in-process - no daemon, no protocol, no remote. In-memory by default; bring your own SQLite, Postgres, S3, or Cloudflare backend if needed.
import { openLix, SqliteBackend } from "@lix-js/sdk";
const lix = await openLix({
backend: new SqliteBackend({ path: "app.lix" }),
});One transaction covers your data, the blobs it references, and the change row that records the edit. No two-phase commit between three systems.
await lix.transaction(async (tx) => {
await tx.fs.writeFile("/spec.docx", body);
await tx.fs.writeFile("/spec.png", img);
});Each agent gets its own session and version without Git-style multi-checkout worktrees. Lix commits through the backend transaction layer, not per-agent repo directories or shell-out coordination.
const agent1 = await lix.create_session("copy");
const agent2 = await lix.create_session("pricing");
const agent3 = await lix.create_session("qa");
await agent1.fs.writeFile("/landing.md", copyDraft);
await agent2.fs.writeFile("/plans.json", priceModel);
await agent3.fs.writeFile("/checks/report.json", testRun);
await agent1.commit();
await agent2.commit();
await agent3.commit();Agents can answer complex questions in one query instead of rereading whole files. Burn fewer tokens, get faster responses, and ground reviews in structured changes - not raw bytes.
Which orders changed status in this branch?
const rows = await lix.execute(
`
SELECT
f.path,
lix_json_get_text(c.entity_pk, 0) AS row_id,
c.snapshot_content AS change
FROM lix_change AS c
JOIN lix_file AS f
ON f.id = c.file_id
WHERE c.schema_key = 'xlsx_row'
AND f.path = '/orders.xlsx'
ORDER BY c.created_at DESC;
`
);Start in memory, then plug Lix into the infrastructure your app already runs: SQLite, Postgres, S3 object storage, Cloudflare storage, or your own backend adapter.
const lix = await openLix({
backend: new SqliteBackend({ path: "app.lix" }),
});v0.6 ships the engine.
new shapes land in every release.
Isolated workspaces, branchable explore steps, semantic change history, and rollback when a run goes sideways.
Time-travel and branchable schemas on top of an existing database. Reviewable migrations. Diffable rows.
Add branches, review, rollback, and history to editors, CMSs, design tools, internal ops apps, and AI-native products.
Surface what an agent actually changed at the entity level. Approve, request edits, or revert by symbol - not by patch.
Lix SDK
Lix CLI
file plugin API
merge conflicts
working changes
Install. Open a Lix with the default in-memory backend. Write something, branch it, query its history. Plug in Postgres or S3 when you outgrow it.
# 1 · install
$ npm install @lix-js/sdk
# 2 · open
import { openLix } from "@lix-js/sdk";
const lix = await openLix();
# 3 · write & commit
await lix.fs.writeFile("/hello.json", payload);
# 4 · branch & ask
const b = await lix.branch("draft");
const diff = await lix.diff({ from: "main", to: b });
