Connect

8 clients · secrets stay placeholders

JSON (mcpServers)Claude CodeCodexOpenCodeCursorVS CodeGemini CLIGoose

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

claude mcp add --transport http waveengine https://jobs.rqmtechnologies.com/mcp/waveengine

[mcp_servers.waveengine]
url = "https://jobs.rqmtechnologies.com/mcp/waveengine"

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "waveengine": {
      "type": "remote",
      "url": "https://jobs.rqmtechnologies.com/mcp/waveengine",
      "enabled": true
    }
  }
}

{
  "mcpServers": {
    "waveengine": {
      "type": "http",
      "url": "https://jobs.rqmtechnologies.com/mcp/waveengine"
    }
  },
  "deeplink": "cursor://anysphere.cursor-deeplink/mcp/install?name=waveengine&config=eyJ0eXBlIjoiaHR0cCIsInVybCI6Imh0dHBzOi8vam9icy5ycW10ZWNobm9sb2dpZXMuY29tL21jcC93YXZlZW5naW5lIn0%3D"
}

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

{
  "mcpServers": {
    "waveengine": {
      "httpUrl": "https://jobs.rqmtechnologies.com/mcp/waveengine"
    }
  }
}

extensions:
  "waveengine":
    enabled: true
    name: "waveengine"
    type: streamable_http
    uri: "https://jobs.rqmtechnologies.com/mcp/waveengine"
    timeout: 300

Quality 97 / 100strong

protocol100 · weight 25

pass
protocol.modernsupports 2026-07-28 (server/discover)
pass
protocol.statelessanswers without a session
pass
protocol.transportstreamable HTTP
pass
protocol.list_ttltool list is cacheable (ttlMs 300000)

authorizationn/a · weight 15

n/a
auth.prm, auth.as_metadata, auth.cimdno remote uses OAuth
n/a
auth.secret_in_urlno templated URL

tool hygiene93 · weight 30

pass
tools.descriptionsevery tool has a description
pass
tools.description_lengthdescriptions are concise
pass
tools.schemasevery tool has an object input schema
pass
tools.annotations34 of 34 tools declare readOnlyHint or destructiveHint
pass
tools.directory_hintsevery tool declares readOnlyHint, destructiveHint, idempotentHint and openWorldHint
warn
tools.token_costabout 9,067 tokens to load every tool
pass
tools.api_dumptools are not a one-to-one API dump

stability100 · weight 15

pass
stability.changesno tool changes in 30 days
pass
stability.rug_pullno tool changed its meaning under the same name

dependenciesn/a · weight 15

n/a
deps.known_vulns, deps.mcp_sdk_version, deps.resolvableno npm or PyPI package

34 tools, about 9,067 tokens to load them all · tool set 7a7ddeb6b455 · checked 2026-10-19 10:52 UTC

Tool changes

No tool definition changes recorded. A server's first observation is its baseline; later probes record what changes.

Checks run on what our credential-free, read-only probes observe; tools are never called and no code audit is performed. How it is computed.

Trust 89 / 100

duplicate-repo

provenance85

liveness100

freshness85

hygiene80

+repository +dns-namespace +website +reachable +uptime-100% ~updated-60d-ago -duplicate-repo(4 names)

Derived from observable signals (official registry feed and our own credential-free probes); no code audit performed. How it is computed.

Endpoints

remote	auth	reachable	uptime 30d	p50	protocol	last ok
`https://jobs.rqmtechnologies.com/mcp/waveengine` streamable-http	none	yes	100%	539 ms	2026-07-28	2026-10-19

Tools (34)

`estimate_wave_job`read-only	Validate a bounded request against the live catalog and return a non-binding price and duration estimate without authentication.
`get_wave_capability`read-only	Return one full approved public Wave capability descriptor.
`get_wave_example`read-only	Return one realistic illustrative request/result shape, artifact list, expected duration, and price guard.
`get_wave_job_artifact`read-only	Retrieve one principal-scoped bounded Wave result artifact.
`get_wave_job_result`read-only	Read one completed and already-settled product result.
`get_wave_job_status`read-only	Read one authorized Wave or Studio managed-simulator job.
`get_wave_receipt`read-only	Retrieve the durable Account Core receipt for one settled WaveEngine reservation.
`list_buyer_jobs`read-only	Return complete agent discovery contracts and readiness for the exact 20/20/20 RQM specialist work portfolio.
`list_wave_capabilities`read-only	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`read-only	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`read-only	Select RQM buyer jobs from work-language requests using deterministic semantic scoring over instructions, examples, outputs, and next steps.
`search_wave_capabilities`read-only	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.

Schemas: list_tools.

Also listed as

3 other active names share this repository: com.rqmtechnologies/jobs, com.rqmtechnologies/robotics, com.rqmtechnologies/studio

Similar MCP servers

More from com.rqmtechnologies

Official server.json

{
  "name": "com.rqmtechnologies/waveengine",
  "_meta": {
    "io.modelcontextprotocol.registry/publisher-provided": {
      "publisher": "RQM Technologies LLC",
      "catalogUrl": "https://jobs.rqmtechnologies.com/mcp/waveengine/catalog.json",
      "categories": [
        "signal-processing",
        "rf",
        "iq",
        "fft",
        "waveengine",
        "ai-outsourcing"
      ],
      "commercialState": "fixed-request Base mainnet x402 portfolio; all 20 jobs passed the controlled 60-payment canary",
      "documentationUrl": "https://www.rqmtechnologies.com/waveengine/mcp",
      "catalogGeneration": "agent discovery v1; exactly 20 production-live WaveEngine buyer jobs"
    }
  },
  "icons": [
    {
      "src": "https://www.rqmtechnologies.com/assets/rqm-open-source-hero-waveengine.png",
      "mimeType": "image/png"
    }
  ],
  "title": "RQM WaveEngine Jobs",
  "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
  "remotes": [
    {
      "url": "https://jobs.rqmtechnologies.com/mcp/waveengine",
      "type": "streamable-http"
    }
  ],
  "version": "1.6.0",
  "repository": {
    "url": "https://github.com/RQM-Technologies-dev/RQM-Jobs-MCP",
    "source": "github"
  },
  "websiteUrl": "https://www.rqmtechnologies.com/waveengine/mcp",
  "description": "Delegate 20 typed, evidence-backed WaveEngine signal work products with fixed-request x402."
}