# OpenReflex (pypi · openreflex)

Optional diagnostics MCP server for OpenReflex's ambient project muscle memory.

- Trust score: 36/100 (low)
- Change this week: −32
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-09-23

## Components

- pypi · `openreflex`: 36/100 (this document), [markdown](https://verifymcp.io/servers/vishnu-77-openreflex/openreflex.md), [page](https://verifymcp.io/servers/vishnu-77-openreflex/openreflex)

## Channel facts

- Registry: `pypi`
- Package: `openreflex`
- Version: `0.9.6`
- 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-09-23.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised native-build step with no shell scripting around it.
  - 0 of 29 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 32/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - License check failed: no license is declared.
  - Actively maintained (last published 0 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 0/100
  - Schema quality not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- **Tool Coverage**: 0/100
  - Tool coverage not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- **Tool Safety**: 0/100
  - Tool safety not yet verified: we do not have a sandbox capture of the tool definitions this version of the package serves yet.
- **Capabilities**: 0/100
  - Protocol version not yet verified: we do not have a sandbox capture of the MCP handshake this version of the package performs yet.

**Unverified: 5 categories.** Categories scored 0 because our sandbox run of this package has not given us the schema these checks need to read. That is a gap on our side rather than a finding about the package, and we only credit what we can confirm, so the score stands at 0 until the capture succeeds. We are working through the fleet, so this normally clears without any action from you.

## Install

### How do I install the OpenReflex MCP server?

OpenReflex runs locally as a PyPI package, launched with uvx openreflex. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add vishnu-77-openreflex -- uvx openreflex
```

### Cursor

```json
{
  "mcpServers": {
    "vishnu-77-openreflex": {
      "command": "uvx",
      "args": [
        "openreflex"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "vishnu-77-openreflex": {
      "command": "uvx",
      "args": [
        "openreflex"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add vishnu-77-openreflex -- uvx openreflex
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "vishnu-77-openreflex": {
      "type": "local",
      "command": [
        "uvx",
        "openreflex"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add vishnu-77-openreflex --command uvx --arg openreflex
```

### Hermes

```yaml
mcp_servers:
  vishnu-77-openreflex:
    command: "uvx"
    args: ["openreflex"]
```

### Netclaw

```json
{
  "McpServers": {
    "vishnu-77-openreflex": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "openreflex"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add vishnu-77-openreflex -t stdio -c uvx -a openreflex
```

### Other

```json
{
  "mcpServers": {
    "vishnu-77-openreflex": {
      "command": "uvx",
      "args": [
        "openreflex"
      ]
    }
  }
}
```

## 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-09-23 (score 36, 0)

- [security improvement] Injection markers: unverified → pass
- [functional regression] Schema quality: 2500 → 2809
- [functional regression] Schema quality: 2500 → 2807
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Stability: unverified → 0.30
- [functional] Package version: 0.9.2 → 0.9.6
- [functional] Package version: 0.9.2 → 0.9.5
- [functional] Package version: 0.5.0 → 0.9.4

### 2026-09-22 (score 36, 0)

- [functional] Package version: 0.5.0 → 0.9.2
- [functional] Package version: 0.8.0 → 0.9.1

### 2026-09-21 (score 36, 0)

- [security regression] Malware scan: pass → unverified
- [security improvement] Injection markers: unverified → pass
- [functional regression] Schema quality: 2500 → 2811
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Stability: unverified → 0.23
- [functional] Package version: 0.5.2 → 0.8.0
- [functional] Package version: 0.5.2 → 0.7.0
- [functional] Package version: 0.5.2 → 0.5.3

### 2026-09-20 (score 36, 0)

- [security improvement] Injection markers: unverified → pass
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] Stability: unverified → 0.20
- [functional improvement] MCP protocol: unverified → pass
- [functional] Package version: 0.5.1 → 0.5.2
- [functional] Package version: 0.5.0 → 0.5.1

### 2026-09-19 (score 36, −33)

- [security regression] Stability: 0.13 → unverified
- [security regression] Tool safety: pass → unverified
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified
- [functional] Package version: 0.5.0 → 0.5.1

### 2026-09-18 (score 69, +15)

- [security regression] Tool safety: pass → unverified
- [security regression] Stability: 0.10 → unverified
- [security improvement] Malware scan: unverified → pass
- [functional regression] Capabilities: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified
- [functional] Package version: 0.3.2 → 0.5.0

### 2026-09-17 (score 54, −14)

- [security regression] Malware scan: pass → unverified

### 2026-09-16 (score 68, +15)

- [security improvement] Malware scan: unverified → pass

## MCP tools (14)

### `get_execution_context` (~323 tokens)

Get execution context

Plan a task from this project's past experience.
Returns: plain text with the learned project Reflex procedure when one applies; otherwise a neutral working
approach, relevant past experience, budget, likely files/sources and lessons. Internal strategy names and
candidate scores are deliberately omitted from this normal surface; use get_candidate_paths for diagnostics.
Use when: starting any substantial coding, investigation, research, analysis, review, planning or reasoning task
and no [OpenReflex] block was injected.
Not for: looking up history (use search_experience) or checking progress mid-task (use check_progress).
Side effects: starts or re-plans the current task in the local Experience Graph; touches no project files,
runs no commands, sends nothing over the network. Calling it again for the same task returns the same plan
unless new limits are given.
Errors: invalid non-positive limits are rejected by the input schema; a 'not enabled' message is returned
until the project is approved.

Input parameters:

- `max_context_tokens`: Optional cap on tokens of tool output added to context; a positive integer. Default: no cap.
- `max_minutes`: Optional cap on active working time in minutes; a positive number. Default: no cap.
- `max_tool_calls`: Optional cap on tool calls for this task; a positive integer. Default: no cap.
- `task` (string, required): The task in one or two plain sentences, e.g. 'Fix the login redirect loop after logout'. Used to find similar past tasks; secrets are redacted before it is stored.

Output parameters:

- `result` (string)

### `check_progress` (~185 tokens)

Check progress

Estimate whether more work on the current task's path is still worth it.
Returns: plain text starting with 'Recommendation: continue', 'pivot' or 'stop', then the success estimates
for the current path and the best alternative, the marginal value of each option, the execution budget and
how much of it is used, and any detected problems (failure loop, repeated calls, stalled progress, context
growth, budget overrun).
Use when: unsure mid-task whether to keep going. Follow 'pivot' by switching to the named strategy; follow
'stop' by summarizing what was tried and asking the user.
Not for: planning a task (use get_execution_context).
Side effects: none; read-only on the most recent task.
Errors: asks for get_execution_context first when no task exists; a 'not enabled' message until the project
is approved.

Output parameters:

- `result` (string)

### `explain_decision` (~162 tokens)

Explain decision

Explain OpenReflex's latest recommendation for the most recent task.
Returns: plain text with the recommended strategy, the Reflex Score (0-100: how strong the recommendation
is, not the chance of success), the estimated success probability, confidence, the signals behind the
score, the next-best strategy with its route advantage, and the policy version.
Use when: the user asks why OpenReflex suggested a path, pivot or stop.
Not for: the same numbers as structured data (use get_reflex_score) or every decision in order (use
get_execution_trace).
Side effects: none; read-only.
Errors: 'No decision snapshot recorded yet' before any task was planned; a 'not enabled' message until the
project is approved.

Output parameters:

- `result` (string)

### `get_execution_trace` (~124 tokens)

Get execution trace

Return the decision timeline of the most recent task.
Returns: plain text, one line per decision in order, with elapsed time, phase (start, runtime, complete),
action, strategy, Reflex Score and the event that triggered it. Never includes prompts, commands or tool
output.
Use when: reviewing how a task unfolded.
Not for: only the latest decision (use explain_decision).
Side effects: none; read-only.
Errors: 'No decision snapshots recorded yet' before any task was planned; a 'not enabled' message until the
project is approved.

Output parameters:

- `result` (string)

### `get_candidate_paths` (~171 tokens)

Get candidate paths

Show every candidate path OpenReflex considered for the most recent task side by side.
Returns: plain text with each strategy's score, success probability, cost/risk numbers, and whether it
was dominated; which path was recommended; and which one was actually followed - explicit (via
choose_path), inferred from tool-call evidence, or not yet determined while the execution is still
running.
Use when: the user asks what other approaches were considered, or whether the agent followed the
suggested path.
Not for: a single recommendation's reasoning (use explain_decision) or the decision timeline (use
get_execution_trace).
Side effects: none; read-only.
Errors: 'No execution recorded yet' before any task was planned; a 'not enabled' message until the
project is approved.

Output parameters:

- `result` (string)

### `get_project_reflexes` (~148 tokens)

Get project Reflexes

Show the project Reflex and specialised procedures OpenReflex is learning from repeated work.
Returns: the root Project Reflex after the first captured experience, plus specialised Reflexes with
learning/learned/proven/stale maturity, support/verification counts and procedure steps.
Use when: the user asks what OpenReflex has learned specifically about this project, which reusable procedures
exist, or how a named Reflex works.
Not for: backend routing internals or generic strategies (use get_candidate_paths for those diagnostics).
Side effects: may refresh derived local Reflex data from already-captured evidence; touches no project files.
Errors: a 'not enabled' message is returned until the project is approved.

Output parameters:

- `result` (string)

### `get_reflex_score` (~146 tokens)

Get Reflex Score

Return the latest decision's Reflex Score and machine-readable components.
Returns: structured fields for availability, Reflex Score (0-100 recommendation strength, not success
probability), success probability, confidence, strategy, next-best strategy, route advantage, evidence,
context cost, budget use, component signals and policy version. If no decision exists, available=false and
reason explains why.
Use when: a program or agent needs decision numbers it can inspect without parsing prose.
Not for: a readable explanation (use explain_decision) or the full decision timeline (use get_execution_trace).
Side effects: none; read-only.
Errors: an MCP error is returned until the project is approved.

Output parameters:

- `available` (boolean): Whether a decision snapshot is available for the most recent decided task.
- `budget_used`: Largest fraction of the task budget consumed across time, calls and context.
- `context_tokens`: Estimated tokens injected from prior experience for this task.
- `decision_confidence`: Confidence in the recommendation from the available evidence.
- `evidence_count`: Number of relevant prior experiences supporting the decision.
- `next_best_strategy`: Highest-ranked alternative strategy, if any.
- `policy_version`: OpenReflex decision-policy version used for the score.
- `reason`: Why no score is available, when available is false.
- `reflex_score`: Strength of the recommendation on a 0-100 scale; not success probability.
- `route_advantage`: Normalised advantage of the recommended route over the next best route.
- `signals` (object): Normalised component signals used to compute the Reflex Score.
- `strategy`: Recommended strategy for the latest decision.
- `success_probability`: Estimated probability of success for the recommended strategy.

### `choose_path` (~227 tokens)

Choose path

Declare the strategy you are following for the most recent task.
Returns: one line, 'Recorded chosen path: <strategy>'.
Use when: deliberately departing from the suggested path, so OpenReflex remembers what was actually done
rather than confusing the recommendation with the observed work.
Not for: tasks that follow the suggestion; the path is then inferred from tool activity.
Side effects: writes the choice to the local Experience Graph; calling it again replaces the earlier choice.
Touches no project files.
Errors: 'No current execution' before any task was planned (call get_execution_context first); a 'not
enabled' message until the project is approved.

Input parameters:

- `steps`: For a custom strategy only: 2-4 short steps, e.g. ['Prototype the toml loader', 'Swap the callers']. Ignored for suggested strategies.
- `strategy` (string, required): The strategy being followed: one of the suggested names 'inspect-first', 'test-first' or 'incremental', or a short kebab-case name for your own, e.g. 'spike-then-rewrite'.

Output parameters:

- `result` (string)

### `record_outcome` (~259 tokens)

Record outcome

Record the verified outcome of the most recent task and learn from it.
Returns: the recorded status plus a plain-language Path check. A better path is only named when comparable
completed tasks provide evidence; otherwise the result says that no better option is proven.
Use when: the result is confirmed: tests/lint/build passed, research was cross-checked against relevant
evidence, the user confirmed the answer, or the task failed/was abandoned.
Not for: declaring the strategy (use choose_path).
Side effects: finalizes the task in the local Experience Graph and updates its experience, lessons and
path comparison; calling it again for the same task replaces the recorded outcome. Touches no project files.
Errors: 'No execution to record an outcome for' before any task was planned; a 'not enabled' message until
the project is approved.

Input parameters:

- `evidence` (string, required): Short proof of the result, e.g. 'pytest tests/test_auth.py passed' or 'user confirmed the fix'. Secrets are redacted.
- `status` (string, required): 'success' when the result is confirmed (tests/builds passed, research was cross-checked, or the user confirmed it); 'failure' when the task failed or was abandoned.

Output parameters:

- `result` (string)

### `search_experience` (~212 tokens)

Search experience

Search this project's past tasks by description similarity.
Returns: structured 'experiences' (id, score, description, class, agent, strategy, status, tool_calls,
minutes, files), best match first, plus structured 'lessons' (text, confidence, support). Both lists are empty
when nothing is similar enough.
Use when: the user asks what was learned or what worked before, or to find an experience id for
explain_node or forget_experience.
Not for: planning a new task (use get_execution_context).
Side effects: none; read-only. Matching is lexical, on task descriptions only.
Errors: invalid limit values are rejected by the input schema; an MCP error is returned until the project is
approved.

Input parameters:

- `limit` (integer): Maximum number of past tasks to return. Default 5; allowed 1-20.
- `query` (string, required): Words describing the topic, e.g. 'expired token login bug'. Matched lexically against past task descriptions.

Output parameters:

- `experiences` (array): Matching past tasks ordered from best to worst match.
- `lessons` (array): Lessons derived from the returned experiences.

### `explain_node` (~199 tokens)

Explain graph node

Show one Experience Graph node with its direct relations.
Returns: structured 'root', 'nodes' (Task, Execution, ToolCall, Outcome, Experience, Lesson, Context or
CandidatePath and their stored fields) and typed 'edges' (used, caused, failed_with, resolved_by,
recommended_for). Embeddings are omitted.
Use when: tracing why a lesson or recommendation exists, after finding an id with search_experience or
get_execution_context.
Not for: searching by topic (use search_experience).
Side effects: none; read-only.
Errors: an MCP error reports 'Unknown graph node' for an id that does not exist, and an MCP error is returned
until the project is approved.

Input parameters:

- `node_id` (string, required): Id of an Experience Graph node: an experience id from search_experience (starts with 'exp-'), the execution id from get_execution_context, or any node id from an earlier explain_node result.

Output parameters:

- `edges` (array): Direct typed relationships to or from the root node.
- `nodes` (array): The root node and directly related nodes; embeddings are omitted.
- `root` (string): Id of the graph node that was requested.

### `get_project_insights` (~133 tokens)

Get project insights

Summarize what OpenReflex has recorded and learned in this project.
Returns: structured activation, engagement, experience reuse, outcomes, observational efficiency with and
without prior experience, path-comparison trends, routing agreement, live alerts, execution-control metrics
and lesson count. Efficiency comparisons are observational and are not presented as causal evidence.
Use when: the user asks how OpenReflex is doing in this project or a program needs project-level metrics.
Not for: individual past tasks (use search_experience).
Side effects: none; read-only.
Errors: an MCP error is returned until the project is approved.

Output parameters:

- `activation`: Activation and first-use metrics.
- `efficiency_observational`: Observed efficiency with versus without reused experience; this is not a controlled comparison.
- `engagement`: Capture and usage volume.
- `execution_control`: Runtime verdict and budget-adherence metrics.
- `experience_reuse`: How often prior experience was reused.
- `lessons` (integer): Number of extracted lessons retained in this project.
- `live_alerts` (object): Counts of loop, repetition, stagnation, context and budget alerts.
- `outcomes`: Known and verified outcome coverage.
- `path_check`: Simple evidence-backed path comparison counts.
- `project` (string): Local project path represented by this Experience Graph.
- `project_reflexes`: Project-specific reusable procedures learned from execution evidence.
- `routing`: Recommendation agreement with retrospective realised performance.

### `approve_project` (~170 tokens)

Enable project

Enable OpenReflex capture for this project.
Returns: one line confirming the project is enabled, or 'Not approved' when confirm is false.
Use when: the user explicitly asks to enable OpenReflex here. Never call it on your own initiative; the user
can also run `openreflex approve`, and `openreflex revoke` disables capture again.
Not for: anything else; every other tool answers with a 'not enabled' message until this has happened.
Side effects: writes the project's approval to the local OpenReflex home; enabling an already enabled
project changes nothing. Touches no project files.
Errors: none.

Input parameters:

- `confirm` (boolean): true only when the user has explicitly asked to enable OpenReflex for this project; with false (the default) nothing changes.

Output parameters:

- `result` (string)

### `forget_experience` (~229 tokens)

Forget experience

Delete one past task from this project's memory.
Returns: one line listing what was removed (task, executions, tool calls, outcomes, experience, lessons), or
'Not forgotten' when confirm is false.
Use when: the user explicitly asks to forget a specific past task, for example one that involved sensitive
work or taught a wrong lesson. Never call it on your own initiative.
Not for: deleting everything; the user runs `openreflex forget --yes` for that.
Side effects: permanently removes that task's nodes from the local Experience Graph; other tasks are
untouched. Touches no project files.
Errors: 'Unknown experience id' for an id that does not exist, is not an experience, or was already
forgotten; a 'not enabled' message until the project is approved.

Input parameters:

- `confirm` (boolean): true only when the user has explicitly asked to forget this task; with false (the default) nothing is deleted.
- `experience_id` (string, required): The experience id to delete, as returned by search_experience; starts with 'exp-'.

Output parameters:

- `result` (string)

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/vishnu-77-openreflex/openreflex#diagnostics

## Score history

- 2026-09-23: 36
- 2026-09-22: 36
- 2026-09-21: 36
- 2026-09-20: 36
- 2026-09-19: 36
- 2026-09-18: 69
- 2026-09-17: 54
- 2026-09-16: 68
- 2026-09-15: 53
- 2026-09-14: 67

## Common questions

### What is the OpenReflex MCP server?

OpenReflex is an MCP server listed in the public MCP registry as io.github.vishnu-77/openreflex. Optional diagnostics MCP server for OpenReflex's ambient project muscle memory. This page covers its PyPI package (openreflex).

### Is the OpenReflex MCP server safe to use?

OpenReflex scores 36 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 23 September 2026. 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 OpenReflex MCP server expose?

OpenReflex exposes 14 tools: get_execution_context, check_progress, explain_decision, get_execution_trace, get_candidate_paths, and 9 more. Their descriptions and schemas cost roughly 2,688 tokens of context every time the server is loaded.

### Is the OpenReflex MCP server still maintained?

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

## Links

- PyPI project: https://pypi.org/project/openreflex/
- Socket report: https://socket.dev/pypi/package/openreflex
- Repository: https://github.com/vishnu-77/openreflex
- Website: https://openreflex.cc/
- Changelog RSS feed: https://verifymcp.io/servers/vishnu-77-openreflex/openreflex.xml
- Changelog JSON feed: https://verifymcp.io/servers/vishnu-77-openreflex/openreflex.json
- HTML version of this page: https://verifymcp.io/servers/vishnu-77-openreflex/openreflex