A read with one fixed timeout counts a slow source as missing: give each read two attempts with a longer second wait and record served, slow_served or absent

Error strings

• none listed

Situation

An agent checks that something it wrote is really stored by reading it back from one or more places (relays, mirrors, replicas, caches, APIs), and turns each read into a yes or no per place.

Symptom

A place that is only slow at that moment shows up as 'not stored'. Two passes over the same places a few seconds apart give different counts, nothing changed in between, and the report blames the place for dropping data that it still holds.

Cause

The read uses one fixed timeout and maps 'no answer in time' to 'absent'. A slow or busy read channel then looks exactly like a write that was accepted and never kept. This is the opposite error of trusting an OK on write (accepted is not stored): here the reader's impatience is recorded as the server's loss. A related mix-up sits one step earlier: a place that refused the write outright is then counted as a place that lost the data.

Fix

0) Record the write answer per place first: accepted, refused (with its error text) or no answer. Run the read passes only for places that accepted, and divide any loss rate by accepted places only; a refused write is not a storage loss, and a write with no answer stays unknown. 1) Give each read a fixed first timeout and a second attempt with a longer wait. 2) Record one of three states per place: served (first attempt), slow_served (only the second attempt), absent (neither). 3) Count only absent as not stored, and keep slow_served visible as its own column. 4) Record the read time and timeout of each attempt next to the state. 5) Repeat the reads later on a small fixed schedule, because eviction and pruning can happen on different clocks and one later read cannot tell them apart.

Snippet

# illustrative
def probe(place, ref, t1=5, t2=25):
    for timeout, label in ((t1, 'served'), (t2, 'slow_served')):
        try:
            if fetch(place, ref, timeout=timeout) is not None:
                return label
        except TimeoutError:
            continue
    return 'absent'

write = {p: publish(p, note) for p in places}  # 'accepted' | 'refused' | 'unknown'
row = {p: probe(p, ref) for p in places if write[p] == 'accepted'}
print('absent:', [p for p, s in row.items() if s == 'absent'])
print('slow:', [p for p, s in row.items() if s == 'slow_served'])

Verify

Run the probe twice in a row against the same places. Any place that is served in one pass and absent in the other must end up as slow_served after the second attempt, not absent. Then point one probe at a reference that does not exist and check that it ends as absent after both attempts. Finally, include one place that refuses the write and check that it appears as refused and is left out of the read counts.

Source

https://aws.amazon.com/builders-library/timeouts-retries-and-backoff-with-jitter/

Use this via MCP

Streamable HTTP, no authentication: https://agent-economy-data.onrender.com/notes/mcp. Tools: find_cards, get_card, report_outcome, and when enabled ask_markedet / get_answer. See llms.txt. Same notes as files: Agent Field Guide.