Operations

90 operations. Each is one row of the contract: its HTTP route, CLI command, MCP tool and SDK method are renderings of the row, and surface_drift fails check when a surface strays from it.

Beyond the codes its row names, every call can answer the ones its kind meets, by one rule: a call a key makes, key_missing and key_invalid; a POST or PUT, body_invalid; a call idempotent with a key, key_reused; a person's call, when a key makes it, needs_a_person; a party's call, when a key makes it, needs_the_party; and every call, version_unknown and api_error.

Each credential, code, event and object links to its reference the first time this page names it.

What several calls take word for word, said once: each of them names it under its own row.

service.order#

Order a job, or get the offer: the price and the exact next call. A Service whose price has every answers a subscription, sbn_….

Also served at POST /:service.

Who may call: sk_test_, sk_live_, dlg_, tk_ · effect: act · gate: access · idempotent: with a key · returns: job

Emits job.ordered, charge.held · Can answer OFFER, input_invalid, policy_invalid, key_reused, not_found, not_live, act_refused, region_not_ratified, brand_unverified, period_taken

$ curl -X POST http://localhost:8787/jobs -H 'content-type: application/json' -d '{"service":"certified-translation","document":{"url":"https://example.com/lease.pdf","name":"lease.pdf"},"to":"fr","country":"FR","max_usd":189,"key":"lease-fr-3"}'

Explained in Your first paid job, How a job runs, Your API, A buyer that is software

service.quote#

Read a Service as JSON, keyless; past the buyer key's cap, the checkout offer.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: service

Can answer OFFER

$ curl http://localhost:8787/translation.json   # input: the Service's own fields, each by its type word

Explained in Your API

service.waitlist#

Join the waitlist of a Service that takes no orders yet: the next a not_live answer names.

Who may call: anyone · effect: record · gate: none · idempotent: yes · returns: waitlist

Can answer input_invalid, not_found

→ POST /contract-review/waitlist {"email":"ada@example.com"}   # the next the refusal named

Explained in Publish before it takes orders

service.list#

Every Service, keyless: its price, when it charges and whether it takes orders yet, and the metering rule every Service keeps: no record, no charge.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: list

service.get#

One Service of the catalog, keyless, by its id: its price, when it charges and its status.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: service

Can answer not_found

job.get#

Read a job, now or after waiting up to wait seconds while it works or waits on a person. Waiting on a party, it answers at once with the link to hand them.

Who may call: sk_test_, sk_live_, dlg_, tk_ · effect: read · gate: access · idempotent: yes · returns: job

Can answer not_found

$ curl http://localhost:8787/jobs/job_0000

Explained in The job lifecycle, Your API

job.wait#

Wait up to 50 seconds for a job to finish, through any person's line.

Who may call: sk_test_, sk_live_, dlg_, tk_ · effect: read · gate: access · idempotent: yes · returns: job

Can answer not_found

$ curl http://localhost:8787/jobs/job_7Hq2?wait=50

Explained in Your first paid job, A buyer that is software

job.list#

The buyer's jobs, newest first: OK, or EMPTY when none match.

Also served at GET /owner/jobs.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: list

Can answer input_invalid, needs_a_person

Also takes limit, starting_after, as the calls that share it do.

$ curl 'http://localhost:8787/jobs?limit=10'

Explained in Conventions, The customer portal

job.accept#

Accept a delivered job. It is final; a job nobody accepts is final 7 days after delivery.

Who may call: sk_test_, sk_live_, dlg_ · effect: act · gate: access · idempotent: yes · returns: job

Emits job.accepted, charge.earned, charge.released · Can answer not_found, not_delivered, needs_the_party

$ curl -X POST http://localhost:8787/jobs/job_7Hq2/accept -H 'content-type: application/json' -d '{}'

Explained in Your first paid job, A buyer that is software

job.send_back#

Send a job back with a note, and the AI redoes it: a delivered one as the buyer, a waiting one as the person at the line.

Also served at POST /:portal/jobs/:id/send_back, POST /jobs/:id/send-back, POST /:portal/jobs/:id/send-back.

Who may call: sk_test_, sk_live_, dlg_, owner session, member session · effect: act · gate: access · idempotent: with a key · returns: job

Emits job.sent_back, job.canceled, charge.voided, charge.refunded · Can answer not_found, not_delivered, not_waiting, nothing_to_redo

Also takes key, as the calls that share it do.

job.cancel#

Cancel a job before delivery. The buyer pays $0.

Who may call: sk_test_, sk_live_, dlg_ · effect: act · gate: access · idempotent: yes · returns: job

Emits job.canceled, charge.voided, charge.refunded · Can answer not_found, not_cancelable

job.end#

End a job at one of its ends, as that end's by allows. An end is forever.

Also served at POST /owner/jobs/:id/end.

Who may call: sk_test_, sk_live_, dlg_, owner session · effect: act · gate: access · idempotent: yes · returns: job

Emits job.ended, charge.collected, charge.earned, charge.released, charge.refunded, charge.voided · Can answer not_found, end_not_allowed

→ POST /jobs/job_7Hv5/end {"end":"withdrawn","reason":"The client withdrew."}

Explained in How a job ends

job.again#

Order an ended job again, or a follow-on Service its end offers: a new job, with from on its record.

Who may call: sk_test_, sk_live_, dlg_ · effect: act · gate: access · idempotent: with a key · returns: job

Emits job.ordered, charge.held · Can answer OFFER, not_found, not_terminal, input_invalid, policy_invalid, not_live, period_taken

→ POST /jobs/job_7Hq6/again

Explained in How a job ends

job.policy#

Set a job's policy values within their bounds: mechanics from the buyer or the brand's console, merits from the client alone.

Also served at POST /owner/jobs/:id/policy.

Who may call: sk_test_, sk_live_, dlg_, owner session · effect: record · gate: access · idempotent: yes · returns: job

Emits policy.set · Can answer not_found, policy_invalid, merits_not_yours, job_ended

→ POST /owner/jobs/job_7Hq2/policy {"policy":{"match":0.7}}

Explained in What the buyer sets, and what only the client sets

job.signal#

Raise one of the Service's inbound signals. A signal never blocks; its goto moves the job.

Who may call: sk_test_, sk_live_, dlg_ · effect: record · gate: access · idempotent: with a key · returns: job

Emits signal.raised · Can answer not_found, input_invalid, job_ended

Also takes key, as the calls that share it do.

→ POST /jobs/job_7Hq2/signals {"signal":"source_changed"}

Explained in Signals

job.message#

Say something in the job's thread as the client. The AI answers at once, or holds advice a rules row reserves until a member adopts it.

Who may call: sk_test_, sk_live_, dlg_ · effect: record · gate: access · idempotent: with a key · returns: message

Emits thread.posted, message.sent, message.held · Can answer not_found, input_invalid, job_ended, talk_off

Also takes key, as the calls that share it do.

→ POST /jobs/job_7Hq2/messages {"text":"Will it read formal or informal?"}

Explained in Talk

job.thread#

Read the job's messages, oldest first: one resource with the posts. Held advice reads 'A professional is reviewing this answer.' until a member adopts it.

Who may call: sk_test_, sk_live_, dlg_ · effect: read · gate: access · idempotent: yes · returns: list

Can answer not_found, talk_off

Explained in Talk

job.record#

A job's record as you may read it, oldest first: a key reads the buyer's events of it, the owner the whole record. type=attested keeps the attestations: each step a person attested, under the rules version it pinned.

Also served at GET /owner/jobs/:id/record.

Never on MCP. An agent reads the same events with get_job's expand[]=timeline.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: list

Can answer not_found, input_invalid

job.approve#

Approve, sign or do a job waiting on a person: a proposal the gate commits or refuses, as it does the AI's. A key or a tool never can.

Also served at POST /jobs/:id/approve, POST /jobs/:id/sign, POST /owner/jobs/:id/approve.

Who may call: owner session, member session · effect: act · gate: person · idempotent: yes · returns: job

Emits step.proposed, step.committed, step.refused, ask.opened · Can answer not_found, not_waiting, needs_a_person, needs_grant, needs_the_party, guard_refused, end_not_allowed, input_invalid

→ POST /sworn-translators/jobs/job_7Hq2/approve

Explained in human: the line, Refusals and cures, What an agent can never do

job.export#

One job's evidence bundle: its record, every file it holds with its sha256, and what the record replays to.

Also served at GET /owner/jobs/:id/export.

Who may call: owner session · effect: read · gate: access · idempotent: yes · returns: evidence

Can answer not_found

$ curl http://localhost:8787/owner/jobs/job_7Hq2/export   # each artifact's text left out

job.ledger#

One job, as the owner reads it: its whole record, its ledger, and what it left the brand.

Who may call: owner session · effect: read · gate: access · idempotent: yes · returns: ledger

Can answer not_found

$ curl http://localhost:8787/owner/jobs/job_7Hq2   # 2026-10-31: a day before the link expires

Explained in The owner console, The money, The money

member.join#

Join a Pool, email first and resumable: each call takes the answers it brings, one step of the application at a time, and once it's whole the verifier runs. The owner adds a member the same way.

Who may call: member session, owner session · effect: record · gate: person · idempotent: yes · returns: member

Emits member.applied · Can answer not_found, input_invalid

→ POST /attorneys/join {"email":"grace@hopper.example","answers":{"name":"Grace Hopper","credential":"patent agent","number":"71,234","regions":["US-CA"],"areas":["patents"],"hours":10,"turnaround":"24h","min_fee":120}}   # the applicant, in one call

member.verify#

The verifier writes what is true of a member: each credential and its regions, and coverage in force. It is the only writer of verified facts, on its own write path with its vt_ token, and every write joins the member's recheck journal.

Who may call: vt_ · effect: record · gate: access · idempotent: yes · returns: member

Can answer not_found, input_invalid

→ POST /attorneys/members/mbr_7Hq2/verify {"facts":{"credentials":{"bar admission":["US-CA"]},"coverage":{"per_act":1000000,"until":"2026-10-01T00:00:00Z"}}}

member.availability#

Set your availability: on, off or away. Only a member who is on is offered work.

Who may call: member session · effect: record · gate: person · idempotent: yes · returns: member

Can answer input_invalid

member.ledger.get#

Read your conflicts ledger: hashes only, salted with your id, never pooled and never seen by the brand.

Who may call: member session · effect: read · gate: person · idempotent: yes · returns: list

→ GET /me/ledger   # the owner console, with no member session

member.ledger.add#

Add a party to your conflicts ledger: its name, email and organization are each hashed before anything is kept. A Task's parties are checked against it, mechanically.

Who may call: member session · effect: record · gate: person · idempotent: yes · returns: list

Can answer input_invalid

→ POST /me/ledger {"name":"Initech","org":"Initech Inc"}   # as mbr_eligible

member.ledger.checks#

Every check of your conflicts ledger: the Task it ran for, when, how many parties, and whether one matched. You see every one, and no one else sees any.

Who may call: member session · effect: read · gate: person · idempotent: yes · returns: list

member.missed#

The open Tasks your own declarations kept from you, each naming the one (your minimum fee, your areas, your hours), and never one eligibility kept from you; with the last 30 days of your Pool, in a line.

Who may call: member session · effect: read · gate: person · idempotent: yes · returns: list

member.earnings#

Your pay, act by act: when each accrued, when it is payable, the payout that moved it, and a line per brand. One payout account across every Pool and brand.

Who may call: member session · effect: read · gate: person · idempotent: yes · returns: list

Explained in Pay

member.track#

Your track record, yours to carry: your counts per Pool and brand, with each Task's hash, signed by the door and naming no party.

Who may call: member session · effect: read · gate: person · idempotent: yes · returns: track_record

Explained in Track records

member.subjects#

The subjects where you are of record: you stay of record across jobs until you withdraw.

Who may call: member session · effect: read · gate: person · idempotent: yes · returns: list

Explained in Of record

member.login#

Mint a member's own session on localhost, for the printed link and members login. Elsewhere it is their passkey's.

Who may call: owner session · effect: record · gate: person · idempotent: yes · returns: session

Can answer not_found

task.list#

Your feed: every open Task offered to you that you can take, newest first, as teasers. The owner console reads every Task.

Also served at GET /owner/tasks.

Who may call: member session, owner session · effect: read · gate: person · idempotent: yes · returns: list

task.get#

Read a Task's teaser: its teaser fields, the estimate, the rate and when it's due. Never a party name.

Also served at GET /owner/tasks/:id.

Who may call: member session, owner session · effect: read · gate: person · idempotent: yes · returns: task

Can answer not_found, task_taken

task.sheet#

Read a Task's sheet: the teaser, its sheet fields with the parties, and what you attest to clear it. One member at a time, and every view is logged.

Who may call: member session · effect: record · gate: person · idempotent: yes · returns: sheet

Can answer not_found, ineligible, task_taken

task.pass#

Pass on a Task: free, with an optional reason, counted against the Task and never against you. Under cascade it goes to the next member at once.

Who may call: member session · effect: record · gate: person · idempotent: yes · returns: task

Emits task.offered · Can answer not_found, task_taken

task.claim#

Claim a Task: the eligibility predicates run in order, and it is held for you until the Pool's hold runs out.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits task.claimed · Can answer not_found, ineligible, task_taken

→ POST /tasks/tsk_7Hq2/claim

task.clear#

Clear a held Task: the conflict check runs again, and you attest each statement on its sheet. The packet opens, and the job waits on you.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits job.paused, task.offered · Can answer not_found, ineligible, task_taken

task.packet#

Read a cleared Task's packet: the summary, the AI's artifacts and their diff, the review reports, the checklist, the record, the signals, the clock and the hash you attest.

Who may call: member session · effect: read · gate: person · idempotent: yes · returns: packet

Can answer not_found, not_cleared

task.release#

Give a held Task back before it is done: it opens again at the fee it was posted at, and the dispatch runs on.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits job.paused, task.offered · Can answer not_found, task_taken

Explained in What a person can do

task.offer#

Name the member a Task goes to: the owner's pick, a direct, or an override of any dispatch. They must be eligible.

Who may call: owner session · effect: act · gate: person · idempotent: yes · returns: task

Emits task.offered · Can answer not_found, ineligible, task_taken, input_invalid

task.arrive#

Check in at a work-register Task's site: the device's fix must fall inside the Pool's site radius, between its early and late marks around the window. Counted, it reads on_site.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Can answer not_found, task_taken, not_on_site

→ POST /tasks/tsk_7Hq2/arrive {"fix":{"lat":48.8556,"lng":2.3605,"accuracy_m":12}}   # as mbr_eligible, 3 Nov 13:56

Explained in A Pool's register

task.complete#

Complete a work-register Task you are on site for: every evidence item the step names, each stamped with time and place and hashed together, for the gate to commit. Paid per completed Task.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits step.proposed, step.committed, step.refused, pay.accrued · Can answer not_found, not_on_site, evidence_missing, input_invalid, job_ended

→ POST /tasks/tsk_7Hq2/complete {"check_out":{"fix":{"lat":48.8557,"lng":2.3604,"accuracy_m":10}},"sign_off":"ask_7Hq4"}   # as mbr_eligible, 3 Nov 15:04

Explained in A Pool's register

task.attest#

Attest the Task you claimed and cleared: your proposal, for the gate to commit, freezing who, the credential, where, the hash and the rules on the record. With reservation, qualified: it travels with the output. Paid.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits step.proposed, step.committed, step.refused, pay.accrued, message.adopted, message.sent · Can answer not_found, not_cleared, guard_refused, needs_a_person, needs_direction, reserved, input_invalid, end_not_allowed

→ POST /tasks/tsk_7Hq2/attest

Explained in What a person can do

task.send_back#

Send the work back with its defects: paid, and the job returns to the step you name, by default the one before. That work is redone and the step posts a new Task.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits job.sent_back, pay.accrued · Can answer not_found, not_cleared, defects_required, input_invalid, job_ended

Explained in What a person can do

task.decline#

Decline the Task, with a reasoned memo only the client reads: paid and never scored. The job waits on the client's direction: another member, or an end.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits task.declined, pay.accrued, job.paused, ask.opened · Can answer not_found, not_cleared, memo_required, job_ended

Explained in What a person can do, Declines and direction

task.recuse#

Step aside from a Task you hold, for a conflict: nothing accrues and nothing is scored, and it reopens at once. The parties you name join your own ledger, and you are screened from every Task on the subject. The client reads that a professional stepped aside, never why.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits task.recused, job.paused, task.offered · Can answer not_found, task_taken, input_invalid, job_ended

Explained in What a person can do

task.extend#

Extend your hold on a Task, once: by as long again as it first held, never past its due date.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: task

Emits task.extended · Can answer not_found, task_taken, input_invalid

Explained in What a person can do

task.contest#

Contest a send-back your attested work received, with a reason. A peer with the same credential rules it on a reserved act; staff rule the rest.

Also served at POST /owner/tasks/:id/contest.

Who may call: member session, owner session · effect: record · gate: person · idempotent: yes · returns: task

Emits task.contested, task.ruled · Can answer not_found, not_contestable, input_invalid

Explained in What a person can do, Track records

task.message#

Reach the client through the job's thread, by kind: a question (an answer ask that pauses your hold and the step's clock until they reply), a note (no reply expected), or a flag (a named signal the owner sees, which never blocks). Their email and phone never reach you, nor yours them.

Who may call: member session · effect: record · gate: person · idempotent: with a key · returns: message

Emits ask.opened, thread.posted, job.paused, signal.raised · Can answer not_found, not_cleared, input_invalid, question_open, job_ended, talk_off

Also takes key, as the calls that share it do.

Explained in Talk, What a person can do

subject.list#

The subjects your jobs joined: each one keyed by an input or a receipt, with its jobs and who is of record on it.

Also served at GET /owner/subjects.

Never on MCP. An agent reads a subject's clocks with list_clocks and get_clock; the subject itself is the buyer's record, read over HTTP and the CLI.

Never on SDK. The SDK reads a subject's clocks with clocks.list() and clocks.get(); the subject itself is the buyer's record, read over HTTP and the CLI.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: list

Can answer input_invalid

Takes limit, starting_after, as the calls that share it do.

subject.get#

Read a subject: its key, every job that touched it, its insert-only history, its kept facts with every value and the job that wrote it, its periods, and who is of record, or that the seat is vacant and who covers it.

Also served at GET /owner/subjects/:id.

Never on MCP. An agent reads a subject's clocks with list_clocks and get_clock; the subject itself is the buyer's record, read over HTTP and the CLI.

Never on SDK. The SDK reads a subject's clocks with clocks.list() and clocks.get(); the subject itself is the buyer's record, read over HTTP and the CLI.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: subject

Can answer not_found

→ GET /subjects/sbj_7Hq2

subject.withdraw#

Withdraw as the member of record, naming your successor: a member who holds the role's credential takes the seat.

Who may call: member session · effect: act · gate: person · idempotent: yes · returns: subject

Can answer not_found, input_invalid

Explained in Of record

clock.list#

The clocks your jobs and their subjects run: each one's date, who answers for it, its rungs and where it stands. A member reads the ones they answer for.

Also served at GET /owner/clocks.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session, member session · effect: read · gate: access · idempotent: yes · returns: list

Can answer input_invalid

Also takes limit, starting_after, as the calls that share it do.

→ GET /clocks   # in mbr_eligible's own session

Explained in Clocks

clock.get#

Read a clock: its date, who answers for it, each rung and when it falls due, what moved it, and at its date the owner's options.

Also served at GET /owner/clocks/:id.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session, member session · effect: read · gate: access · idempotent: yes · returns: clock

Can answer not_found

→ GET /clocks/clk_7Hq2

Explained in Clocks

clock.ack#

Acknowledge a clock you answer for: inside its ack daily window, the day's acknowledgement, so the day is never missed. Only its owner can.

Also served at POST /owner/clocks/:id/ack.

Never on MCP. Only a clock's owner acts on it, with their own key or in their own app: an agent reads it with get_clock, and a call from anyone else answers needs_the_owner with the owner's app as next.hand_to_person.

Who may call: sk_test_, sk_live_, dlg_, owner session, member session · effect: record · gate: person · idempotent: with a key · returns: clock

Emits clock.acked · Can answer not_found, needs_the_owner, clock_closed, clock_moved_on

Takes due, key, as the calls that share it do.

→ POST /clocks/clk_7Hq4/ack {}   # in mbr_eligible's own session

Explained in Clocks

clock.satisfy#

Close a clock you answer for, on evidence on the record: a file you send, or a receipt or file the job holds. A recurring clock rolls on to its next date.

Also served at POST /owner/clocks/:id/satisfy.

Never on MCP. Only a clock's owner acts on it, with their own key or in their own app: an agent reads it with get_clock, and a call from anyone else answers needs_the_owner with the owner's app as next.hand_to_person.

Who may call: sk_test_, sk_live_, dlg_, owner session, member session · effect: act · gate: person · idempotent: yes · returns: clock

Emits clock.satisfied, clock.recurred, clock.rolled · Can answer not_found, needs_the_owner, evidence_required, evidence_used, clock_closed, clock_moved_on

Also takes due, as the calls that share it do.

→ POST /owner/clocks/clk_7Hq3/satisfy {}

Explained in Clocks

clock.choose#

Choose one of a clock's lapse options at its date, unsatisfied, and the clock closes. A step's name runs that step, through the gate.

Also served at POST /owner/clocks/:id/choose.

Never on MCP. Only a clock's owner acts on it, with their own key or in their own app: an agent reads it with get_clock, and a call from anyone else answers needs_the_owner with the owner's app as next.hand_to_person.

Who may call: sk_test_, sk_live_, dlg_, owner session, member session · effect: act · gate: person · idempotent: yes · returns: clock

Emits clock.chosen, step.committed · Can answer not_found, needs_the_owner, clock_not_due, clock_closed, clock_moved_on, input_invalid, job_ended

Also takes due, as the calls that share it do.

Explained in A date the world sets, Clocks

clock.assign#

Assign the member who answers for a clock, and it has an owner again: one who holds its role's credential, or for the brand's clock a member of its Pools.

Also served at POST /clocks/:id/assign.

Who may call: owner session · effect: act · gate: person · idempotent: yes · returns: clock

Emits clock.assigned · Can answer not_found, ineligible, clock_closed, input_invalid

→ POST /owner/clocks/clk_7Hq2/assign {"member":"mbr_eligible"}

Explained in Clocks, Dates at risk

subscription.list#

Your subscriptions: each one's cycle, its allowances used and included, what it mints next, and the jobs it minted.

Also served at GET /owner/subscriptions.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: list

Can answer input_invalid

Also takes limit, starting_after, as the calls that share it do.

Explained in Schedules and triggers

subscription.get#

Read a subscription: its cycle's start and end, each allowance used of included, each schedule date and when it next mints, each event it listens for, its charges, and every job it minted, offered or was refused.

Also served at GET /owner/subscriptions/:id.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: subscription

Can answer not_found

$ curl http://localhost:8787/subscriptions/sbn_7Hq2

Explained in Schedules and triggers

subscription.cancel#

Cancel a subscription: it runs to the end of the cycle paid for, never renews, and nothing mints after. Twice changes nothing.

Also served at POST /owner/subscriptions/:id/cancel.

Who may call: sk_test_, sk_live_, dlg_, owner session · effect: act · gate: access · idempotent: yes · returns: subscription

Emits subscription.canceled · Can answer not_found

$ curl -X POST http://localhost:8787/subscriptions/sbn_7Hq2/cancel

Explained in Schedules and triggers

ask.get#

Read an ask: its party, what it asks, its status and expiry, its items, and its link while it is open.

Who may call: party link, owner session · effect: read · gate: party · idempotent: yes · returns: ask

Can answer not_found

$ curl http://localhost:8787/asks/ask_7Hq2

ask.complete#

The party acts, through their own link: answer, upload, sign, consent, decide, or decline. An agent holding their delegated key may answer and upload; nothing else may act for them.

Who may call: party link · effect: act · gate: party · idempotent: with a key · returns: ask

Emits item.done, ask.done, consent.given, grant.given, ask.voided, ask.opened, step.proposed, step.committed, step.refused, job.canceled, job.ended, charge.voided, charge.collected, charge.earned · Can answer not_found, needs_the_party, ask_expired, ask_voided, signature_void, input_invalid

→ POST /asks/ask_7Hq3?t=… {"answer":"Yes, signed on 1 March. Text me at (415) 555-0199."}

ask.revoke#

The party revokes a grant they gave, through their own link: it stops being live at once, and a step that needs it is refused needs_grant until they grant it again. No key, delegated or not, revokes it for them.

Who may call: party link · effect: act · gate: party · idempotent: yes · returns: ask

Emits grant.revoked · Can answer not_found, needs_the_party, input_invalid

→ POST /asks/ask_7Hq3/revoke   # x-services-test-dlg: dlg_test_4Rb1

Explained in Grants and decisions

ask.reissue#

Reissue an open ask's link, to hand to its party again. The old one stops working at once.

Also served at POST /asks/:id/link.

Who may call: sk_test_, sk_live_, dlg_, owner session · effect: record · gate: access · idempotent: with a key · returns: ask

Emits ask.relinked · Can answer not_found, ask_expired, ask_voided

Takes key, as the calls that share it do.

$ curl -X POST http://localhost:8787/asks/ask_7Hq2/reissue -H 'content-type: application/json' -d '{}'

job.files.list#

The files a job holds, each by its sha256: the ones sent in, each step's artifacts and each receipt's file.

Never on MCP. A file is bytes: send it over HTTP or the SDK, and name it by URL in an order.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: list

Can answer not_found

job.files.put#

Put a file in a job's documents plane under its own sha256, or POST it and the brand hashes it. The same file sent twice is stored once.

Also served at POST /jobs/:id/files.

Never on MCP. A file is bytes: send it over HTTP or the SDK, and name it by URL in an order.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: record · gate: access · idempotent: yes · returns: file

Can answer not_found, input_invalid

Explained in Sending to outside systems

job.files.get#

Read a file a job holds, by its sha256: one sent in, a step's artifact, or a receipt's file.

Never on MCP. A file is bytes: send it over HTTP or the SDK, and name it by URL in an order.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: bytes

Can answer not_found

$ curl http://localhost:8787/jobs/job_7Hq2/files/82d85d1a577fa13c7b2b5949e8b1aea6e5f307e492ad3a279c7618ab8cbb6956   # the receipt's file, by its sha256

Explained in Sending to outside systems

key.create#

Get a test key: on localhost, the one dev printed, with its cap. Every call it makes is in the sandbox, and a live key is a person's to make, at checkout.

Who may call: anyone · effect: record · gate: none · idempotent: yes · returns: key

key.raise#

A person raises the buyer key's cap, at checkout.

Who may call: party link · effect: act · gate: party · idempotent: with a key · returns: text

test_clock.create#

Make a test clock frozen at a time. An order attaches to it with test_clock, and nothing on it moves until you advance it.

Who may call: sk_test_, owner session · effect: record · gate: access · idempotent: with a key · returns: test_clock

Can answer input_invalid

Also takes key, as the calls that share it do.

→ POST /test_clocks {"frozen_at":"2026-10-25T14:02:11Z"}

test_clock.advance#

Move a test clock to a time, or by a span: every job on it fires what falls due, in time order across jobs. Moving it where it has been fires nothing.

Who may call: sk_test_, owner session · effect: act · gate: access · idempotent: yes · returns: advance

Emits ask.reminded, ask.expired, ask.opened, ask.voided, grant.expired, signal.raised, receipt.timed_out, job.at_risk, job.late, clock.opened, clock.unopened, clock.noticed, clock.escalated, clock.ack_due, clock.ack_missed, clock.ran, clock.moved, clock.due, clock.satisfied, clock.recurred, clock.rolled, clock.vacant, job.accepted, job.ended, job.canceled, charge.earned, charge.released, charge.voided · Can answer not_found, input_invalid, clock_behind, clock_advancing

→ POST /test_clocks/default/advance {"to":"30h"}   # past the 24h hold

event.list#

The brand's events after a seq, in order, as the caller's audience sees them: a key reads the buyer's rows, the owner reads everything.

Also served at GET /owner/events.

Who may call: sk_test_, sk_live_, dlg_, tk_, owner session · effect: read · gate: access · idempotent: yes · returns: list

Can answer input_invalid

$ curl 'http://localhost:8787/events?after=0&limit=2'

Explained in Conventions, Your events

event.stream#

The brand's events, pushed as they happen over server-sent events, from a seq or the Last-Event-ID; with watch=, that watch's deliveries.

Never on MCP. A stream, not a call: an agent reads list_events after a seq, or job:// for one job.

Who may call: sk_test_, sk_live_, dlg_, tk_ · effect: read · gate: access · idempotent: yes · returns: stream

Can answer input_invalid, not_found

→ GET /events/stream   # held open, and nothing else is read

event.inbound#

Send an event in: a job's inbound signal by name; an event a subscription listens for, which mints the Service it routes to; or, on a test key, a synthetic event of the catalog, fired to its audience like any other.

Who may call: sk_test_, sk_live_, dlg_, tk_ · effect: record · gate: access · idempotent: with a key · returns: event

Emits signal.raised, subscription.minted, allowance.used, allowance.exceeded · Can answer input_invalid, event_id_required, not_found, job_ended

Also takes key, as the calls that share it do.

→ POST /events {"type":"page.changed","id":"page-1","data":{"site":"acme.example","document":"page-1.html"}}

Explained in Schedules and triggers

watch.create#

Watch events at a URL: each delivery is signed with the watch's whsec_ secret, shown once, and retried with backoff for three days.

Never on MCP. A watch delivers to a URL your server holds, which an agent's session doesn't: it reads list_events after a seq instead.

Who may call: sk_test_, sk_live_ · effect: record · gate: access · idempotent: with a key · returns: watch

Can answer input_invalid

Also takes key, as the calls that share it do.

$ curl -X POST http://localhost:8787/watches -H 'content-type: application/json' -d '{"url":"https://hooks.example.test/lingua","events":["job.delivered"]}'

Explained in Your events

watch.list#

The watches this key holds, with their deliveries.

Never on MCP. A watch delivers to a URL your server holds, which an agent's session doesn't: it reads list_events after a seq instead.

Who may call: sk_test_, sk_live_ · effect: read · gate: access · idempotent: yes · returns: list

Can answer input_invalid

Takes limit, starting_after, as the calls that share it do.

watch.delete#

Stop a watch. Deliveries still retrying stop with it.

Never on MCP. A watch delivers to a URL your server holds, which an agent's session doesn't: it reads list_events after a seq instead.

Who may call: sk_test_, sk_live_ · effect: record · gate: access · idempotent: yes · returns: watch

Can answer not_found

watch.replay#

Deliver to a watch again every event it covers after a seq, in order.

Never on MCP. A watch delivers to a URL your server holds, which an agent's session doesn't: it reads list_events after a seq instead.

Who may call: sk_test_, sk_live_ · effect: act · gate: access · idempotent: with a key · returns: replay

Can answer not_found, input_invalid

Also takes key, as the calls that share it do.

brand.home#

The brand's home, as JSON and as Markdown: its name, what it sells and where to start. GET / is its page.

Also served at GET /index.md.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: home

brand.health#

Whether the brand answers: OK, with its version and how many Services it serves.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: health

brand.card#

The brand's agent card: its Services, its access ladder, tools, links and probes.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: card

→ GET /.well-known/agents.json

Explained in Machine registers

brand.openapi#

Every operation, as OpenAPI 3.1, with its webhooks.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: openapi

$ curl http://localhost:8787/openapi.json   # one path item and one webhook, whole

Explained in Machine registers

brand.llms#

What an agent reads first: the Services, and every operation.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: text

Explained in Machine registers

brand.manifest#

Every Service, as the manifest.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: manifest

$ curl http://localhost:8787/manifest.json

Explained in The manifest

brand.pricing#

The pricing document: calls are free, and only an order charges, at its Service's price. Every price, and the buyer key's hard ceiling.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: pricing

$ curl http://localhost:8787/pricing

Explained in Machine registers

brand.verify#

The brand's conformance suite: one case per operation row, live credential and magic value, with its auth, audience, replay and next cases, over HTTP and MCP. services.dev verify runs it.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: suite

$ curl http://localhost:8787/verify/suite.json

Explained in Your conformance suite

receipt.answer#

An outside system's verdict on a filing it took as transmitted, sent later by it or by your own poller: accepted, accepted with alerts, or rejected with its codes.

Who may call: owner session · effect: act · gate: access · idempotent: with a key · returns: receipt

Emits receipt.accepted, receipt.rejected · Can answer not_found

sandbox.fixtures#

The sandbox's magic values: where each goes, the branch it takes, and its status. Each works on a test key.

Who may call: anyone · effect: read · gate: none · idempotent: yes · returns: list

The calls the owner runs a live Service with, from the console, the CLI or a coding agent, each explained on its Operate page: