Ablo is coordination infrastructure for agents, applications, services, and people working on shared state.

Every write goes through it, so authority, idempotency, conflicts, ordering, and confirmation are enforced in one place. Your Postgres remains the source of truth.

Why Ablo

Software used to have one writer: a human clicking through an application. AI applications now have humans, agents, workflows, and services acting concurrently. Databases keep transactions consistent. They do not coordinate autonomous work that reads now, reasons for thirty seconds, and writes later.

Humans handle this naturally. We see that somebody is editing, agree on who takes which part, wait our turn, and look again before continuing. Ablo gives software actors those same capabilities: bounded authority, shared ownership, fresh context, safe handoffs, and an attributed record of what happened.

Start

npm install @abloatai/ablo
npx ablo init
npx ablo dev

ablo dev prepares an isolated Ablo branch for your Git branch, writes its temporary credential to gitignored .env.local, pushes the schema, and watches for changes.

Read and write through one typed API:

const order = await ablo.orders.read({ id: orderId });

if (!order) throw new Error('Order not found');
await ablo.orders.update({
  id: order.id,
  data: { status: 'approved' },
  reads: [order],
});

confirmed means the authoritative database reported the change back. The same commit can be retried safely if the caller loses its connection.

When work takes thirty seconds instead of one request, coordinate before the agent starts reasoning:

await using claim = await ablo.orders.claim({ id: orderId });

const priced = await pricingAgent(claim.data);

await ablo.orders.update({
  id: claim.data.id,
  data: { total: priced.total, status: 'repriced' },
  claim,
});

Another actor touching the same work waits fairly and receives fresh state when its turn begins. If the agent fails, the claim releases automatically. If its context became stale, the write is rejected instead of silently overwriting work it never saw.

If you use AI SDK, expose the same operation as a typed model tool:

import { updateTool } from '@abloatai/ablo/ai-sdk';

const approveOrder = updateTool(ablo.orders, {
  description: 'Approve an order after reviewing it.',
  inputSchema: z.object({ orderId: z.string() }),
  id: ({ orderId }) => orderId,
  apply: () => ({ status: 'approved' }),
});

Ablo supplies readTool, createTool, updateTool, and deleteTool over the same authoritative resources. AI SDK keeps ownership of the model loop and tool execution.

For a model call that needs several reads plus application-owned retrieval or memory, context() awaits the selected values and carries the exact Ablo rows into the write's reads option. It does not add search, memory, or a model runtime.

Use @abloatai/ablo for agents and backend code, @abloatai/ablo/client for live applications, and @abloatai/ablo/react for React. All entrypoints share the same schema, authority, commits, claims, and ordered changes.

Read the Quickstart, browse docs.abloatai.com, or run npx ablo docs.

Navigating the source

This repository preserves the package ownership boundaries instead of flattening the implementation into packages/ablo:

• packages/ablo is the branded public facade. Its files mostly re-export the package that owns each API.
• packages/transaction owns the shared model-operation contracts and the headless HTTP/WebSocket transport implementation.
• packages/humans owns the reactive WebSocket/local/React implementation.

That means searching only inside packages/ablo/src will not find the implementation of create, update, delete, or claim. Read the source code map for a verb-by-verb ownership table and guided call traces for both the default and reactive clients.

Contributing

Ablo is free and open source. You can help by opening an issue, suggesting a feature, or contributing code.

Please report vulnerabilities privately through GitHub Security Advisories.

License

Apache License 2.0. See LICENSE and NOTICE.