Start from the execution boundary you already have.

npx seenrelay scan

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

npx seenrelay otel-trace-census traces.otlp.json --json

claude plugin marketplace add ovladon/seenrelay
claude plugin install --scope user seenrelay@seenrelay

npx skills add https://seenrelay.com --skill seenrelay --yes

Find repeated expensive read-only validations across this agent fleet. Integrate SeenRelay only through a supported adapter, start in shadow mode, preserve the authoritative call and stronger native controls, run the existing tests, and report the exact workloads that repeat. Where workers already share a caller-owned store, evaluate encrypted private L1 before optional shared CHECK.

npm install seenrelay

import { ambientMcpClient } from 'seenrelay/ambient';

const client = ambientMcpClient(rawMcpClient);

// use client.callTool(...) normally
console.log(client.seenRelayAmbient.getReport());

pip install seenrelay

from seenrelay_ambient import ambient_mcp_client

client = ambient_mcp_client(raw_mcp_client)

# await client.call_tool(...) normally
print(client.get_report())

import { SeenRelayClient, reuseKnownOnSameObserved } from 'seenrelay';
import { SeenRelayShadowProof } from 'seenrelay/shadow-proof';
import {
  classifyHostileBenchmarkVerdict,
  evaluateHostileBenchmark
} from 'seenrelay/economics';

const proof = new SeenRelayShadowProof(
  new SeenRelayClient(),
  { benchmarkRecordLimit: 10_000 }
);

await proof.guard({
  fact,
  knownValue,
  validate: ({ conditionalHeaders }) =>
    expensiveValidation(conditionalHeaders),
  benchmark: {
    reuse: reuseKnownOnSameObserved,
    baselineCost: measuredValidationCost,
    checkCost: measuredCheckCost,
    observeCost: measuredObserveCost,
    observeAfterBaseline: true
  }
});

const input = proof.hostileBenchmarkInput({
  workloadId: 'opaque-workload-id',
  controls: measuredControls
});
const report = evaluateHostileBenchmark(input);
console.log(classifyHostileBenchmarkVerdict(report));

from seenrelay import SeenRelayClient, reuse_known_on_same_observed
from seenrelay_shadow import SeenRelayShadowProof
from seenrelay_economics import (
    classify_hostile_benchmark_verdict,
    evaluate_hostile_benchmark,
)

proof = SeenRelayShadowProof(
    SeenRelayClient(),
    benchmark_record_limit=10_000,
)

proof.guard(
    fact=fact,
    known_value=known_value,
    validate=lambda ctx: expensive_validation(ctx.conditional_headers),
    benchmark={
        "reuse": reuse_known_on_same_observed,
        "baseline_cost": measured_validation_cost,
        "check_cost": measured_check_cost,
        "observe_cost": measured_observe_cost,
        "observe_after_baseline": True,
    },
)

benchmark_input = proof.hostile_benchmark_input(
    workload_id="opaque-workload-id",
    controls=measured_controls,
)
report = evaluate_hostile_benchmark(benchmark_input)
print(classify_hostile_benchmark_verdict(report))

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

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

const meter = new SeenRelayFleetShadowMeter({
  store,
  scopeKey: process.env.SEENRELAY_FLEET_SCOPE
});

await meter.measure({
  coordinate,
  policy: {
    sideEffectClass: 'read_only',
    exactSingleAnswerShareable: true,
    independentSamplesRequired: false
  },
  execute: expensiveCall,
  cost: {
    marginalCostUsd: 0.48,
    provenance: 'provider_list_price'
  }
});

console.log(meter.getReport());

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

const savings = createFleetSavingsLedger();
const fleet = new SeenRelayFleetCoordinator({
  store,
  codec: fleetCodecFromPrivateCodec(
    createAesGcmPrivateCodec(keyBytes)
  ),
  scopeKey: process.env.SEENRELAY_FLEET_SCOPE
});

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