ejentum-mastra

Mastra integration for the Ejentum Reasoning Harness. createEjentumTools() returns an object of eight Mastra createTool instances you pass as the tools field to new Agent({ tools, ... }). Each tool calls the Ejentum API and returns a structured injection the LLM consumes before generating its response.

Use the harness before the agent generates on complex, multi-step, or multi-constraint tasks where the model's default reasoning template would miss a constraint, take a shortcut, or drift across turns. Each call returns a cognitive operation: a structured procedure (numbered steps with a failure pattern to refuse and a falsification test) paired with an executable reasoning topology (a DAG of those steps with decision gates, parallel branches, bounded loops, and meta-cognitive exit nodes). The agent reads both layers before producing its response.

Four dynamic tools (reasoning, code, anti-deception, memory) are available on all tiers including the 30-day free trial. Four adaptive tools (adaptive-reasoning, adaptive-code, adaptive-anti-deception, adaptive-memory) additionally run an adapter LLM that rewrites the matched operation with task-specific identifiers; they require the Go or Super tier.

npm install ejentum-mastra
# peer deps
npm install @mastra/core zod

export EJENTUM_API_KEY="ej_..."

Or pass it explicitly: createEjentumTools({ apiKey: "..." }). Get a key at ejentum.com/pricing.

import { Agent } from "@mastra/core/agent";
import { createEjentumTools } from "ejentum-mastra";

const architect = new Agent({
  id: "senior-architect",
  name: "Senior Architect",
  instructions: "Push back on sunk-cost framings.",
  model: "anthropic/claude-sonnet-4-6",
  tools: createEjentumTools(),
});

const response = await architect.generate(
  "We have spent three months on the GraphQL gateway. " +
  "Should we keep going or pivot to REST?",
);

import { createReasoningTool, createAntiDeceptionTool } from "ejentum-mastra";

const tools = {
  reasoning: createReasoningTool(),
  antiDeception: createAntiDeceptionTool(),
};

The wrapper-object key is a developer-facing camelCase identifier; the LLM-facing tool name is the id field on each tool object.

Each tool takes one parameter, query: string. The execute function returns { injection: string }. Errors do not throw; they return as a human-readable string in the injection field.

import { createEjentumTools, type EjentumConfig, type EjentumTools, type HarnessMode } from "ejentum-mastra";

createEjentumTools(config?: EjentumConfig): EjentumTools

Per-tool factories: createReasoningTool, createCodeTool, createAntiDeceptionTool, createMemoryTool, createAdaptiveReasoningTool, createAdaptiveCodeTool, createAdaptiveAntiDeceptionTool, createAdaptiveMemoryTool. Each accepts an EjentumConfig and returns a Mastra createTool result.

createEjentumTools() issues:

POST https://api.ejentum.com/harness/
Headers: Authorization: Bearer <key>, Content-Type: application/json
Body:    { "query": <string>, "mode": <one of 8 mode strings> }
Response (200): [ { "<mode>": "<injection string>" } ]

Full wire contract, field structure, DAG syntax, and a canonical dynamic-vs-adaptive comparison on the same query are documented in the ejentum-mcp README. The format is identical across this package and every Ejentum shim.

Mastra ships an MCP client (@mastra/mcp). The same eight tools are exposed by the hosted MCP server:

import { MCPConfiguration } from "@mastra/mcp";

const mcp = new MCPConfiguration({
  servers: {
    ejentum: {
      url: new URL("https://api.ejentum.com/mcp"),
      requestInit: {
        headers: { Authorization: `Bearer ${process.env.EJENTUM_API_KEY}` },
      },
    },
  },
});
const tools = await mcp.getTools();

• Node.js 18+
• @mastra/core 0.10+ (peer dep >=0.10.0)
• zod 3.x (peer dep ^3.23.0)
• TypeScript 5.x

MIT

The Ejentum harness is benchmarked publicly under CC BY 4.0 at github.com/ejentum/benchmarks:

• ELEPHANT sycophancy: 5.8% composite on GPT-4o (40 real Reddit scenarios)
• LiveCodeBench Hard: 85.7% to 100% on Claude Opus (28 competitive programming tasks)
• Memory retention: 50% fewer stale facts served (20-turn implicit state changes)
• Plus per-harness numbers across BBH/CausalBench/MuSR, ARC-AGI-3, SciCode, and perception tasks

Methodology, scenarios, run scripts, and raw outputs are all in-repo.