The market is solving the opposite problem

Software is learning to do legal work. It can research, draft, analyze and assemble legal artifacts, and it gets better at all four every quarter. What it still can't do is get a lawyer at the moment judgment, a credential, authority or representation becomes necessary.

That moment is where the workflow breaks. We think it should be where the workflow makes a call.

Two different questions

The first generation of legal AI asks a good question: how can AI help lawyers do legal work? Put AI inside the law firm. The lawyer is the operator, and AI accelerates the research, the drafting and the analysis.

api.lawyer asks the opposite question: how can software access lawyers? Put lawyers inside the AI. Software is the operator, and a qualified professional is invoked when the work requires one.

Both are real markets. They are not the same product, and they don't compete for the same moment. One makes a firm faster. The other makes legal capability something a product can call.

Where the workflow breaks today

Here is the shape of almost every AI legal workflow in production:

1. The software drafts and analyzes.
2. It reaches a boundary and says "consult a lawyer."
3. The user leaves, searches, and starts over somewhere else.

Step 3 is a dead end, and it is the most expensive step in the flow: everything the software learned stays behind when the user walks out.

With api.lawyer, the same flow keeps going:

1. The software drafts and analyzes.
2. It requests the capability it needs.
3. An independent professional judges and acts.
4. The software continues with the result.

The primitive is an action

The missing primitive is not "find me a lawyer." It is an action: review, sign, file, opine. The caller states what it needs done and under what constraints. The infrastructure resolves who can legally and professionally do it, and returns the outcome in a form software can act on.

This is not a lawyer directory, a staffing marketplace or an AI assistant. It is a legal capability layer.

What it looks like today

You can play the whole contract in the sandbox, keyless. An order opens a Matter; the agent runs every stage it may (intake, drafting, an adversarial examiner pass) and then stops at the first reserved act, with a typed state instead of a dead end:

curl -X POST https://api.lawyer/workspacescurl -X POST https://api.lawyer/workspaces/{id}/orders -d '{ … }'

{  "matterId": "m_5",  "status": "waiting_on_signer",  "provenance": {    "environment": "sandbox",    "simulated": true  }}

Ask the Matter to move on before anyone has signed and the Gate refuses, in words your code can log:

{  "error": "Matter m_5 is waiting_on_signer — Gig gig_sandbox_1 is with the network; the Gate commits nothing until the Gig completes"}

When the Signer attests, the Matter moves again. And the money waits for the outcome, not the other way round: settlement answers only once the Matter is fulfilled, because there is nothing to settle before the receipt.

The boundary is the product

For a founder, this reads as a missing API: the step where your product used to lose the user becomes one more call. For a bar-journal editor, it should read as the opposite of erosion. The agent never signs. The reserved act stays reserved, performed by an independent professional under their own license, in their own judgment. The software's job is to get everything ready and get out of the way. api.lawyer is infrastructure, not a law firm.

The north star

Software needs a lawyer. Today that sentence implies a complicated human workflow. Eventually it should imply an API call: an agent reaches the edge of its authority, requests the right professional, hands over everything needed for an informed decision, receives the judgment or the completed work, pays for it, and continues.

Without directories. Without cold calls. Without starting over. Without pretending AI can perform a role that requires a human professional.

That is what we mean by the legal services layer for the agentic economy. You can walk the whole loop in the sandbox or read the docs.