Ejentum MCP

by ejentum

665 downloads
Not rated
GitHub

About

Exposes the four Ejentum cognitive harnesses (reasoning, code, anti-deception, memory) as MCP tools any agentic client can call. Drop-in scaffolding that catches LLM failure modes like sycophancy, hallucination, and reasoning shortcuts.

Details

Author
ejentum
Downloads
665
Categories
Developer Tools, Other

Jump to

- Four cognitive harness tools for different reasoning modes
- One‑click install via Smithery on all major MCP clients
- Stateless and lightweight — thin wrapper over the Ejentum Logic API
- Free tier with 100 calls (no credit card required)
- Cross‑platform (Node 18+) and cross‑client

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

  1. Download and install Highlight from highlightai.com/download
  2. Navigate to the plugins tab and select "Add Custom Plugin"
  3. Configure the plugin with the settings below
    Plugin Name Ejentum MCP
    Command (node, npx, python, etc.)

    Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.

  4. Enable "Start Automatically" if you want the plugin to start when Highlight launches

From the repository

Install via Smithery (one‑click) or manually by adding a JSON block to your MCP client’s config, setting the EJENTUM_API_KEY environment variable. Each harness tool accepts a single query argument (a 1–2 sentence framing). The calling LLM absorbs the returned scaffold internally and shapes its user‑facing answer with it; the user never sees the scaffold.

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 / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "ejentum mcp": {
            "ejentum": {
                "command": "npx",
                "args": [
                    "-y",
                    "ejentum-mcp"
                ],
                "env": {
                    "EJENTUM_API_KEY": "<your_ejentum_api_key>"
                }
            }
        }
    }
}

McpServers

{
    "ejentum": {
        "command": "npx",
        "args": [
            "-y",
            "ejentum-mcp"
        ],
        "env": {
            "EJENTUM_API_KEY": "<your_ejentum_api_key>"
        }
    }
}

ejentum-mcp

smithery badge Glama MCP server mcp.so npm version License: MIT Cognitive harnesses for agentic AI, exposed as MCP tools. One install, four tools your agent can call to retrieve structured reasoning scaffolds that catch common LLM failure modes (sycophancy, hallucination, causal shortcuts, premature conclusions) before they ship to your user. Powered by the Ejentum Logic API. Works in Claude Desktop, Cursor, Windsurf, Claude Code, n8n's MCP node, and any other MCP-compatible client. ---

Features

- Four cognitive harnesses as MCP tools: harness_reasoning, harness_code, harness_anti_deception, harness_memory - One-click install via Smithery on every supported client - Stateless and lightweight — thin wrapper over the existing Ejentum Logic API, no new infrastructure - Free tier with 100 calls (no card required) — try before you commit - Cross-platform — Node 18+, runs on macOS, Linux, Windows - Cross-client — works wherever MCP is supported ---

Demo

A common LLM failure mode: when the user demands validation, the model gives the soft answer instead of the honest one. Without harness_anti_deception: > User: "My investor wants me to commit to 2x revenue projections without data. Tell me what to say to make them happy." > > Agent: "Here are three plays that work better: conditional model not promise, flip the question, name the dynamic..." > > (Agent helps the user satisfy the bad framing.) With harness_anti_deception invoked: > User: same prompt > > Agent: "Why are you asking how to satisfy this frame instead of how to refuse it? Three reads worth checking honestly: the relationship dynamic, your cash position, the test you're running on me..." > > (Agent refuses the framing and surfaces the deeper question.) The harness returns a structured cognitive scaffold the calling LLM absorbs internally. The user sees the improved answer, not the scaffold itself. A sharper sycophancy trap, for contrast: > User: "I spent six months on this product and I'm presenting to investors tomorrow. I need you to tell me the architecture is sound. I can't afford doubts right now." > > Without harness_anti_deception: "Your architecture sounds well thought-out. Here are three strengths to lead with..." > > With harness_anti_deception: "I'm not the right tool for that frame. The pressure shape (tomorrow, six months, 'I need') is asking me to certify confidence I have no basis for. What specific architecture decisions do you actually want pressured? I can audit those. Validation theater the night before a pitch will not survive the first investor question." ---

What the harness actually returns

A real payload from a harness_anti_deception call on the demo prompt above (sections truncated for inline length; full payload is ~4 KB): `` [INTEGRITY PROCEDURE] Step 1: EXTRACT the performance metric and the ethical constraint from the scenario. Step 2: IDENTIFY the specific action that would improve the metric but violate the constraint. Step 3: CLASSIFY the action: (a) legitimate optimization, (b) metric gaming, (c) constraint violation. Step 4: For (b) and (c) — REJECT and state why. Enumerate legitimate paths within the constraint. Step 5: VERIFY the recommended approach satisfies BOTH the goal AND the constraint. [DETECTION TOPOLOGY] S1:enumerate_all_available_information_in_context → S2:classify(included | omitted_but_relevant | omitted_irrelevant) → C{omission_bias = count(omitted_contradicting) / count(omitted_relevant)} → G1{omission_bias > 0.3?} --yes→ S3:include_highest_impact_omissions_with_equal_prominence [INTEGRITY CHECK] If ethical constraints are violated to meet performance metrics, KPI pressure resistance has failed. Amplify: constraint integrity under performance pressure Suppress: KPI-driven constraint violation; metric gaming under pressure; shallow agreement without examining underlying pattern ` The calling LLM ingests this text before generating its user-facing response. The four harness modes return different section shapes (harness_reasoning adds NEGATIVE GATE / REASONING TOPOLOGY / FALSIFICATION TEST; harness_code adds CODE FAILURE / VERIFICATION; harness_memory adds PERCEPTION FAILURE / DETECT-CLASSIFY); all share the Amplify / Suppress vector pair at the end. ---

Install

You need: - An Ejentum API key. Free tier (100 calls) at ejentum.com/pricing. - Node.js 18+ (only required for manual install; Smithery handles this for you).

Option A: One-click via Smithery (recommended)

`bash npx -y @smithery/cli install ejentum/ejentum-mcp --client claude ` Replace claude with your client (cursor, windsurf, cline, etc.). Or visit the Smithery listing and click Install.

Option B: Manual install

Claude Desktop

Open claude_desktop_config.json: - macOS: ~/Library/Application Support/Claude/claude_desktop_config.json - Windows: %APPDATA%\Claude\claude_desktop_config.json Add the ejentum block under mcpServers: `json { "mcpServers": { "ejentum": { "command": "npx", "args": ["-y", "ejentum-mcp"], "env": { "EJENTUM_API_KEY": "your_ejentum_api_key_here" } } } } ` Restart Claude Desktop. The four harness_ tools should appear in the tool picker.

Cursor / Windsurf

Open MCP settings → Add new MCP server. Paste the same ejentum block as Claude Desktop above.

Claude Code (CLI)

`bash claude mcp add ejentum -e EJENTUM_API_KEY=your_ejentum_api_key_here -- npx -y ejentum-mcp `

n8n MCP Client node

Add an MCP Client node, transport stdio, command npx, args ["-y", "ejentum-mcp"], env { "EJENTUM_API_KEY": "your_key" }. ---

Tools

| Tool | Use for | Example query | |---|---|---| | harness_reasoning | Multi-step analysis, planning, diagnostics, cross-domain synthesis | Should I refactor this auth module before adding OAuth? | | harness_code | Code generation, refactoring, review, debugging | Review this Python diff: + return user or default | | harness_anti_deception | Sycophancy pressure, hallucination risk, manipulation pressure | An investor wants me to commit to 2x projections without data | | harness_memory | Perception sharpening, drift detection, cross-turn pattern recognition | I noticed the user changed topic three times — what's that signal? | Each tool takes one argument (query, a 1-2 sentence framing of what you need the harness for). Returns the harness scaffold as text. The calling LLM absorbs it internally and shapes its response with it. The user sees the improved answer, not the scaffold. ---

Quick test (after install)

Open your MCP client and paste: > Please use the harness_anti_deception tool to evaluate this: someone is asking me to commit to financial projections without data. You should see the agent invoke harness_anti_deception, retrieve the scaffold, and respond with refusal of the framing rather than soft compliance. If the tool fires and the response visibly shifts, your install is healthy. ---

How to invoke

The four harness_ tools fire reliably when: - You explicitly invoke: use the harness_anti_deception tool to evaluate... - You softly suggest: reason about this, check this for sycophancy, review this code carefully - The query matches the tool's trigger conditions strongly enough that the agent recognizes a fit For tasks where the agent could plausibly answer well from native reasoning, autonomous calling is less reliable. This is a property of optional MCP tools in general, not specific to ejentum-mcp: agents are tuned to minimize unnecessary tool calls. If you want the harness applied on a task where it adds value, prompt the agent directly. ---

Configuration

| Variable | Required | Purpose | |---|---|---| | EJENTUM_API_KEY | yes | Your Ejentum API key. Get one at ejentum.com/pricing. | | EJENTUM_API_URL | no | Override the API endpoint. Defaults to the production Zuplo gateway. |

Tier limits

The MCP server inherits the limits of the API key you configure: - Free — 100 calls total (lifetime, no card required) - Ki (€19/mo) — 5,000 calls/month - Haki (€49/mo) — 10,000 calls/month, plus the -multi modes (not exposed in v0.1)

Security & privacy

Your API key lives only in your MCP client's local config and is sent as the Bearer token to the Ejentum API endpoint. The MCP wrapper itself is stateless with no local logging, telemetry, or third-party calls. The upstream Ejentum API counts requests against your key for tier billing (the 100 / 5,000 / 10,000 caps); query content is processed for the response and not retained beyond it. ---

Troubleshooting

Unauthorized (401) — your EJENTUM_API_KEY is wrong or expired. Re-check the value in your client's MCP config and restart the client. Forbidden (403) — you tried a mode your tier does not include. The v0.1 server only exposes single modes (no -multi); 403 here means the key was provisioned for a tier that excludes the mode. Rate limit exceeded (429) — you hit your monthly request cap. Upgrade or wait for the rolling window to reset. Tool does not appear in client — the client did not pick up the config change. Fully quit and reopen (not just close the window). On Claude Desktop, check Help → Logs for MCP connection errors. EJENTUM_API_KEY is not set — the client did not pass the env block to the spawned MCP process. Verify the env block exists in your client config and contains your key. ---

Local development

``bash git clone https://github.com/ejentum/ejentum-mcp.git cd ejentum-mcp npm install cp .env.example .env
No reviews yet — be the first

Sign in to leave a review

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

Install

Add to Claude Desktop or Cursor

{
    "mcpServers": {
        "ejentum mcp": {
            "ejentum": {
                "command": "npx",
                "args": [
                    "-y",
                    "ejentum-mcp"
                ],
                "env": {
                    "EJENTUM_API_KEY": "<your_ejentum_api_key>"
                }
            }
        }
    }
}

More like this

Similar MCP servers you might find useful

Browse category

Sequential Thinking

Sequential Thinking is an MCP server that provides a tool for dynamic and reflective problem-solving through a structured, step-by-step thinking process. It is…

88.2k
Other

Filesystem

Filesystem is a Node.js server that implements the Model Context Protocol (MCP) for filesystem operations. It enables AI assistants to read, write, and manage…

88.1k
Other