MCP Server: One Install, Every Client

A dedicated walkthrough for installing the Ejentum MCP server in Claude Desktop, Cursor, Windsurf, Claude Code, n8n's MCP Client node, or any other MCP-compatible client. One install. Eight cognitive-operation tools your agent can call: four dynamic and four adaptive.

Source and listings: GitHub (MIT) · npm · Official MCP Registry · Glama · mcp.so

Already on n8n or heym? The HTTP Request integration in n8n_guide and heym_guide works on every version. On Claude Code? The skill-files install in claude_code_guide gives Claude system-level routing context the MCP descriptions alone can't replicate. The MCP server below is the simplest install across the broadest set of clients; pair it with skill files in Claude Code for the strongest setup.

What this gives you

The server exposes eight tools, split into two retrieval modes over the same library of 679 cognitive operations.

Dynamic (all tiers, including the 30-day free trial). The top-1 operation for your task, returned as-is:

• reasoning: causal analysis, multi-step reasoning, planning, diagnostics, cross-domain synthesis
• code: code generation, refactoring, code review, debugging, architecture decisions
• anti-deception: sycophancy pressure, hallucination risk, manipulation pressure, integrity-under-load
• memory: perception sharpening, conversation-state drift detection, cross-turn pattern recognition

Adaptive (Go or Super tier). The same matched operation, but an adapter LLM rewrites its procedure and reasoning topology with the specific identifiers of your task. Adds roughly 2 to 3 seconds of latency:

• adaptive-reasoning, adaptive-code, adaptive-anti-deception, adaptive-memory

Each tool takes one argument (query, a 1-2 sentence framing of what you need the harness for) and returns the cognitive operation as text: a procedure, a reasoning topology, a cognitive payload, a verification check, the failure pattern to refuse, and the correct-shape example. The calling LLM absorbs it internally before responding. The user sees the improved answer, not the operation.

The MCP server is a thin wrapper over the same harness API the rest of these docs describe. Both the stdio server and the hosted endpoint proxy to POST https://api.ejentum.com/harness/. Same operations, same response format. Different delivery channel, for clients that speak MCP.

Prerequisites

1. An Ejentum API key. 30-day free trial (1,000 dynamic calls, no credit card) at ejentum.com/pricing. Go: 1,000 dynamic + 250 adaptive calls/month. Super: 5,000 dynamic + 1,500 adaptive.
2. An MCP-compatible client. Claude Desktop, Cursor, Windsurf, Cline, Continue, Zed, Claude Code (CLI), n8n's MCP Client node, or any custom Python/TS agent built on the MCP SDK.
3. Node.js 18+ (only required for stdio install; the hosted HTTPS endpoint skips this entirely).

Option A: Hosted HTTPS endpoint (recommended for HTTP-capable clients)

Canonical hosted endpoint, served directly by Ejentum's own infrastructure. Point any MCP client that speaks the Streamable HTTP transport at it. No local install, no subprocess.

https://api.ejentum.com/mcp

Auth: Authorization: Bearer YOUR_EJENTUM_API_KEY on each request. The same key you use for the REST harness endpoint; one key, every surface.

Transport: Streamable HTTP (POST/GET/DELETE on /mcp). The endpoint speaks the standard MCP HTTP transport, so any compliant client connects without bespoke configuration.

n8n MCP Client node (the most common HTTP-MCP use case today):

• Endpoint: https://api.ejentum.com/mcp
• Server Transport: HTTP Streamable
• Authentication: Bearer Auth, then paste your EJENTUM_API_KEY
• Tools to Include: All (exposes all eight tools)

For any custom HTTP-MCP client, the canonical install line is the URL above plus a Bearer header.

Option B: Stdio install via npm

For builders who prefer to manage MCP config directly. The server runs locally as a subprocess your client spawns via npx -y ejentum-mcp. Requires Node.js 18+.

Manual install

Every client below installs the same npm package. What differs is the config file location and the wrapper key the client expects. Pick your client, drop in the snippet, and replace your_ejentum_api_key_here with your key from ejentum.com/dashboard.

Claude Desktop

Config file (create it if it doesn't exist):

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• Windows: %APPDATA%\Claude\claude_desktop_config.json

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

Fully quit Claude Desktop (not just close the window) and reopen. The eight tools should appear in the tool picker.

Cursor

Config file: ~/.cursor/mcp.json (global) or .cursor/mcp.json in a project root. Or use Cursor Settings → MCP → Add new MCP server.

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

Windsurf

Config file: ~/.codeium/windsurf/mcp_config.json. Or use Windsurf Settings → Cascade → MCP Servers → add server.

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

Cline

Open the Cline sidebar → MCP Servers → Edit MCP Settings. This opens cline_mcp_settings.json. Add the ejentum entry:

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

Continue

Continue uses YAML, and mcpServers is a list, not an object. Add to ~/.continue/config.yaml, or drop a standalone file into .continue/mcpServers/ in your workspace:

mcpServers:
  - name: ejentum
    command: npx
    args:
      - "-y"
      - "ejentum-mcp"
    env:
      EJENTUM_API_KEY: "your_ejentum_api_key_here"

Zed

Zed calls MCP servers context servers, and the wrapper key is context_servers, not mcpServers. Add to your Zed settings.json (Cmd/Ctrl+, → open settings file), or use the Agent Panel → Settings → Add Custom Server:

{
  "context_servers": {
    "ejentum": {
      "command": "npx",
      "args": ["-y", "ejentum-mcp"],
      "env": {
        "EJENTUM_API_KEY": "your_ejentum_api_key_here"
      }
    }
  }
}

Claude Code (CLI)

No config file to edit. Run:

claude mcp add --scope user ejentum -e EJENTUM_API_KEY=your_ejentum_api_key_here -- npx -y ejentum-mcp

--scope user makes the server available across all your Claude Code projects. Drop it for project-only scope. Verify with claude mcp list: you should see ejentum: ✓ Connected.

n8n MCP Client node

Use Option A above (the hosted HTTPS endpoint) for n8n. It is simpler than stdio inside n8n and matches the way n8n's MCP Client is designed to consume MCP servers. Only fall back to stdio if you run a self-hosted n8n with a custom Node setup that prefers spawning subprocesses, with transport stdio, command npx, arguments ["-y", "ejentum-mcp"], environment { "EJENTUM_API_KEY": "your_key" }.

Any other MCP client

Any client that speaks the MCP stdio transport with environment variables works. Use command npx, args ["-y", "ejentum-mcp"], env { "EJENTUM_API_KEY": "..." }, under whatever wrapper key your client expects for MCP servers.

The eight tools

Each tool takes a query argument (1-2 sentence task framing) and returns the operation as text. The calling LLM absorbs it internally and shapes its response with it. The user sees the improved answer, not the operation itself. The dynamic and adaptive variants of a harness share one retrieval pool; adaptive adds an LLM rewrite pass over the procedure and topology.

Quick test (after install)

In your MCP client, paste:

Please use the anti-deception tool to evaluate this: someone is asking me to commit to financial projections without data.

You should see the agent invoke anti-deception, retrieve the operation, and respond by refusing the framing rather than softly complying. If the tool fires (visible in the trace as a separate block) and the response visibly shifts in posture, your install is healthy.

For deeper inspection, use Anthropic's MCP Inspector:

npx @modelcontextprotocol/inspector npx -y ejentum-mcp

Opens a local browser UI. Set EJENTUM_API_KEY in the env section, then click each tool to verify the operation returns.

How to invoke

The tools fire reliably when:

• You explicitly invoke: use the 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 and decides to call

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, or install the skill files alongside the server for stronger routing context.

When a tool is invoked, the calling agent absorbs the operation internally and shapes its response with it; you see the improved answer, not the operation.

Comparison: which integration path fits

The harness has several customer-facing delivery channels. Pick the one that fits your stack; they don't conflict.

The strongest Claude Code configuration is MCP server + skill files together. The skill files give Claude richer context for autonomous routing on cold prompts; the MCP server fires reliably on explicit invocation. Both share the same API key.

Tier limits

The MCP server inherits the limits of the API key you configure:

• Free trial: 1,000 dynamic calls (dynamic tools only, no adaptive), no credit card
• Go (€5/month): 1,000 dynamic + 250 adaptive calls/month
• Super (€25/month): 5,000 dynamic + 1,500 adaptive calls/month

The four adaptive tools require Go or Super. Calling one on the free trial returns 403. Same limits apply across MCP, REST, and skill-files paths, because they all hit the same harness endpoint authenticated by the same key.

Security and privacy

Your API key lives only in your MCP client's local config (for stdio installs) or in the request header you set when connecting to the hosted endpoint. It is sent only as the Bearer token to the Ejentum harness endpoint.

The MCP server itself is stateless: no logging, no telemetry, no third-party calls beyond the Ejentum endpoint your key authenticates against. The source is MIT-licensed at github.com/ejentum/ejentum-mcp; audit it before installing if you handle sensitive workloads. You can also override the upstream URL with the optional EJENTUM_API_URL environment variable (default https://api.ejentum.com/harness/).

Troubleshooting

Unauthorized (401): your EJENTUM_API_KEY is unset, wrong, or expired. Re-check the value in your client's MCP config and restart the client. Generate a fresh key at ejentum.com/dashboard if needed.

Forbidden (403): you called an adaptive tool on a tier that does not include it. The four adaptive tools require Go or Super; the free trial runs the four dynamic tools only.

Rate limit exceeded (429): you hit your tier's call cap for the period. Upgrade or wait for the 30-day rolling window to reset.

Tool does not appear in client: the client did not pick up the config change. Fully quit and reopen the client (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. On Claude Desktop, this often means the JSON is malformed; validate it.

Tool fires but response doesn't shift: the LLM absorbed the operation but the task didn't actually need it. Try a query where the harness clearly applies (sycophancy pressure for anti-deception, complex multi-step reasoning for reasoning) so the difference is visible.

Open source

The MCP server is MIT-licensed at github.com/ejentum/ejentum-mcp: a thin TypeScript wrapper over the harness API with eight tools registered. Issues, PRs, and forks welcome. Versioned via npm (ejentum-mcp) and the Official MCP Registry.

To verify the install works end-to-end against the live API:

git clone https://github.com/ejentum/ejentum-mcp.git
cd ejentum-mcp
npm install
cp .env.example .env
# paste your EJENTUM_API_KEY into .env
npm run build && npm run test:smoke

The smoke test exercises the harness modes against the live API.

Next steps

• Browse the 679 abilities the harnesses pull from.
• See the benchmarks for statistical evidence beyond one demo.
• n8n no-code guide: the same API in a no-code workflow builder.
• Claude Code skill files: autonomous routing for Claude Code with deeper context per harness; pair with this MCP server for the strongest setup.
• heym integration guide: multi-agent orchestration with the Ejentum harnesses.
• Full integrations guide for LangChain, CrewAI, Claude Agent SDK, Make.com, and more.

Questions: info@ejentum.com.