# io.github.praxec/fmeca (oci · ghcr.io/praxec/fmeca)

Deterministic, offline FMECA MCP server: failure modes, criticality matrix, mitigations, readiness

- Trust score: 41/100 (low)
- Change this week: +4
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-10-23

## Components

- oci · `ghcr.io/praxec/fmeca`: 41/100 (this document), [markdown](https://verifymcp.io/servers/praxec-fmeca/ghcr-io-praxec-fmeca.md), [page](https://verifymcp.io/servers/praxec-fmeca/ghcr-io-praxec-fmeca)

## Channel facts

- Registry: `oci`
- Package: `ghcr.io/praxec/fmeca`
- Version: `0.2.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-10-23.

- **Supply Chain Security**: 0/100
  - No malware scan is available for this kind of package: the supply-chain vendors we use do not cover it. This is a permanent gap in our coverage, not a finding about the package.
  - Known CVEs could not be checked: this artifact ships no SBOM or dependency manifest, so there is no dependency list to read.
  - Install-script risk not yet assessed.
  - Dependency health could not be checked: this artifact ships no SBOM or dependency manifest, so there is no dependency list to read.
- **Provenance & Transparency**: 48/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 0 days ago).
  - Publishes a security disclosure policy (SECURITY.md).
- **Schema Quality & AI Usability**: 54/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3678 tokens (~306/item across 12 items; 12 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 30/100
  - Stability observed for 9 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 92/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 76% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 12 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 13 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a current MCP spec version (2026-07-28).

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the io.github.praxec/fmeca MCP server?

io.github.praxec/fmeca runs locally as a container image, launched with docker run --rm -i ghcr.io/praxec/fmeca:0.2.2. Ready-made configuration for Claude, Cursor, VS Code, Codex and 3 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add praxec-fmeca -- docker run --rm -i ghcr.io/praxec/fmeca:0.2.2
```

### Cursor

```json
{
  "mcpServers": {
    "praxec-fmeca": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/praxec/fmeca:0.2.2"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "praxec-fmeca": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/praxec/fmeca:0.2.2"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add praxec-fmeca -- docker run --rm -i ghcr.io/praxec/fmeca:0.2.2
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "praxec-fmeca": {
      "type": "local",
      "command": [
        "docker",
        "run",
        "--rm",
        "-i",
        "ghcr.io/praxec/fmeca:0.2.2"
      ],
      "enabled": true
    }
  }
}
```

### Hermes

```yaml
mcp_servers:
  praxec-fmeca:
    command: "docker"
    args: ["run", "--rm", "-i", "ghcr.io/praxec/fmeca:0.2.2"]
```

### Netclaw

```json
{
  "McpServers": {
    "praxec-fmeca": {
      "Transport": "stdio",
      "Command": "docker",
      "Arguments": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/praxec/fmeca:0.2.2"
      ]
    }
  }
}
```

### Other

```json
{
  "mcpServers": {
    "praxec-fmeca": {
      "command": "docker",
      "args": [
        "run",
        "--rm",
        "-i",
        "ghcr.io/praxec/fmeca:0.2.2"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-10-23 (score 41, +1)

No change was recorded against any check on this day. Stability & Change Management went from 27 to 30. That category is still filling its 30-day observation window: 8 days of observed history at the previous scan, 9 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-22 (score 40, 0)

- [functional] Package version: 0.2.1 → 0.2.2

### 2026-10-21 (score 40, +1)

No change was recorded against any check on this day. Stability & Change Management went from 20 to 23. That category is still filling its 30-day observation window: 6 days of observed history at the previous scan, 7 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-20 (score 39, 0)

- [functional] Package version: 0.2.0 → 0.2.1

### 2026-10-18 (score 39, +1)

No change was recorded against any check on this day. Stability & Change Management went from 10 to 13. That category is still filling its 30-day observation window: 3 days of observed history at the previous scan, 4 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-10-17 (score 38, +1)

- [functional improvement] Stability: unverified → 0.10

### 2026-10-14 (score 37, +27)

- [security improvement] Injection markers: unverified → pass
- [security] First check of Judged manipulation: pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional] First check of Schema quality: fail
- [functional] First check of Destructive annotations: pass
- [functional] First check of Schema quality: fail
- [functional] First check of Tool coverage: 76
- [functional] First check of Schema quality: good

### 2026-10-12 (score 10)

First indexed and scored.

## MCP tools (12)

### `session.open` (~276 tokens)

Start or resume a session by session_id. Optional matrix_strategy SELECTS the criticality matrix (closed set: qualitative3x3 (default) | nasa8004_5x5); a session's strategy is fixed once opened, and you SELECT it — you cannot edit its cells. Optional analysis metadata, also fixed once opened: title, level (concept|conops|technical_plan|project_plan|implementation|verification), aspect, scope_paths[] and parent (an existing session id). Convention: session_id = <aspect>-<level>. Returns the current FmecaState including meta, matrix_strategy, matrix_scale, the active scoring_catalog, the component registry, computed criticality, signals, and readiness.

Input parameters:

- `aspect` (string): Optional. What is analysed, e.g. checkout.
- `level` (string): Optional. The level of this analysis.
- `matrix_strategy` (string): Optional. Selects the criticality matrix; default qualitative3x3. Fixed once the session is opened.
- `parent` (string): Optional. The parent session id (must exist), e.g. a technical plan's conops.
- `scope_paths` (array): Optional. Repo paths this analysis covers.
- `session_id` (string, required)
- `title` (string): Optional. A human title for the analysis.

### `append` (~434 tokens)

Append one event. Tagged by `variant`: add_failure_mode{session_id, failure_mode} | add_mitigation{session_id, mitigation} | rescore{session_id, rescore} | set_mitigation_status{session_id, mitigation_id, status (planned|implemented|verified|abandoned), evidence?[]{kind, reference, basis?}, note?} (verified needs evidence whose kind is not note) | set_failure_mode_disposition{session_id, failure_mode_id, disposition (open|accepted|excluded), rationale, approver?, evidence?[]} (accepted needs an approver; excluded needs evidence whose kind is not note). The server stamps `at` on status and disposition changes. Never delete a failure mode: exclude it. A failure_mode / rescore supplies severity_observations + probability_observations, and a mitigation supplies residual_severity_observations + residual_probability_observations (all ids from scoring.catalog) — NOT a score; the engine derives every level. Returns the recomputed FmecaState with freshly-computed criticality + signals.

Input parameters:

- `approver` (string): set_failure_mode_disposition. Required for accepted.
- `disposition` (string): set_failure_mode_disposition. accepted needs an approver; excluded needs evidence whose kind is not note.
- `evidence` (array)
- `failure_mode` (object): add_failure_mode. Besides the core fields: optional local_effect, next_effect (effect is the end effect), single_point, parent{session_id, failure_mode_id} and refs[].
- `failure_mode_id` (string): set_failure_mode_disposition.
- `mitigation` (object)
- `mitigation_id` (string): set_mitigation_status.
- `note` (string): set_mitigation_status. Optional.
- `rationale` (string): set_failure_mode_disposition. Required, non-empty.
- `rescore` (object)
- `session_id` (string, required)
- `status` (string): set_mitigation_status. verified needs evidence whose kind is not note.
- `variant` (string, required)

### `state.get` (~46 tokens)

Read-only FmecaState projection: failure modes with computed criticality/residual/standing + mitigations + issues + signals + registry + readiness.

Input parameters:

- `session_id` (string, required)

### `risk.next` (~47 tokens)

The highest-criticality UNMITIGATED failure mode to address next. Returns {risk: null} when nothing unmitigated is High/Medium.

Input parameters:

- `session_id` (string, required)

### `readiness.assess` (~58 tokens)

Compute the ReadinessReport: ready bool + residual-criticality buckets + blockers. Ready iff every failure mode is scored, no residual High/Medium remains, and no weak_mitigation_order issue stands.

Input parameters:

- `session_id` (string, required)

### `report.export` (~67 tokens)

Emit the FMECA report: a row per failure mode (component, domain, cause, effect, criticality, residual, standing, response_class, mitigations), residual buckets, an explicit accepted-risks section, and the verbatim blockers.

Input parameters:

- `session_id` (string, required)

### `scoring.catalog` (~145 tokens)

The fixed evidence→score catalog for a strategy: criteria{id, axis (severity|probability), level_ordinal, level (label), description} + the selected matrix_strategy. Optional matrix_strategy arg (default qualitative3x3). Supply these ids as severity_observations / probability_observations on append — the engine maps observations to a strategy-relative level (MAX-combine) and the matrix collapses it to criticality (low|medium|high). The model never supplies a score. A session's ACTIVE catalog is also embedded in session.open / state.get.

Input parameters:

- `matrix_strategy` (string): Optional. Which strategy's catalog to return; default qualitative3x3.

### `analyze` (~284 tokens)

Stateless one-shot FMECA: hand it an ENTIRE analysis in one call, get back the ENTIRE computed report. NO session, NO persistence, NO event log — (input) → (computed report), deterministic + idempotent. Uses the SAME kernel compute as the session path (criticality matrix, residual, standing, response_class, readiness) so it cannot diverge. Args: optional matrix_strategy (qualitative3x3 (default) | nasa8004_5x5) + failure_modes[] — each {id, component{id}, description, cause?, effect?, domain, scope?, severity_observations[], probability_observations[], mitigations[]{id, kind, description, residual_severity_observations[], residual_probability_observations[]}}. ALL observation arrays (incl. the residual ones) are ids from scoring.catalog for the SELECTED strategy (NOT scores). Returns {matrix_strategy, failure_modes[]{id, criticality, residual_criticality, standing, response_class, issues[]}, risk_ranking[] (fm ids, highest risk first), issues[], ready, blockers[]}. An unknown observation id → INVALID_OBSERVATION.

Input parameters:

- `failure_modes` (array, required): The entire batch of failure modes to analyze in one shot.
- `matrix_strategy` (string): Optional. Selects the criticality matrix; default qualitative3x3.

### `session.list` (~198 tokens)

List the analyses in the state dir (the project's .fmeca/ when there is one). Optional exact-match filters: level, aspect, parent. Returns {state_dir, sessions[]} sorted by session_id; each row is {session_id, title, level, aspect, scope_paths, parent, failure_modes (count, excluded ones left out), by_standing{unmitigated, under_mitigated, acceptable}, excluded (count), ready, ready_verified, resolution{planned, implemented, verified, abandoned}, critical_items (count), accepted_risks (count)}. A log that fails to replay is listed as {session_id, error} instead of failing the call (such rows are kept whatever the filters).

Input parameters:

- `aspect` (string): Optional. Only analyses of this aspect.
- `level` (string): Optional. Only analyses at this level.
- `parent` (string): Optional. Only children of this session id.

### `actions.suggest` (~402 tokens)

READ-ONLY. Read an analysis under a declarative risk policy and SUGGEST actions; it never changes the analysis or appends to the log. Pass exactly one of session_id or analysis ({matrix_strategy?, failure_modes[]} as for analyze). Optional: policy (a preset name or a file name in .fmeca/policies/, no paths; default compat-0.1), as_of (YYYY-MM-DD; default today, UTC; echoed back), bands[] (keep failure modes in these effective bands), tags[] (keep actions with any of these tags), required_only (keep only required actions), group_by (failure_mode|band|tag|action). Roll-ups and signoff always cover the whole analysis. Returns {policy{name,hash,class,matrix_derived_from,source}, as_of, failure_modes[]{id, inherent_band, residual_band, effective_band, confidence, fallback?, status, rationale_needed, actions[]}, excluded[], rollups, signoff{pass,reasons[]}, groups?}. Errors: POLICY_NOT_FOUND, INVALID_POLICY, POLICY_STRATEGY_MISMATCH; a malformed as_of reports INVALID_POLICY: date: ....

Input parameters:

- `analysis` (object): A one-shot analysis, the same envelope as the analyze tool. Pass exactly one of session_id and analysis.
- `as_of` (string): YYYY-MM-DD. Default: today (UTC). Echoed back.
- `bands` (array): Keep only failure modes whose effective band is listed.
- `group_by` (string): Add a groups map.
- `policy` (string): A preset name or a file name in .fmeca/policies/ (no paths, no ..). Default compat-0.1.
- `required_only` (boolean): Keep only required actions.
- `session_id` (string): A session to read. Pass exactly one of session_id and analysis.
- `tags` (array): Keep only actions carrying any of these tags.

### `policy.list` (~69 tokens)

READ-ONLY. List the risk policies actions.suggest accepts: {presets[], project[]}, each {name, hash, class, description, source}. Project policies are the files in .fmeca/policies/; one that fails to load is listed with an error instead of failing the call.

### `vet` (~340 tokens)

ADVISORY second opinion from Jev (a calibrated judgment model on OpenRouter; needs OPENROUTER_API_KEY). Pass exactly one of session_id or analysis (the analyze args shape). Asks up to max_questions (default 40, max 200) in four checks: observations (do the claimed scoring.catalog observations apply; does the next level up?), mitigations (how fully each addresses the cause; is its declared kind right?), coverage (failure classes no failure mode covers) and readiness (sound enough to sign off?). Returns {status: ok, model, usage{cost}, readiness_gate, findings[]{check, target, question_hash, probability, threshold, verdict (flag|ok; readiness concern|ok)}, skipped[] (unsent question hashes), questions_sent} or {status: vet_unavailable, reason (no_key|timeout|http_4xx|http_5xx|network|bad_response|bad_config), detail, readiness_gate}. NEVER writes and NEVER changes a score: the readiness_gate is the deterministic one; findings are probabilities to weigh, not verdicts. Excluded failure modes are skipped.

Input parameters:

- `analysis` (object): A one-shot analysis in the analyze tool's argument shape. Not with session_id.
- `checks` (array): Optional. Which checks to run; default all four. Readiness and coverage are always asked before the per-failure-mode checks.
- `max_questions` (integer): Optional. Questions to send (default 40); the rest are listed in skipped. 0 sends none.
- `session_id` (string): The session to vet. Pass this or analysis, not both.

## Diagnostics

Captured diagnostic sections: Provenance. The full working is on the page: https://verifymcp.io/servers/praxec-fmeca/ghcr-io-praxec-fmeca#diagnostics

## Score history

- 2026-10-23: 41
- 2026-10-22: 40
- 2026-10-21: 40
- 2026-10-20: 39
- 2026-10-19: 39
- 2026-10-18: 39
- 2026-10-17: 38
- 2026-10-16: 37
- 2026-10-15: 37
- 2026-10-14: 37
- 2026-10-13: 10
- 2026-10-12: 10

## Common questions

### What is the io.github.praxec/fmeca MCP server?

io.github.praxec/fmeca is an MCP server listed in the public MCP registry as io.github.praxec/fmeca. Deterministic, offline FMECA MCP server: failure modes, criticality matrix, mitigations, readiness. This page covers its container image (ghcr.io/praxec/fmeca).

### Is the io.github.praxec/fmeca MCP server safe to use?

io.github.praxec/fmeca scores 41 out of 100 on VerifyMCP. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the io.github.praxec/fmeca MCP server expose?

io.github.praxec/fmeca exposes 12 tools: session.open, append, state.get, risk.next, readiness.assess, and 7 more. Their descriptions and schemas cost roughly 2,366 tokens of context every time the server is loaded.

### Is the io.github.praxec/fmeca MCP server still maintained?

io.github.praxec/fmeca is still listed as active in the MCP registry. We last reached this channel on 23 October 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the io.github.praxec/fmeca MCP server under?

io.github.praxec/fmeca declares the Apache-2.0 licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

## Links

- GitHub Container Registry: https://ghcr.io/praxec/fmeca
- Repository: https://github.com/praxec/fmeca
- Changelog RSS feed: https://verifymcp.io/servers/praxec-fmeca/ghcr-io-praxec-fmeca.xml
- Changelog JSON feed: https://verifymcp.io/servers/praxec-fmeca/ghcr-io-praxec-fmeca.json
- HTML version of this page: https://verifymcp.io/servers/praxec-fmeca/ghcr-io-praxec-fmeca