Measure duplicate expensive work before you suppress a single call.

Across 3 rounds with 2 separate workers, the uncoordinated path executed 6 Firecrawl browser jobs for 18 credits. Active coordination executed 3 jobs for 9 credits, with 3 actual follower reuses and matching browser-computed results.

The latest repeat remained clean: zero fail-open, store, coordinate, codec or follower-timeout failures. Dollar and net-savings claims remain intentionally unset.

A 5-worker uncoordinated attempt hit Firecrawl's observed concurrency ceiling of 2 jobs and returned HTTP 429. In the coordinated follow-up, all 5 callers shared one authoritative browser job: 1 leader, 4 follower reuses, 0 coordination failures.

This is capacity/headroom evidence, not an 80% savings claim: the five-worker baseline did not complete, so comparative credit delta and dollar savings stay unknown.

npx seenrelay trace-census fleet-trace.jsonl
npx seenrelay trace-census fleet-trace.jsonl --json

The trace contains opaque SHA-256 exact-coordinate hashes, comparable start/end timestamps, worker identity, explicit shareability policy and optional caller-provenanced marginal cost or provider units. Raw prompts, tool arguments, URLs and results are not required and common raw-content fields are rejected.

successful_leader_overlap_opportunities counts eligible calls that began behind an exact leader that later succeeded. When the caller supplied cost provenance, the report can total gross_potential_avoided_cost_usd and potential provider units.

Actual avoided executions remain unknown at this stage. They become factual only after active coordination produces verified follower-reuse savings records. Net savings additionally require measured coordination/store overhead.

import {
  SeenRelayFleetShadowMeter,
  createRedisRestFleetStore
} from 'seenrelay/fleet';

const meter = new SeenRelayFleetShadowMeter({
  store: createRedisRestFleetStore({
    url: process.env.UPSTASH_REDIS_REST_URL,
    token: process.env.UPSTASH_REDIS_REST_TOKEN,
    prefix: 'seenrelay:fleet:shadow:v0'
  }),
  scopeKey: process.env.SEENRELAY_FLEET_SCOPE
});

const result = await meter.measure({
  coordinate: {
    provider: 'openai',
    operation: 'responses.create',
    model,
    input
  },
  policy: {
    sideEffectClass: 'read_only',
    exactSingleAnswerShareable: true,
    independentSamplesRequired: false
  },
  execute: () => expensiveCall(),
  cost: {
    marginalCostUsd: 0.48,
    provenance: 'provider_list_price'
  }
});

console.log(meter.getReport());

callsWithIdenticalInflightPredecessor counts eligible calls that started while the same exact coordinate was already running. overlappedFollowerObservedCostUsd is cost actually incurred during shadow measurement — not a savings claim.

If exact compatible overlap is rare, the call is cheap, or a zero-cost provider-native exact cache already dominates, leave coordination off.

If overlap is frequent and materially expensive, move that one reviewed operation to active fleet coordination and measure actual avoided executions with Savings Reports.

Mutations and independent sampling are excluded from overlap candidacy. Store or cost-metadata failures cannot change the application result.

import {
  SeenRelayFleetCoordinator,
  createRedisRestFleetStore,
  fleetCodecFromPrivateCodec
} from 'seenrelay/fleet';
import { createAesGcmPrivateCodec } from 'seenrelay/zero-state';

const fleet = new SeenRelayFleetCoordinator({
  store: createRedisRestFleetStore({
    url: process.env.UPSTASH_REDIS_REST_URL,
    token: process.env.UPSTASH_REDIS_REST_TOKEN
  }),
  codec: fleetCodecFromPrivateCodec(
    createAesGcmPrivateCodec(keyBytes)
  ),
  scopeKey: process.env.SEENRELAY_FLEET_SCOPE
});

const result = await fleet.run({
  coordinate: {
    provider: 'openai',
    operation: 'responses.create',
    model,
    input
  },
  policy: {
    sideEffectClass: 'read_only',
    exactSingleAnswerShareable: true,
    independentSamplesRequired: false
  },
  execute: () => expensiveCall()
});

Every result-affecting qualifier belongs in the coordinate. If two calls differ in model, files, tools, tenant state, randomness contract or another relevant input, they must not collapse.

import {
  createFleetSavingsLedger
} from 'seenrelay/fleet';

const savings = createFleetSavingsLedger();

await fleet.run({
  coordinate,
  policy,
  execute: expensiveCall,
  cost: {
    marginalCostUsd: 0.48,
    provenance: 'provider_list_price'
  },
  onReceipt: savings.record
});

console.log(savings.snapshot());

avoidedExecutions increases only on actual follower reuse. If cost is unknown, SeenRelay leaves the dollar value unknown instead of estimating it.

A Savings Report is not an invoice, bill, charge, payment receipt, customer-spend claim or proof that every similar request is shareable. It reports the local coordination path that actually occurred and the caller-provided cost provenance.

onReceipt remains the callback name for API compatibility; it records savings evidence, not a payment event.

Start with one expensive operation. If follower reuse is rare or absolute savings are immaterial, leave the rest of the application unchanged.

import {
  SeenRelayZeroState,
  createAesGcmPrivateCodec
} from 'seenrelay/zero-state';

const edge = new SeenRelayZeroState({
  privateStore: fleetStore,
  privateCodec: createAesGcmPrivateCodec(keyBytes),
  privateMaxAgeMs: 30_000
});

A positive privateMaxAgeMs is a separate caller freshness decision. Keep it at zero when a completed result must never suppress live validation.

Fleet coordination: same eligible work is already running now.

Private L1: a completed caller-owned result may still be fresh enough under an explicit policy.

Shared CHECK: optional recent external evidence for compatible source-backed facts.

Fallback: when any cheaper layer is insufficient, validate normally.

If compatible overlap is rare, the operation is cheap, or a stronger native mechanism already removes the cost, leave SeenRelay out of that path.

If the overlap is material and expensive, keep the narrowest explicit policy that preserves the caller's intended result multiplicity.