Ejentum MCP vs Code Assistant

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.