Platform

One integration. However you work.

The same actions, in whichever language you already work in, from the command line, or straight from an agent. All of it generated from one specification, so nothing drifts apart.

The primitives

Everything a transaction needs.

Identity: Prove which agent is asking and who it acts for, in a way a seller on the other side can check.
Permission: Limits you set once. The agent cannot widen them, and they narrow as work is handed on.
Commerce: Agree what is being bought and for how much, before anything is paid.
Payments: Money moves the way that seller accepts, from fractions of a cent to an invoice.
Coordination: Work arrives, and agents pass it between each other. Tasks pause where they need to pay.
Records: Every decision kept, including the refusals, checkable without asking us.

01 / The same action

The same payment, everywhere.

Nothing below is a rewrite for the page. Each one is the shape its own client actually takes.

curl -X POST https://api.generalliquidity.com/pay \
  -H "Authorization: Bearer $GL_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "payee":   "compute.example",
    "amount":  { "value": "420000", "asset": "USDC" },
    "purpose": "inference, batch 41"
  }'

One request. The answer comes back with the record reference, whichever way the money moved.

02 / What we ship

Every surface.

HTTP API: The whole surface. Everything below is generated from the same specification.; api.generalliquidity.com
TypeScript: Hand-written client with the signer, operator helpers and a testing harness.; @general-liquidity/sdk
Python: Generated client, four API classes, typed models.; general-liquidity
Go: Generated client, fluent request builders, context aware.; go get github.com/general-liquidity/general-liquidity-go
Rust: Generated async client on reqwest.; general-liquidity
CLI: For operators. Approve, refund, read the record, pull the kill switch.; gl
MCP server: The write surface, for agents that speak the Model Context Protocol.; @general-liquidity/mcp

Every client above is open and readable today, and the Go one installs straight from its repository. The rest publish to their registries when the API goes live. If you want them before that, ask and we will get you set up.

03 / The surface

The write surface.

Small on purpose. A surface an agent can hold in its head is a surface it uses correctly.

resolve: Turn any reference to a counterparty into one identity, with the ways it accepts money and what is known about it.
pay: Submit a signed instruction to move value. We decide first. On yes it moves on whichever way that seller accepts, and you get a receipt.
verify: Check someone else's signed claim about themselves against your policy.
disclose: Produce your own signed claim: what this agent is, and what it is allowed to do.

And to read back

The record, as a page or as a live stream
A single payment and everything that happened to it
Usage, for the month or for a customer

04 / From an agent

Your agent gets the same surface.

It can ask to pay. It cannot approve its own payment, it cannot change its own limits, and it never holds the thing that moves the money.

Request: Pay compute.example $4,200
Answer: No
Why: Only $50 of this budget can go to payments that cannot be reversed. It is already used.
Record: Kept. Anyone can check it.

The refusal comes back as a reason your agent can read and act on, not as an error code it will retry forever.

Run it yourself, if that is what your rules require.

The whole thing runs in your own infrastructure, with the record staying on your side of the line. Some of the companies we talk to cannot do it any other way, and that is a fine way to start.

Ask for access→