# RQM WaveEngine Jobs

> Delegate 20 typed, evidence-backed WaveEngine signal work products with fixed-request x402.

- name: com.rqmtechnologies/waveengine
- version: 1.6.0
- connection class: R0 (autonomous)
- trust: 89/100 flags: duplicate-repo
- quality: 97/100 (strong)
- owner: not claimed
- descriptor: https://api.protogrid.dev/v1/servers/com.rqmtechnologies%2Fwaveengine
- tools: https://api.protogrid.dev/v1/servers/com.rqmtechnologies%2Fwaveengine/tools

**An agent can connect right now, no human step.** Remote endpoint, no authentication, reachable on the last probe.

## Connection (mcpServers)

```json
{
  "mcpServers": {
    "waveengine": {
      "type": "http",
      "url": "https://jobs.rqmtechnologies.com/mcp/waveengine"
    }
  }
}
```


## Trust

- hygiene: 80
- liveness: 100
- freshness: 85
- provenance: 85
- drivers: +repository +dns-namespace +website +reachable +uptime-100% ~updated-61d-ago -duplicate-repo(4 names)
- Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed.

## Quality 97/100 (strong)

### protocol: 100 (weight 25)

- pass `protocol.modern`: supports 2026-07-28 (server/discover)
- pass `protocol.stateless`: answers without a session
- pass `protocol.transport`: streamable HTTP
- pass `protocol.list_ttl`: tool list is cacheable (ttlMs 300000)

### authorization: n/a (weight 15)

- n/a `auth.prm`, `auth.as_metadata`, `auth.cimd`: no remote uses OAuth
- n/a `auth.secret_in_url`: no templated URL

### tool hygiene: 93 (weight 30)

- pass `tools.descriptions`: every tool has a description
- pass `tools.description_length`: descriptions are concise
- pass `tools.schemas`: every tool has an object input schema
- pass `tools.annotations`: 34 of 34 tools declare readOnlyHint or destructiveHint
- pass `tools.directory_hints`: every tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
- warn `tools.token_cost`: about 9,067 tokens to load every tool
- pass `tools.api_dump`: tools are not a one-to-one API dump

### stability: 100 (weight 15)

- pass `stability.changes`: no tool changes in 30 days
- pass `stability.rug_pull`: no tool changed its meaning under the same name

### dependencies: n/a (weight 15)

- n/a `deps.known_vulns`, `deps.mcp_sdk_version`, `deps.resolvable`: no npm or PyPI package

- tools: 34, about 9,067 tokens to load them all
- tool set hash: 7a7ddeb6b45504e9d03ed7650b16f6a9
- badge: [![protogrid quality](https://protogrid.dev/badge/com.rqmtechnologies/waveengine.svg)](https://protogrid.dev/servers/com.rqmtechnologies/waveengine)
- Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed.

### Tool changes

_No tool definition changes recorded._

## Remotes

- https://jobs.rqmtechnologies.com/mcp/waveengine (streamable-http, auth none, reachable true, uptime30d 1)

## Packages

_none_

## Tools (34)

- `estimate_wave_job`: Validate a bounded request against the live catalog and return a non-binding price and duration estimate without authentication.
- `get_wave_capability`: Return one full approved public Wave capability descriptor.
- `get_wave_example`: Return one realistic illustrative request/result shape, artifact list, expected duration, and price guard.
- `get_wave_job_artifact`: Retrieve one principal-scoped bounded Wave result artifact.
- `get_wave_job_result`: Read one completed and already-settled product result.
- `get_wave_job_status`: Read one authorized Wave or Studio managed-simulator job.
- `get_wave_receipt`: Retrieve the durable Account Core receipt for one settled WaveEngine reservation.
- `list_buyer_jobs`: Return complete agent discovery contracts and readiness for the exact 20/20/20 RQM specialist work portfolio.
- `list_wave_capabilities`: Describe the preserved v0/v1 surface or the dynamic v2/v3 Wave catalog.
- `run_buyer_job`: Quote, settle, and submit one allowlisted WaveEngine, Studio, or Robotics buyer job using x402.
- `run_wave_example`: Execute the catalog-owned bounded example through the real typed WaveEngine adapter without accepting arbitrary input.
- `run_wave_job`: Pay anonymously with x402 by default, or explicitly use an authenticated Account Core balance, then submit one idempotent WaveEngine job.
- `search_buyer_jobs`: Select RQM buyer jobs from work-language requests using deterministic semantic scoring over instructions, examples, outputs, and next steps.
- `search_wave_capabilities`: Deterministically rank executable WaveEngine capabilities for a natural-language task and bounded filters.
- `wave_apply_verified_phase_correction_v1`: Problem: Apply this bounded phase correction and verify the supplied preservation assertions. Input: JSON with sample rate hz, channels, angle radians, assertions. Result: corrected capture and preservation checks. Limits: Bounded signal processing only; 2 channels; 1024 samples/channel.
- `wave_compare_pipeline_responses_v1`: Problem: Compare these two supported Wave pipelines on the supplied fixture and caller tolerances. Input: JSON with left pipeline, right pipeline, fixture, maximum rmse, maximum absolute.... Result: response differences and tolerance checks. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_compare_waveform_captures_v1`: Problem: Compare these two bounded waveforms against the supplied alignment and numeric rules. Input: JSON with sample rate hz, channels, reference channel id, candidate channel id, rules. Result: waveform differences and caller-rule results. Limits: Bounded signal processing only; 2 channels; 1024 samples/channel.
- `wave_compile_curated_processing_recipe_v1`: Problem: Compile this curated processing recipe and return its validated pipeline and execution trace. Input: JSON with fixture, maximum round trip rmse. Result: validated pipeline and execution trace. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_convert_capture_to_spectrum_v1`: Problem: Convert this bounded complex capture into a checksummed spectral artifact with declared normalization. Input: JSON with sample rate hz, channel, normalization. Result: spectrum with normalization and checksums. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_diagnose_multichannel_capture_v1`: Problem: Diagnose this coordinated complex capture for bounded Wave-Intelligence degradation findings without inferring a physical cause. Input: JSON with sample rate hz, channels. Result: bounded capture findings and artifacts. Limits: Bounded signal processing only; 8 channels; 1024 samples/channel.
- `wave_equalize_pilot_capture_v1`: Problem: Fit a bounded quaternion NLMS equalizer to this received and desired pilot capture. Input: JSON with input channels, output channels, received, desired, pilot mask. Result: fitted equalizer and pilot-fit evidence. Limits: Bounded signal processing only; 4 channels; 1024 samples/channel.
- `wave_extract_wave_features_v1`: Problem: Convert this coordinated complex capture into the deterministic versioned Wave-Intelligence feature vector. Input: JSON with sample rate hz, channels. Result: versioned feature vector and artifacts. Limits: Bounded signal processing only; 8 channels; 1024 samples/channel.
- `wave_fit_coupled_channel_model_v1`: Problem: Fit a bounded structured quaternion ridge model to these coupled channel features and targets. Input: JSON with feature count, output count, features, targets. Result: fitted channel model and fit evidence. Limits: Bounded signal processing only; 16 channels; 512 samples/channel.
- `wave_gate_signal_capture_v1`: Problem: Accept or reject this bounded signal capture against the caller-supplied metric rules and return every measurement and violation. Input: JSON with sample rate hz, channels, rules. Result: measurements, violations and checksummed artifacts. Limits: Bounded signal processing only; 8 channels; 1024 samples/channel.
- `wave_generate_validated_signal_fixture_v1`: Problem: Generate this bounded sine or safe-formula signal fixture and return reproducibility, measurement, checksum, and validation evidence. Input: JSON with fixture. Result: signal fixture, checksums and validation evidence. Limits: Bounded signal processing only; 8 channels; 16384 samples/channel.
- `wave_measure_phase_drift_v1`: Problem: Measure phase drift in this bounded complex observation against the supplied reference and tolerances. Input: JSON with reference, observation, maximum absolute drift radians, maximum rms.... Result: phase drift measurements and tolerance checks. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_optimize_processing_pipeline_v1`: Problem: Optimize this supported Wave pipeline against the supplied operation-count objective and equivalence rule. Input: JSON with operations, fixture, objective, maximum operations, maximum equivalence.... Result: candidate pipeline and equivalence checks. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_reconstruct_bounded_capture_v1`: Problem: Reconstruct this bounded capture under the supplied transfer assumption and verify it against the reference rules. Input: JSON with observation, reference, assumed transfer, maximum rmse, maximum.... Result: reconstructed capture and reference-rule checks. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_reconstruct_time_domain_signal_v1`: Problem: Convert these bounded frequency bins into time-domain samples and verify the caller's round-trip rule. Input: JSON with sample rate hz, frequency bins, normalization, rules. Result: time-domain samples and round-trip verification. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_rotate_and_validate_two_channel_frame_v1`: Problem: Rotate these two coordinated complex channels with the supplied rotor and validate caller invariants. Input: JSON with channels, rotor, rules. Result: rotated channels and invariant checks. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_transport_polarization_frame_v1`: Problem: Transform these Jones vectors or channel operators between the explicitly named SU(2) frames and verify invariants. Input: JSON with mode, rotor. Result: transformed vectors/operators and invariant checks. Limits: Bounded signal processing only; 4 channels; 1024 samples/channel.
- `wave_validate_reconstruction_quality_v1`: Problem: Compare this reconstruction with the supplied reference and acceptance rules. Input: JSON with reference, reconstruction, rules. Result: reconstruction differences and rule results. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_validate_spectral_criteria_v1`: Problem: Accept or reject this bounded capture against the caller's supplied spectral criteria. Input: JSON with sample rate hz, channel, normalization, rules. Result: spectral metrics and caller-rule verdict. Limits: Bounded signal processing only; 8 channels; 4096 samples/channel.
- `wave_verify_wave_pipeline_v1`: Problem: Execute and verify this bounded Wave IR pipeline against the required representation, shape, and optional round-trip assertions. Input: JSON with sample rate hz, channels, operators, assertions. Result: execution result and shape/round-trip checks. Limits: Bounded signal processing only; 2 channels; 1024 samples/channel.