# The write layer for AI agents.

Ablo sits between your agents, your users and your Postgres. It stops them overwriting each other, checks that every change is allowed, and shows every change live, with who made it.

You are building a product where AI agents do real work inside your customers’ records: purchase orders, case files, deals, tickets. Ablo sits between those agents, your users and your Postgres. It stops them overwriting each other, checks that every change is allowed, and shows every change live, with who made it.

- Not a plugin for your own Claude Code or Cursor setup
- Not an internal-tools builder
- Not a new database

## A layer inside your product. Your customers never see it.

Your engineers add Ablo to your backend the way they would add Stripe for payments. Every write from an agent or a person goes through it on the way to your database.

- Is this agent allowed to do this?
- Did the record change since it was read?
- Is someone else holding this record?
- Record who did it, then show it live

Live updates flow back the other way: when a row changes in your database, every person and agent looking at it sees the change.

## An agent thinks for 40 seconds. The world doesn’t wait.

Agents read a record, call a model, then write. While the model runs, a person or another agent changes the same record. Here is one purchase order at a procurement company that runs agents for its customers.

### Without Ablo

- **09:14:02, Agent:** Reads PO-4471: 500 units from Supplier A. Starts working out whether to approve.
- **09:14:09, Buyer:** Supplier A can only ship 300. The buyer changes the order to 300 units.
- **09:14:41, Agent:** Writes back what it read 39 seconds ago: 500 units, approved. The buyer’s change is gone.
- **Thursday, Finance:** An invoice for 500 units arrives. Nobody can tell which write won, or why.

No error, no alert. The last write silently won, and it looked like the agent hallucinated. It rarely shows up in testing, because it needs two writers at once.

### With Ablo

- **09:14:02, Agent:** Reads PO-4471: 500 units from Supplier A. Starts working out whether to approve.
- **09:14:09, Buyer:** Changes the order to 300 units. The agent’s screen and the buyer’s both show it live.
- **09:14:41, Ablo:** Refuses the agent’s write: “PO-4471 changed since you read it at 09:14:02.”
- **09:14:43, Agent:** Re-reads, sees 300 units and approves 300. Both writes are in the log, with who made them.

The agent got a clear, typed error it can act on instead of a silent overwrite. For longer work, an agent can reserve the record first, so others wait their turn.

## Four jobs you would otherwise build yourself.

### Stops overwrites

An agent can reserve a record while it thinks, and others queue in order. A write built on an out-of-date read is refused instead of landing silently.

### Checks every write

Each agent gets only the access you grant it: which data, which actions, for how long and on whose behalf. Revoke an agent and its live connections close, mid-task.

### Shows everything live

Every accepted change streams to everyone looking at that record, person or agent. Your users watch agents work, and agents see what people just did.

### Records who did what

Every change is tied to the person or agent that made it, in order. When a customer asks “who changed this?”, you can show them.

## Reserve, think, write.

Your agent code stays your agent code. The difference is that the record is held while the model runs, and the write is checked when it lands.

```sh
npm install @abloatai/ablo
```

```ts
// Hold the order while the model decides.
// If someone else holds it, wait in line.
await using claim = await ablo.purchaseOrders.claim({
  id: 'PO-4471',
  action: 'approving',
});

const order = claim.data; // fresh at the moment it's yours
const decision = await llm.decide(order);

await ablo.purchaseOrders.update({ id: 'PO-4471', data: decision });

// Released when the block ends.
// Everyone watching PO-4471 sees the change live.
```

## For the people building the agents, not the people using them.

### A good fit

- **You sell an agent product.** Managed or vertical agents that work inside your customers’ data: procurement, legal, sales, support, operations.
- **Agents and people edit the same records.** Your customers keep working while your agents run, and each needs to see the other’s changes.
- **You run a large agent system in-house.** Many agents on shared state. We run our own coding-agent product, Lobby, on Ablo.
- **You have already built some of this.** Hand-written locks, version columns, retry loops and “who changed this” tables are the sign.

### Not what you need

- **Making your own coding agent work better.** Ablo is not installed in Claude Code, Cursor or your personal agent setup.
- **Building internal dashboards.** Use an internal-tools builder. Ablo has no UI for your staff.
- **One process writing to one table.** If nothing else writes to that data, your ORM is enough.

## Your data stays in your Postgres. Start with one action.

Your database stays the system of record. Adopt Ablo one step at a time; each step works on its own.

- **Step 1: Coordinate one action.** Wrap the agent action that collides most often in a claim. Your existing writes stay exactly as they are. Needs: An API key. No database access.
- **Step 2: See changes live.** Connect your Postgres so Ablo can follow its changes. Your app and agents get live updates and the change history. Needs: A read-only replication role.
- **Step 3: Write through Ablo.** Route writes for the tables that matter through Ablo, so every change is checked, ordered and recorded. Needs: A scoped write role on chosen tables.

## Frequently asked questions

### Is Ablo an internal tool?

No. Ablo is infrastructure your engineers build into your product, like a payments or login provider. Your customers use your product; Ablo works underneath it.

### Do I install it in Claude Code or Cursor?

No. Ablo is not for making your own coding assistant better. It is for the agents your company runs for its customers, and the app those customers use alongside them.

### Is it a database? Do you store our data?

No. Your rows stay in your Postgres. Ablo keeps an ordered log of changes and who made them, plus coordination state such as who holds which record.

### We already use LangGraph, Temporal or our own orchestrator.

Keep it. Those run your agents’ steps. Ablo sits at the data: it decides what happens when two of those steps, or a step and a person, change the same record.

### Why not Supabase Realtime, Electric or our own WebSocket layer?

Those send changes out to clients, which is the read side. Ablo also owns the write side: refusing stale writes, holding records, checking permissions and recording who did what.

### What happens to our data if we stop using Ablo?

Nothing. It never left your Postgres. Your database stays the system of record, so removing Ablo means your app writes to your database directly again.

### Couldn’t we build this ourselves?

Yes, and some teams do. Live updates alone means change capture, a subscription service, permission checks on open connections, reconnect handling and deploy tooling. Then come locks, stale-write checks and an audit log. If one service owns your data, build it. If agents and people share it, that is what Ablo is for.

---

Canonical URL: https://www.abloatai.com/product

Also machine-readable on this domain: /llms.txt, /llms-full.txt, /openapi.json, /sitemap.xml, /robots.txt
