# Whose devices you can use

*Reference for the Stringer onboarding skill. You do not need this to get
started — the fast path is in SKILL.md. Come here when something fails, when a
tool refuses you, or when your human asks why.*

## §6B. Whose devices you can use: yours, or strangers'

This decides where you aim every mission, so read it before you submit one.

**Your own supply — "me".** The devices belonging to the human who owns you. Ask
which they are and where; never guess, and never copy coordinates from an example
on this page:

```bash
curl -s "$BROKER/v0/agents/me" -H "authorization: Bearer $AGENT_KEY"
# -> "own_coverage":{"devices":[{"embodiment_id":"emb_...","status":"listening",
#                                "lat":51.5077,"lng":-0.1278}],"listening":1}
```

`own_coverage` lists ONLY your owner's devices — you and they are the same
principal, so this discloses nothing about anybody else. **`lat`/`lng` is the
centre of the coverage area its human DECLARED — a service area, not where the
device is now** — rounded to about 110 m. Use it to decide whether a point your
human names is one of your owner's devices (within a few hundred metres of it)
and never as a mission's `location`: an agent that copied it sent a mission
27.7 km from the person meant to fulfil it (`missions.md`). A device with
`"lat": null` has never declared an area and cannot be targeted; `0,0` is a
real place in the Atlantic, so never substitute it. `"listening": 0` means none of
your devices is available right now — **say so and stop**, rather than dispatching
work nobody can do.

Own-device missions take **no escrow**, and raw capture is permitted on them.
This is the path Phase 1 is built around.

**Strangers — other people's devices.** Opt in explicitly with
`allow_stranger: true`, and it changes the rules: the mission must be funded in
the instrument it will pay in, and it must carry a `prompt` stating screenable
intent. Raw `video`/`audio`/`live_video` is permitted, at the same
`raw_capture_ack` + `lawful_basis` bar your own device meets — and what a
stranger's PHONE sends is never raw pixels. **The phone app declares
`redaction: {"post": "full", "live": "full"}` with face, plate and text blur,
`consent_tiers: [0, 1, 2]`, `form: "handheld"` and `max_fps: 2`**, so a tier-2 or
`live_video` mission on a stranger's phone arrives blurred on the device, at two
frames a second at most. (The marketplace LISTING route is stricter: it refuses
raw kinds outright, `E_LISTING_MEDIA_UNSUPPORTED` in `money.md`.) A stranger's
room is usually a private space: the terms of service (`/v0/terms`) restrict
capture inside one, and the person reading your prompt can decline — that
refusal is the safety model, not a fault. **Do not set it during onboarding** —
not because it is refused, but because a stranger mission pays a real person and
you should have walked the loop on your own device first.

**How much a device has proved about itself is yours to ask on, and it is always
disclosed.** Four rungs, weakest first:

| `attestation` | what it means |
|---|---|
| `none` | Nothing proved. **Most supply is here**, including every robot. |
| `self_declared` | A stable identity the device asserts; nothing verifies it. |
| `attested` | Platform attestation we verified. Apple App Attest today, so iPhone-only. |
| `hardware_key` | A key in secure hardware with a chain we verified. Nothing reaches this yet. |

Ask for a floor with `require: {"attestation": "attested"}` on the mission and
you will be matched at that rung **or better**; ask for nothing and you may be
matched with anything. Either way the `DISPATCHED` outbox event carries the
assigned device's `attestation` and a plain-language `attestation_plain`.

**Do not read this as the bystander control — it is not.** What protects people
who walk past a lens is the device's redaction *declaration*, which we enforce
per lane and which fails closed: a device that has not declared what it masks is
never offered stranger work, whatever its attestation says.

**A person, or a machine, is `require.form` — not attestation.** A body declares
its shape: `handheld` (a phone in a person's hand), `wheeled`, `legged`,
`tracked`, `humanoid`, `aerial`, `fixed`. Ask for a person with
`require: {"form": ["handheld"]}` and for a machine with the shapes a machine
takes, e.g. `["wheeled", "legged", "tracked", "humanoid"]`; the list means any
of them. Attestation is a different fact — most robots are `none` and an
attested iPhone is still a phone — and on 2026-09-04 a cold agent asked to
"find a person" guessed attestation because this paragraph did not exist.
⚠️ **A device that never declared a form is `unknown`, and `unknown` matches no
filter.** The phone app declares `handheld` from build 134 and the reference
robot declares `wheeled`; other bodies declare theirs as they are updated. If a
form filter finds nothing, that is the reason before it is anything else.

**YOU NAME THE PRICE, AND THIS IS REQUIRED.** A stranger mission must say what
you will pay the person who does it, in minor units — but **the field is named
differently depending on how you are calling**, and the wrong one is rejected
before the broker sees it:

```json
// raw HTTP -- the label matches pay_instrument, which defaults to CRDW
"offer_price": {"amount": 350, "currency": "CRDW"}
```

```json
// through the MCP client — a plain integer, and the schema is strict, so
// sending the object form above gets you "Unrecognized key: offer_price"
"offer_price_minor": 350
```

Omit it and the mission is refused with `E_PRICE_REQUIRED`. There is no fallback
and no computed default, deliberately: until 2026-08-07 the broker priced
stranger work from an internal yardstick of 10 minor per minute, which was built
to decide how much credit an OWN-DEVICE mission mints and had no business setting
a human's wage. A provider advertising $3.50 who was sent a `goto` plus sixty
seconds of `observe` was paid **35 minor**. The ledger balanced, nothing errored,
and the person was underpaid by an order of magnitude. Refusing is louder than
underpaying, and an underpayment leaves nothing to find.

`offer_price` is **not** `max_price`. `max_price` is a CEILING and can only ever
lower a computed figure; it does not apply to stranger work at all now. If you
send both, the offer is what is escrowed.

**What to offer.** If you are buying against a listing, offer what the listing
says. Otherwise: the person is doing a real errand with their own phone, their
own time and their own legs. Price it as you would price asking a stranger in the
street to do it, not as a fraction of an API call.

**Say what you are paying in.** `pay_instrument` is `"CRDW"` (default) or
`"CRD"` — **uppercase, and checked strictly: a lowercase value is refused rather
than corrected.** `CRDW` is real money — cash your human topped up, one minor
unit per US cent, and what a stranger is paid in. `CRD` is credit, minted when
an owner's own devices do work; it can be spent here and **cannot be exchanged
for cash** (owner ruling 2026-09-05: *"Credits are not money. You can top up
real cash, CRDW, and spend it. Credits, CRD, cannot be exchanged for cash."*).
A provider is shown which one an offer pays *before* they accept it, and it is
a different proposition to them. Choose honestly.

There is **no fallback**. If you name `CRDW` and cannot cover the quote, the
accept is refused with `E_INSUFFICIENT_FUNDS` — it will not quietly pay the
person in `CRD` instead. Omit the field and you are paying `CRDW`.

**Mind the case, because this document uses both and they are not
interchangeable.** The `pay_instrument` VALUE is uppercase `"CRD"`/`"CRDW"` and
is checked strictly. The WALLET BALANCE keys are lowercase — `{"crd":0,"crdw":0}`
(Step 2) — because they are field names, not instrument values. Sending
`"crdw"` as a pay_instrument is refused, not corrected.

**`pay_instrument` needs a client of 0.2.0 or newer.** The tool schemas are
strict, so an older client REFUSES a key it does not know rather than dropping it
— you will see a schema error naming `pay_instrument`, not a mission that
quietly paid the wrong way. That refusal is the signal to re-download the bundle
from `/v0/mcp-server.tgz` (Step 3) and check `node "$MCP" --version`. There is no
auto-update: the client you hold is the client you keep until you pull again.

`allow_stranger` is a parameter on the `stringer_request` and `stringer_observe`
tools as well as on the raw mission body, so both paths reach the same market.
Omit it and it stays false — the tools send no key at all rather than a default
of their own, so the broker's default is the only one that exists.

**The trap that cost a real run.** `/v0/feasibility` and `/v0/discover` answer
about the point YOU give them, confidently, whether or not it is anywhere near
your owner. On 2026-07-30 an agent used this page's example coordinates, asked
about Edinburgh while its owner's only phone sat 534 km away in Twickenham, and
reported "no coverage" — a true answer to a question its human never asked. Check
`own_coverage` FIRST; feasibility second, about a point you got from it.

---


## `/v0/discover` and `/v0/feasibility`, exactly

Both are `GET`, agent-authenticated, and both were referred to on four pages
without their request shape until 2026-09-04.

- **`GET /v0/discover`** -- YOUR OWN devices only; it takes no point. Optional
  query: `duration_s` (default 120), `needs` and `prefer` as `modality:level`
  pairs, e.g. `?needs=classify:basic,ocr:basic`. Answers `available`,
  `listening`, `supply_depth`, per-kind counts, whether any listening device
  takes free-text directives, and `why` / `remedy` when nothing can be
  dispatched.
- **`GET /v0/feasibility?lat=51.458&lng=-0.322`** -- about a POINT. `lat` and
  `lng` are required (`400 bad_request` otherwise); add `allow_stranger=true` to
  count strangers who could actually be hired (vetted, granted, paid), and
  `needs` / `prefer` as above. Answers how many capability-matched devices are
  near that point, as a band rather than identities.
