codameter · ambient-noise dv/v monitoring

From raw coda to stress at depth — and where agents fit

codameter turns cross-correlation functions into a relative velocity-change (δv/v) time series, propagates its uncertainty, and inverts it for depth and stress. This chart maps that pipeline, marks the steps an agent can drive, and decomposes the evaluation loop into its smallest reproducible parts.

Agent-amenable — an LLM can do or drive it Deterministic compute — pure code, reproducible Data artifact — a dataset or output object Human-in-the-loop — needs a scientist's call
design rule

Agents propose; deterministic oracles score. Every agent step is bounded by code that regenerates a known truth and measures the result — so trust never rests on the model.

A · the scientific pipeline

Measurement to interpretation

The core dv/v arc. The processing at stage 2 is a long chain of choices; the whole point of the advisor and the golden set is to make those choices explicit and testable.

compute + human QC

1. Ingest & QC

Raw noise / CCFs, gap detection, time alignment, SNR gating.

data.loaders · qc · readiness (Phase 0)
→
compute · choice=agent

2. Measure δv/v

Estimator, band, coda window, reference, stacking, aggregation → δv/v(t).

synthetic_demo · deviations.run_pipeline
→
compute

3. Uncertainty → C d

Aleatoric floor + processing multiverse, marginalized into one covariance.

uq_measurement · uq_processing · uq_bayes
→
compute

4. Depth inversion

Frequency-dependent kernels → a shear-velocity change vs depth.

uq_depth · kernels (disba)
→
compute + human

5. Stress & strain

Petrophysical β-bridge from velocity change to stress at depth.

interpretation · forward · coupling
→
compute · draft=agent

6. Anomaly & attribution

Detect residual transients; attribute to a forcing mechanism.

anomaly · forcing_models

Agent openings: stage 2's choices come from the advisor; stages 5–6 benefit from agent-drafted interpretation, but the numbers stay code-owned.

B · the parameter advisor

Elicit → map → validate → report

The codameter-advisor skill front-ends stage 2. It never invents parameters: it maps a use case to a config, then proves it on a matched synthetic before recommending.

agent + human

1. Elicit use case

Ask the monitoring target, band, geometry, expected amplitude, data problems.

use_cases.ELICITATION · AskUserQuestion
→
compute · surfaced by agent

2. Map to config

Look up the recommended choice set with cited rationale.

use_cases.recommend()
→
compute · agent-invoked

3. Validate live

Run recommended vs naive on a matched golden case; report the RMS cost.

golden.generate · run_pipeline · multiverse
→
agent

4. Report

Config + YAML + numbers + the one caveat that matters for this case.

references/report_format.md
↶

Loop: if the user pins an axis, re-map and re-validate. The report carries the measured contrast, not an opinion.

C · evaluation, decomposed

Two lanes of small, checkable steps

"Evaluation" is really two pipelines. The left lane scores a pipeline against a known truth (the regression oracle). The right lane scores an agent against that same oracle (the FrugalMind benchmark). They share their scoring core, so an agent is judged by the same code that guards the pipeline.

Lane 1 · Pipeline scoring (deterministic oracle)

Reproducible from seeds. Runs in CI and fans out on Fargate.

  1. 1

    Define the case human / agent

    Pick a use case and regime (mainstream or an edge: low-SNR, clock drift, freq-dependent, sparse).

    golden.CASES
  2. 2

    Generate golden synthetic data

    Seed → daily CCFs with an exactly known δv/v(t). Deterministic; cached, hash-keyed.

    golden.generate()
  3. 3

    Produce a config agent or code

    The recommended config, or a candidate to test. This is the only lever under study.

    use_cases.recommend()
  4. 4

    Run the pipeline compute

    Recover δv/v(t) under that config, with the estimator, reference and stacking it names.

    deviations.run_pipeline()
  5. 5

    Score recovery compute

    Baseline-aligned RMS of recovered vs true δv/v (the DC offset is unobservable, so removed).

    golden._rms()
  6. 6

    Sweep & shard compute · scale

    Every case × every config in a grid; round-robin shards across an array of tasks.

    bench.sweep · --shard k/N
  7. 7

    Aggregate & drift-guard data

    Merge shards, pick best config per case, and lock expected RMS in the committed manifest.

    bench.aggregate · manifest.json

Lane 2 · Agent scoring (FrugalMind benchmark)

Judges a model, cost-aware. Reuses Lane 1's steps 4–5 as its scorer.

  1. 1

    Build rows data

    Each case → a prompt + gold (case id + tolerances) + a scorer spec. No arrays leak.

    frugalmind.build_rows()
  2. 2

    Model answers agent · under test

    Returns a config (JSON) for param_recommendation, or the recovered series for dvv_series.

    EvalRunner → adapter.generate()
  3. 3

    Rebuild scorer compute

    Reconstruct the deterministic scorer from the JSON spec — portable, no hidden state.

    make_scorer_from_spec()
  4. 4

    Score in [0,1] compute

    Run the answer through Lane 1 (steps 4–5). Wrong band or cycle-skip → near 0; a no-change series is null-anchored to 0.

    dvv_recovery · dvv_series_regression
  5. 5

    Route on budget compute

    Track spend per model; stop cleanly at the cap. Cheapest model that clears the quality floor wins.

    EvalRunner · BudgetGuard
  6. 6

    Adversarial cross-check agent · optional

    A panel re-derives δv/v with independent estimators; agreement gates the result.

    multi-estimator verify (proposed)
  7. 7

    Leaderboard data · human reads

    Score × cost per model and suite; skill-lift over the no-skill baseline.

    leaderboard · skill_lift

D · where agents plug in

Agent opportunities, ranked by leverage

The steps worth agentifying, what the agent actually does, and where each stands today. Everything else stays deterministic on purpose.

StepAgent roleToolingStatus
Use-case elicitation drives asks & infers the monitoring setting codameter-advisor built
Recommend & report drafts surfaces config + cited rationale + numbers advisor · report_format built
Config under test is tested picks a processing config for a scenario param_recommendation built (benchmark)
End-to-end series is tested runs codameter in a sandbox, returns δv/v(t) dvv_series built; needs sandbox
Interpretation draft assists narrates stress / anomaly attribution interpretation · anomaly candidate
Adversarial verify panel cross-checks with independent estimators multi-estimator proposed
Eval orchestration meta chooses sweeps, reads leaderboards, flags drift bench · frugalmind candidate