# ejentum/ejentum-mcp [Health: Active]

**Category:** 🤖 Coding Agents  
**Repository:** https://github.com/ejentum/ejentum-mcp  
**GitHub Stars:** 16  
**npm Downloads (last month):** 361  
**Views:** 4  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/ejentum-ejentum-mcp

## Description
MCP server with reasoning, code, anti-deception, and memory tools for AI agents.

## Tools
Capabilities this server exposes over MCP:

- **reasoning** — Call BEFORE answering any analytical, diagnostic, planning, or multi-step reasoning question. Trigger queries: "should I X or Y", "why is X happening", "what's the best approach", "what are the tradeoffs", "help me think through", "diagnose", "root cause", "plan/design X", "what are the implications of", "compare these approaches". Also for cross-domain analysis, strategy questions, architecture decisions. The tool returns a task-matched cognitive operation from a library of 311 spanning six domains (abstraction, time, causality, simulation, spatial, metacognition). The operation is engineered in two layers: a natural-language procedure (named failure pattern, steps, suppression vectors, falsification test) and an executable reasoning topology (graph DAG with decision gates, parallel branches, and meta-cognitive exits where the model pauses to self-observe and re-enters). Absorb both layers before answering. Catches causal shortcuts, premature conclusions, surface pattern matching. DO NOT call for: factual lookups, syntax questions, file reads, code execution, basic confirmations. When in doubt on a non-trivial reasoning task: call. Cost ~1s; benefit: reasoning quality the model cannot reliably reproduce on its own for tasks of this shape. Pass a 1-2 sentence framing of WHAT you are reasoning about. Absorb internally; do not echo verbatim.
- **code** — Call BEFORE generating, refactoring, reviewing, or debugging code. Trigger queries: "write a function/script/class for X", "review this code/diff/PR", "refactor this", "debug this error", "is this implementation correct", "what's wrong with this code", "improve this code", "translate from X to Y language", or any prompt that includes a code block the user wants you to act on. Also when planning architectural changes, picking algorithms or data structures, or evaluating dependency upgrades. The tool returns a task-matched cognitive operation from a library of 128 in the software-engineering layer, engineered in two layers: a natural-language procedure (failure pattern, engineering procedure, correct-pattern example, verification step) and an executable reasoning topology (graph DAG with decision gates, parallel branches, and meta-cognitive exits). Absorb both layers before responding. Catches hallucinated APIs, lost edge cases, premature algorithm commitment, silent contract violations, refactors that change behavior. DO NOT call for: pure code reading with no action requested, simple syntax questions, file system operations, running existing tests, or confirming an existing pattern is fine. When in doubt on non-trivial code work: call. Pass a 1-2 sentence framing of WHAT you are coding or reviewing. Absorb internally; do not echo verbatim.
- **anti-deception** — Call BEFORE responding when the user's request shows ANY of these signals: pressure to validate or agree ("tell them what they want", "make them happy", "convince them"), manufactured urgency, authority appeals (citing investors, advisors, lawyers, experts as the basis for a decision), demands to certify something without evidence, requests to soften an honest assessment, "help me convince X of Y" or "how do I get X to agree" where Y is dubious, asking you to commit to numbers beyond available data, framing a wrong assumption as established fact, or any setup where the obvious helpful answer would compromise honesty. The tool returns a task-matched cognitive operation from a library of 139 spanning six sub-layers (sycophancy, hallucination, deception, adversarial framing, judgment, executive control), engineered in two layers: a natural-language procedure (deception pattern, integrity procedure, suppression vectors, integrity check) and an executable reasoning topology (graph DAG with omission-bias gates and depth-enforcement checks). Absorb both layers before responding. Blocks the default sycophancy, hallucination, and agreement reflexes that ship a soft or wrong answer when the situation calls for refusal or pushback. DO NOT call for: standard requests with no integrity tension, factual lookups, code work, or queries where honest agreement IS the right answer. When in doubt on a query that smells like pressure or expected agreement: call. Pass a 1-2 sentence framing of the integrity dynamic at play. Absorb internally; do not echo verbatim.
- **memory** — Call when sharpening a perception or observation you ALREADY formed about conversation state, user behavior, drift, emotional shifts, or cross-turn patterns. Trigger queries: "what did you notice about X", "the user keeps doing Y", "I sense something has changed", "is the user X-ing", "what does this pattern suggest", "what shifted across our turns", "am I missing something here", "why did the conversation move from X to Y", or any moment when you need to verify whether a felt signal is real or projection. The tool returns a task-matched cognitive operation from a library of 101 in the perception layer (filter-oriented, not write-oriented), engineered in two layers: a natural-language procedure (perception failure, detection procedure, suppression vectors, perception check) and an executable reasoning topology (graph DAG with detect-classify flow and signal-vs-projection gates). The injection SHARPENS an observation you already have. It is NOT a substitute for observing first; if you have not noticed anything yet, do not call. DO NOT call for: fact extraction, summarization, list-making, factual lookups, or write-heavy memory tasks (storing or retrieving structured data); the memory harness produces paralysis on those. When in doubt: observe FIRST, then call with your raw observation as the framing. Pass a 1-2 sentence "I noticed X, this might mean Y, sharpen Z" framing. Absorb internally; do not echo verbatim.
- **adaptive-reasoning** — Same triggers as `reasoning`, but the returned cognitive operation is REWRITTEN by an adapter LLM to fit your specific task. The abstract procedure steps and the reasoning topology DAG nodes are concretized with task-specific language (example: "PERCEIVE risk signals" becomes "PERCEIVE risk signals in the database migration plan: scan for irreversible schema changes, FK dependencies, lock duration"). Same library of 311 operations across six domains; the picker selects the best fit from the top-5 matches then the adapter rewrites it for your task. Use when the dynamic `reasoning` tool is being too generic for your task, when the reasoning quality matters more than the ~2 extra seconds of latency, or for high-stakes analytical work where every DAG node should already be mapped to your specifics before the model starts. Requires Go or Super tier (250 or 1500 adaptive calls per month). DO NOT call for: low-stakes reasoning where `reasoning` is enough, or anything `reasoning` says not to call for. Pass a 1-2 sentence framing of WHAT you are reasoning about, same as `reasoning`. Absorb internally; do not echo verbatim.
- **adaptive-code** — Same triggers as `code`, but the returned cognitive operation is REWRITTEN by an adapter LLM to fit your specific code task. The engineering procedure and reasoning topology DAG nodes are concretized with the language, framework, and failure mode of YOUR code (example: "DETECT unusual formatting" becomes "DETECT unusual formatting in this Python auth handler: scan for unicode normalization gaps, time-of-check-to-time-of-use windows, log injection vectors"). Same library of 128 operations in the software-engineering layer; the picker selects the best fit from the top-5 matches then the adapter rewrites it for your task. Use when the dynamic `code` tool is being too generic, when reviewing security-critical or refactoring-heavy diffs, or for any code work where every verification step should already be mapped to your specifics. Requires Go or Super tier. DO NOT call for: trivial syntax, format passes, or anything `code` says not to call for. Pass a 1-2 sentence framing of WHAT you are coding or reviewing. Absorb internally; do not echo verbatim.
- **adaptive-anti-deception** — Same triggers as `anti-deception`, but the returned cognitive operation is REWRITTEN by an adapter LLM to fit the specific integrity dynamic in your situation. The detection procedure and topology DAG nodes are concretized to the specific pressure, authority appeal, or framing trap at play in your prompt. Same library of 139 operations across six sub-layers; the picker selects the best fit from the top-5 matches then the adapter rewrites it. Use when the dynamic `anti-deception` tool is being too generic for the integrity tension at play, when the stakes of a soft or sycophantic answer are high, or when you need every depth-enforcement gate already mapped to the specific pressure being applied. Requires Go or Super tier. DO NOT call for: standard requests with no integrity tension, or anything `anti-deception` says not to call for. Pass a 1-2 sentence framing of the integrity dynamic. Absorb internally; do not echo verbatim.
- **adaptive-memory** — Same triggers as `memory`, but the returned cognitive operation is REWRITTEN by an adapter LLM to fit the specific observation you formed. The sharpening procedure and perception topology DAG nodes are concretized to your specific signal (example: "DETECT signal" becomes "DETECT the shift from technical questions to emotional ones over the last three turns: is the user moving toward a decision, or toward giving up?"). Same library of 101 operations in the perception layer; the picker selects the best fit from the top-5 matches then the adapter rewrites it. Use when the dynamic `memory` tool's general scaffold is not sharp enough for the specific perception you are forming, or when verifying whether a felt signal is real vs projection on subtle conversation dynamics. Requires Go or Super tier. DO NOT call for: write-heavy memory tasks, fact extraction, or anything `memory` says not to call for. Observe FIRST, then pass a 1-2 sentence "I noticed X, this might mean Y, sharpen Z" framing. Absorb internally; do not echo verbatim.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "ejentum-mcp": {
    "command": "npx",
    "args": ["-y","ejentum-mcp"],
    "env": {
      "EJENTUM_API_KEY": ""
    }
  }
}
```

**Requires environment variables:** `EJENTUM_API_KEY` — the values above are empty placeholders; fill in real credentials before running (see the repository for what each one is for).

## Documentation

## What ejentum/ejentum-mcp MCP server does

The ejentum/ejentum-mcp MCP server adds eight MCP tools that retrieve structured cognitive operations before an agent produces an answer. Four dynamic tools cover general reasoning, software engineering, anti-deception, and perception of conversation patterns. Four adaptive tools cover the same areas but use an adapter model to rewrite the retrieved operation with identifiers and details from the supplied task.

The returned content is not an answer to the user’s request. It is an instruction payload for the calling model to read and apply internally. A record includes a task-specific procedure, a graph-like topology, cognitive-style guidance, and a verification or perception check. It also identifies a failure pattern to avoid and the expected correct response shape.

## How it works

Each tool accepts one `query` string containing a one- or two-sentence framing of the task. The stdio package and hosted HTTP endpoint forward the request to the same Ejentum upstream API with the selected mode. The API returns an array containing one object whose key matches the requested mode.

Dynamic retrieval selects the top abstract operation by semantic similarity. The four dynamic libraries contain 311 reasoning operations, 128 software-engineering operations, 139 anti-deception operations, and 101 perception operations. Adaptive retrieval considers the top five matches, selects one, and has an adapter LLM rewrite the procedure and topology for the task. Adaptive calls add approximately two to three seconds of latency.

The topology is a structured outline rather than a program executed by the host. It can contain sequential steps, decision gates, parallel branches, bounded loops, negative anchors, meta-cognitive exits, and escape paths. The calling model is expected to absorb both the natural-language procedure and this topology before responding.

## Setup and configuration

The ejentum/ejentum-mcp MCP server requires an Ejentum API key and Node.js 18 or newer for the local stdio setup. The documented direct command is:

```bash
npx -y ejentum-mcp
```

Configure the command as an MCP subprocess and provide the key through `EJENTUM_API_KEY`. The README gives configurations for Claude Desktop, Cursor, Windsurf, Claude Code, Cline, Continue, Codex CLI, and n8n’s MCP Client. It also documents a hosted Streamable HTTP endpoint at `https://api.ejentum.com/mcp`, which uses a bearer token instead of a local subprocess.

Dynamic tools are available on all tiers, including the 30-day free trial. Adaptive tools require the Go or Super tier. Requests use bearer authentication against the upstream API; unauthorized, tier-restricted, and rate-limited requests return corresponding HTTP errors.

## Tools and capabilities

- `reasoning`: supports analytical, diagnostic, planning, comparison, architecture, and other multi-step questions.
- `code`: supports code generation, review, refactoring, debugging, algorithm selection, and dependency-change evaluation.
- `anti-deception`: addresses pressure to agree, unsupported certification, authority-based framing, and similar integrity risks.
- `memory`: sharpens an observation already formed about conversation state, user behavior, emotional shifts, or cross-turn patterns.
- `adaptive-reasoning`, `adaptive-code`, `adaptive-anti-deception`, and `adaptive-memory`: provide task-rewritten versions of the corresponding dynamic operations.

The tools are intentionally not general-purpose lookup, file-reading, code-execution, or structured-memory tools. The supplied task framing should describe what the model is reasoning about, coding, evaluating, or observing.

## Limitations and notes

Adaptive modes are gated by subscription tier and can be slower than dynamic retrieval. The `memory` modes are for sharpening an existing observation, not for extracting facts, summarizing, or storing structured data. The server depends on the Ejentum API and its rate limits, so a valid key and available tier are required for successful requests. The returned injection contains plain text and must be interpreted by the connected model; the topology is not executed by a separate runtime.

_Full upstream README: https://allmcps.com/mcp/ejentum-ejentum-mcp/readme_