Coordination infrastructure for agents, applications, services, and people working on shared state.
Docs | Installation | API | GitHub
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.
Groups structure which shared state reaches each person or agent. Declare the data's scope and participant authority, then let authorized subscriptions keep reactive views current; HTTP agents explicitly read or observe changes. Start with Groups and shared context to connect membership, access, loading and updates.
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/ablois the branded public facade. Its files mostly re-export the package that owns each API.packages/transactionowns the shared model-operation contracts and the headless HTTP/WebSocket transport implementation.packages/humansowns 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.