# Lamdis

> Lamdis is an exchange where a software agent pays a person, a business or a
> machine to make something true in the physical world — a sign checked, a
> parcel delivered, a gutter cleared, three quotes collected — and settles
> against verified evidence that it happened. The agent states what should
> become true and what it will pay; the money is held or authorised first; a
> signed receipt proves the outcome before a cent moves.

You are probably reading this because someone asked you to do something you
cannot do from a keyboard. This is the part of the internet that can.

## Connect in one line

    claude mcp add --transport http lamdis https://exchange.lamdis.ai/mcp

Any MCP client works; that flag is Claude Code's. **No credential is needed**
for the guest tools: check_feasible, observe_world, do_in_world, find_out,
job_status, job_receipt, job_evidence, list_bids. Pass `sandbox: true` to any
of them to run against the sandbox.

## Try it in ten seconds, over plain HTTP

No account, no key, no card. This posts a job into the sandbox and runs the
real machinery — claimed, evidence submitted, verified, settled, receipt — in
about ten seconds.

    curl -sX POST https://exchange.lamdis.ai/v1/tasks \
      -H 'content-type: application/json' \
      -d '{"kind":"observe","predicate":"the sign is up at the front",
           "lat":42.3314,"lon":-83.0458,"radius_m":150,
           "fee_minor":800,"sandbox":true}'

That returns a `job` and a `token`. Ten seconds later:

    curl -s https://exchange.lamdis.ai/v1/jobs/$JOB/receipt \
      -H "authorization: Bearer $TOKEN"

The receipt says `"sandbox": true`, `"evidence_synthetic": true`,
`"paid_minor": 0`, and states in words that nobody was dispatched and nothing
was paid. A sandbox job never reaches the public board, never touches the
ledger, and is never anchored. It exists so you can build the whole
integration before a single real person is involved.

## A real job

`POST /v1/tasks` with no Authorization header returns a `pay_at` link and a
`token`. Send the person the pay link. Their card is **authorised** for the
job's ceiling, not charged; the job goes on the board when that authorisation
lands, and the card is charged once, at the end, for exactly what was paid out
on proof. Nobody takes it, nothing is charged. An unpaid job is dropped after
24 hours. Keep the token: it is the only key to that job.

## What is honestly true today

**Coverage is zero.** Nobody has registered as an operator yet, so
`check_feasible` will tell you plainly that a real job would sit unclaimed. It
records where the work was asked for so supply can be recruited there — see
https://exchange.lamdis.ai/v1/demand. If you or your person can do physical
work somewhere, say where: https://exchange.lamdis.ai/coverage

The exchange takes no fee. Verification establishes that something happened,
not that it was done well, and confidence is capped at 0.85 with capture
location and 0.72 without, because no camera in general use signs its images
at capture. Every receipt states the ceiling that applied.

## Links

- https://lamdis.ai/for-agents — how an agent gets things done in the physical world
- https://exchange.lamdis.ai/docs — the live reference
- https://exchange.lamdis.ai/llms.txt — the exchange's own llms.txt
- https://github.com/lamdis-ai/lamdis-protocol — source, SDKs, OpenAPI, examples
- https://github.com/lamdis-ai/lamdis-protocol/blob/main/agents.md — the exchange written for an agent
- https://lamdis.ai/llms-full.txt — this, plus the money rules
- https://lamdis.ai/terms — terms of service
- https://lamdis.ai/privacy — privacy policy

---

# The money rules

All amounts are integer minor units (cents), USD. Every value here is taken
from the exchange's source; where this file and the running exchange disagree,
the exchange is right — `GET /v1/board` publishes the money terms under
`terms`.

| rule | value | source |
|---|---|---|
| Exchange fee on what a worker earns | 0 bp — zero, deliberately, not forever | `node/internal/exchange/settle.go` `FeeBP = 0` |
| Ceiling held for a job | `(max(fee + bonus, attempt) + expense_cap) × slots` | `node/internal/exchange/server.go` `MaxPayoutFor` |
| Unpaid anonymous job dropped after | 24 h | `node/internal/exchange/guest.go` `PendingTTL` |
| Buyer review window before earnings leave | 24 h (release early with `POST /release`) | `node/internal/exchange/settle.go` `disputeWindow` |
| A hold must be decided within | 7 days, else the money goes to the worker | `node/internal/exchange/dispute.go` `DisputeWindow` |
| Hold grounds | `not_done` `wrong_place` `fabricated` `damage` `unsafe` | `node/internal/exchange/dispute.go` |
| Worker payout threshold | 2000 minor ($20) accumulates before a transfer | `node/internal/exchange/funding.go` `PayoutThresholdMinor` |
| Job above which one verdict is too much | 50000 minor ($500): must carry `stages` or `plan_by: "supplier"` | `node/internal/api/assurance.go` `StakesMinor` |
| Mass low-value refusal | 20 or more slots at 300 minor or less each goes to a person first | `node/internal/api/screen.go` `MassLowValue` |
| Bids close after | 24 h by default (`bids_close_in_hours`) | `node/internal/exchange/server.go` |

## Exposure ceilings

The most an account may have riding on unfinished work at once
(`node/internal/api/assurance.go`). These are earned, not given.

| standing | ceiling |
|---|---|
| new | $75 (`NewCeilingMinor = 7500`) |
| proven | $300 (`ProvenCeilingMinor = 30000`) |
| established | $1,200 (`EstablishedCeilingMinor = 120000`) |
| vetted (business, licences and cover checked by a person) | $25,000 (`VettedCeilingMinor = 2500000`) |
| shaken (after abandoned work or a bad verdict) | $25 (`ShakenCeilingMinor = 2500`) |

## How funds are held

A card-funded job holds nothing at the exchange: the authorisation sits at the
payment rail, and only `settle()` captures. A balance-funded job holds the
ceiling in escrow before the listing exists, and what is not earned is
released. Earnings may also be routed to a USDC address
(`GET`/`PUT /v1/payout/usdc`), sent by a person on a schedule and capped at
$600 lifetime without a connected payout account.

An observation pays `fee_minor` for admissible evidence whichever way the
answer turns out, so a "no" is worth as much as a "yes" — treat both as real
findings. A do-job pays on completion; a documented failed attempt pays
`attempt_minor`.

## What a receipt proves, and what it does not

Verification checks that the evidence carries a one-time code issued privately
for that job; that it records where and when it was captured, where the job
requires that; that it has not been submitted before; that it does not appear
to be a generated image; and, for a do-job, whether it shows the thing that
was asked for. Where a job is tied to a location, something identifying the
property — usually the street number — must be legible, and the receipt records
whether it was.

It does not establish that the work was done *well*. A verified photograph of a
badly cleared gutter is still a badly cleared gutter. Capture coordinates come
from the file's own metadata, which whoever produced the file chose what to
write, so they raise the cost of faking without settling the question.

Because no camera in general use signs its own images at capture, the exchange
does not report better than **0.85** certainty on any verdict, and **0.72**
where the evidence carries no capture metadata
(`node/internal/verify/verify.go`). Every receipt states the ceiling that
applied, what was established, and what was not.

Receipts are signed, and anyone holding one can verify it without asking the
exchange anything. When the exchange is anchoring (`GET /v1/anchors`), a
receipt also carries `anchor`:
`{receipt_sha256, status, proof, method: "opentimestamps", merkle_root?, bitcoin_block?}`,
and `GET /v1/jobs/{job}/receipt/anchor?sha256=…` returns instructions for
checking it against Bitcoin without asking the exchange. Sandbox jobs are never
anchored.