Agents need a legal path into the real world

Agents are taking on real work: research, procurement, contracting, payments, operations. Sooner or later, each of those workflows reaches a moment where something more than intelligence is required: professional judgment, a credential, an approval, a signature, representation.

Intelligence alone doesn't give an autonomous system legal authority. No model upgrade changes that, because it isn't a capability gap. It is how the law allocates the act.

The escalation loop

An agent with a legal path into the real world runs one loop:

1. The agent executes: it researches, drafts, negotiates.
2. It reaches a legal boundary: authority or judgment is required.
3. api.lawyer resolves the capability and the authority the act needs.
4. Qualified counsel acts: reviews, approves, signs, files.
5. A structured result returns: a decision, the authority behind it, the artifact.
6. The agent resumes: continues, executes, records.

The important word is resumes. A boundary that ends the run is a dead end. A boundary that returns a typed state is just another step.

What an agent can use today

It can find the surface on its own. Discovery is keyless, from the first request:

curl https://api.lawyer/.well-known/agents.json

{  "name": "api.lawyer",  "interfaces": {    "http": [      {        "method": "GET",        "url": "…/matters"      }    ],    "mcp": {      "command": "npx api.lawyer mcp serve"    }  }}

It can call it as tools. The published package runs a stdio MCP server with zero dependencies:

{  "mcpServers": {    "api.lawyer": {      "command": "npx",      "args": [        "-y",        "api.lawyer",        "mcp",        "serve"      ]    }  }}

Its advance_matter tool runs one propose, gate, commit turn on a Matter, and when the next act is reserved it returns the typed escalation instead of faking success.

It can dispatch on outcomes, not exceptions. Every typed body carries a type from a closed set (OK, EMPTY, BLOCKED, OFFER), so an agent branches on one field. A reserved act waits as waiting_on_signer while an independent professional does the part only they may do.

It can't overspend. Agents run under a hard spend ceiling you set, and an act that doesn't complete costs nothing: the Meter releases only on the receipt.

It can rehearse without anyone to ask. A keyless sandbox plays the whole contract over synthetic state, including you playing the Signer, so an agent can be tested against both a yes and a no before it ever meets a real one.

The capability surface grows with the network

Escalation is bigger than document review. The acts software may need from a professional fall into four kinds:

• Judgment: review, opine.
• Authority: approve, sign.
• Action: file, notify, negotiate.
• Representation: before a counterparty, a regulator, a court.

Today the reserved acts that run end to end in the sandbox are signatures and filings. The rest of the surface grows as qualified professionals join the network, each one adding capabilities, jurisdictions and response times that weren't callable before.

Where this goes: legal policy as code

Businesses already have rules for when counsel must enter a workflow. In an agentic company, those rules become machine-readable controls:

• A contract under a set value: the agent proceeds within its delegated authority.
• Above it, or with uncapped liability: a professional reviews or approves first.
• An IP assignment, or personal data crossing a border: the matching specialist reviews.

Configure the jurisdictions, the outside-counsel budget, the delegated authority and the escalation triggers once, and the agents operate inside those guardrails, invoking counsel automatically when a threshold is crossed. That points toward persistent counsel, not only one-off requests: a legal control layer for agentic businesses. It is the direction, not a shipped feature, and we'll say so on the day it ships.

The north star

An agent should be able to reach the edge of its authority, request the right licensed professional, provide everything needed for an informed decision, receive the judgment or the completed work, pay for it, and continue its workflow.

Start with the MCP tools, or run the loop in the sandbox.