General Liquidity

An applied research lab building the interface to the machine economy.

generalliquidity.com · Documentation · contact@generalliquidity.com

The economy is being handed to actors that are not people. Agents are about to hold budgets, sign for value, and act on standing mandates, transacting at machine speed against counterparties they have never met.

Fabric's essay on the machine economy gets the shape right: compute, models, and programmable money converge until agents become economic actors rather than tools. Its sharpest observation is that once capability is abundant, "the scarce and therefore precious resource is no longer capability, it becomes direction."

We part company on what follows. That essay treats the question of who directs the flywheel as political and philosophical rather than an engineering one. It is both, and the engineering half is the part nobody is building. Direction has to live somewhere concrete: delegated, bounded, priced, and refusable. In practice that somewhere is a single API call, made by an agent, at machine speed, with no human watching it happen. Governance that cannot be enforced inside that call is not governance. It is a policy document.

Agent commerce is being assembled one layer at a time: who the agent is, what it is allowed to do, what is being bought, how the money moves, how agents coordinate, and what record is left behind. Each layer has its own standards and its own companies.

Very little carries a single decision across all of them, and that is exactly where agent transactions break. A limit agreed at the identity layer means nothing if the payment layer cannot see it. A receipt proving settlement does not prove the purchase was authorised.

So we build the vertical: one governed surface over identity, permission, commerce, payments, coordination, and records, where an agent states an intent and a mandate decides whether it becomes an action. We connect to the standards being built for this rather than replacing them, so nobody has to bet on which one wins. Cards, bank transfers, stablecoins, and per-call payments settle through the same decision and produce the same receipt.

The agent never holds the settle primitive. It can ask to pay. It cannot approve its own payment, change its own limits, or move money itself. Every enforcement decision is falsifiable after the fact, by anyone, offline.

Moving the money is the easy part. An agent transaction has to be refusable.

• Limits travel with the work and only ever narrow.
• Payments that cannot be reversed need a bound a mistake cannot cross.
• Some requests need a person, and the system has to know which.
• The useful answer is often no. A system that cannot say it is not one you should hand a budget to.

One governed surface over identity, permission, commerce, payments, coordination and records. The spec is the source of truth and every client is generated from it, so a client cannot drift from the contract.

Repository	Description	Stars	Issues	PRs
OpenAPI spec	The OpenAPI 3.1 contract for the governed payment surface, the source of truth every client pins to. It states who is allowed to move value, on which rail, under what mandate, and what proof comes back.
TypeScript SDK	The hand-written TypeScript client: an agent signs and submits a payment intent and never holds a settle primitive, with a built-in operator signer for approvals, refunds, and the kill switch.
Python SDK	The Python client for the same governed surface, generated from the spec so it cannot drift from the contract.
Go SDK	The Go client for the governed surface, for backends and infrastructure that already speak Go.
Rust SDK	The Rust client for the governed surface, for services that want the contract enforced at compile time.
MCP server	The payment surface as agent tools over the Model Context Protocol: resolve a counterparty, pay under a mandate, verify a disclosure, and disclose the agent's own identity. It can ask to pay; it cannot approve its own payment.
gl CLI	The operator command line: replay an audit log against a candidate mandate to see what it would have changed, and verify a signed chain offline.

Where the work started. Trading was the proving ground for delegated financial action, and the harness pattern the API now uses came out of it. All three remain public and maintained; none of them is where the company is pointed.

Repository	Description	Stars	Issues	PRs
Gordon	A plan-first trading agent. You state intent in plain language, it drafts a structured plan, you approve it, and a deny-first risk harness gates every order before it reaches a venue. MIT, local-first, no account.
SharpeBench	A benchmark that refuses to reward luck. It scores agents on the Sharpe ratio that survives deflation for the number of strategies tried, and asks them to commit before the evaluation window so a result cannot be fit after the fact.
SharpeArena	A point-in-time market environment for training and evaluating trading agents without lookahead leakage. Every scenario is reconstructed from a seed so runs stay reproducible, with a language-agnostic contract agents speak.