Your agent is fluent. It's also confident when it shouldn't be, stops at the first plausible explanation, and fails silently inside a well-formed response. These failures don't throw exceptions. They ship to production.

Ejentum exists because the reasoning gap is structural, not informational. RAG solved what models know. Nobody solved how they think. We built for that.

RA²R (Reasoning Ability-Augmented Retrieval) retrieves engineered cognitive operations (not documents, not facts) and injects them into an LLM's context at inference time. 679 operations across four harnesses. One API call. The model's next output reflects a different reasoning structure before the first token generates.

Your agent sends a task description. The Ejentum API returns a structured cognitive injection with six labeled blocks:

• PROCEDURE: the natural-language steps the model should follow
• REASONING TOPOLOGY: the same procedure as an executable DAG (Sn:steps, Gn{gates}, M{meta-nodes}, FREEFORM{exits})
• COGNITIVE PAYLOAD: named signals — Amplify: to activate, Suppress: to block, plus cognitive style and elasticity
• FALSIFICATION TEST: the verification criterion the model checks its output against
• NEGATIVE GATE: the failure pattern to avoid, stated as a concrete scenario the model recognizes
• TARGET PATTERN: what correct reasoning looks like

The injection is inserted into the agent's context window before the task. The suppression signals are the core mechanism. They constrain the model's output space multiplicatively: each named failure mode eliminates an entire branch of incorrect reasoning. In our testing, suppression consistently outperforms amplification alone.

Two delivery modes per harness:

• Dynamic — single retrieval. The highest-scoring operation comes back as-is. Predictable, fast.
• Adaptive — top-k retrieval, then an adapter LLM rewrites the operation with task-specific identifiers from your query. The procedure steps and topology nodes reference YOUR problem, not the canonical example.

curl -X POST "https://api.ejentum.com/harness/" \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "Our conversion rate dropped 40% after the checkout redesign. Determine whether the redesign caused the drop or if something else changed at the same time.",
    "mode": "reasoning"
  }'

[PROCEDURE]
Step 1: Identify the intervention, variable, or agent whose impact is being
attributed. Step 2: Simulate the counterfactual world where ONLY that element
is absent while all correlated variables are held at their natural values.
Step 3: Compute the difference between the factual and counterfactual outcome
distributions. Step 4: Check SUTVA (Stable Unit Treatment Value Assumption)
and flag violations where removal of the target variable changes the values
of the supposedly held-constant covariates. Step 5: Reject attribution claims
that do not survive the isolation test, where a proposed cause is actually a
proxy for a correlated variable that carries the true causal load.

[REASONING TOPOLOGY]
N{accept_attribution_based_correlation_alone} → FORK:
├→ S1a:simulate_factual(with_intervention) → ACTUAL[]
└→ S1b:simulate_counterfactual(without_intervention,hold_covariates) → CONTROL[]
→ JOIN → C{causal_impact = outcome(factual) - outcome(counterfactual)}
→ S2:apply_causal_impact → S3:check_SUTVA
→ G1{covariates_shift?} --yes→ FLAG:contaminated_isolation → OUT:invalid_attribution
                          --no→ G2{attribution_survives?}
                                --yes→ OUT:confirmed_impact
                                --no→ REJECT:proxy_for_correlated_var

[COGNITIVE PAYLOAD]
Amplify: potential outcomes simulation; counterfactual world construction; SUTVA enforcement
Suppress: correlation based attribution; shared variance credit diffusion
Cognitive Style: counterfactual reasoning
Elasticity: coherence=optimal isolation, expansion=adversarial perturbation

[FALSIFICATION TEST]
If the effect of a specific variable is estimated without verifying
controlling for correlated co-variables, impact isolation was not performed.

[NEGATIVE GATE]
The sales increase is attributed to the new marketing campaign, ignoring
correlated economic factors and treatment spillover.

[TARGET PATTERN]
Apply potential-outcomes simulation: construct the counterfactual world
where the intervention is absent, hold covariates at natural values,
and verify that the measured effect survives SUTVA checks before
accepting any causal claim.

The agent absorbs this before answering. Instead of accepting "the redesign caused the drop" on temporal proximity alone, it constructs a counterfactual world where the redesign did not happen, checks whether other variables (traffic source, device mix, pricing, market conditions) shifted in the same window, and either confirms the impact or rejects the attribution as a proxy for a correlated variable.

Eight modes across four harnesses:

Retrieval under 1 second for dynamic, a few seconds for adaptive (one adapter-LLM round-trip). If the API is unreachable, your agent continues on native reasoning. Enhancement, not dependency.

Why not just write better prompts? Prompt engineering is O(n) work. Every new scenario needs a new prompt. Every model update risks breaking what worked. Ejentum selects from 679 cognitive operations across 4 harnesses at runtime. Zero prompt maintenance. One API call adapts to any task.

Why not fine-tune? Fine-tuning burns reasoning into weights. It costs weeks, requires training data per domain, and must be repeated when the base model updates. The reasoning harness operates at the prompt level. No training, no data collection, no retraining cycle. Deploy in minutes, not months.

Why not RAG? RAG retrieves information. Ejentum retrieves reasoning. Your agent already has the data. The problem is how it thinks about that data. RAG gives the agent more to read. Ejentum gives it a better way to think. Use both.

Why not chain-of-thought? Chain-of-thought makes reasoning visible. Ejentum governs which reasoning steps to take and which failure modes to block. CoT says "show your work." Ejentum says "do this work, not that work." They are complementary. Use both.

Why not just use a stronger model? We tested on Claude Opus 4.6 with maximum-effort extended thinking. The strongest reasoning model available. It scored 85.7% on hard competitive programming. Four tasks failed: two to reasoning spirals where the model thought for 600-1200 seconds and produced zero code. One API call per task fixed all four. The model had the knowledge. It lacked the convergence discipline. A stronger engine with uncalibrated steering still crashes.

The original product. Addresses reasoning failures across extended execution chains. Each operation is a structured protocol with an execution topology, suppression vectors, amplification signals, and graph edges connecting it to other operations. Organized by class of cognitive failure, not by subject matter.

Blocks sycophancy, hallucination, social engineering, and prompt injection. Tested cross-model on GPT-4o.

• ELEPHANT sycophancy benchmark: 5.8% composite sycophancy across 40 real Reddit scenarios
• Adversarial social engineering: Detected at Turn 6 in a 20-turn adaptive attack. 27/30 blind evaluation
• Hallucination prevention: Zero hallucinations across 5 fabrication tests

Engineering operations for code generation, refactoring, security auditing, and architecture. Tested on competitive programming and scientific computing.

• LiveCodeBench Hard: 85.7% to 100% on 28 hard AtCoder tasks. Zero regressions
• SciCode: Zero bugs on 10 hard scientific computing problems with dual injection (reasoning + code stacked)

Perception sharpening and behavioral calibration. The model detects what changed, not just what was said. Two-pass protocol: observe first (free perception), then sharpen (focused injection).

• State tracking: 50% fewer stale facts served as current across 20-turn conversations
• Perceptual detection: 3x signal detection rate in coaching conversations
• Blind evaluation: 4.1/5 vs 3.5/5. The evaluator independently named the core insight: "Retention without updating is a liability"

Browse all 679 operations: ejentum.com/abilities

Headline numbers (external, binary, reproducible):

• LiveCodeBench Hard: 85.7% → 100% on 28 hard AtCoder tasks. Zero regressions across three batches.
• SciCode: 7 → 0 correctness bugs on 10 hard scientific computing problems. Blind evaluator chose injection on 10/10.
• ELEPHANT sycophancy: 5.8% composite across 40 real Reddit scenarios. Cross-model validated on GPT-4o.
• Memory state tracking: 50% fewer stale facts served as current across 20-turn conversations. Blind eval 4.1/5 vs 3.5/5.

Eight benchmarks across four harnesses. Two-stage blind protocol on reasoning and memory. Exact-match on code. Cross-model validation on anti-deception and memory (GPT-4o). Source data for every number is in the benchmarks repo.

LiveCodeBench Hard: 28 hard competitive programming tasks. Designed by an independent research team.

+14.3pp. Four tasks gained. Zero lost. Zero regressions across three independent batches.

SciCode: 10 hard scientific computing problems. Externally published benchmark. Dual injection (reasoning + code modes stacked).

ELEPHANT: 40 real Reddit sycophancy scenarios. Externally published benchmark. Cross-model validation: these results are on GPT-4o, not Claude.

BBH / CausalBench / MuSR: 70 published academic tasks. Externally designed by independent research teams.

EjBench: 180 custom professional tasks. Designed by Ejentum as a harder stress test after external validation. Same blind protocol as BBH above. Reported here for transparency despite custom design.

20-turn Vantage scenario: implicit state changes. Conversation designed to silently walk back Turn-1 facts by Turn 19. Measures whether the agent detects the shifts or serves stale facts.

25 interactive reasoning steps. Neither condition cleared Level 0 (baseline rate on ARC-AGI-3 is <1% across all frontier models). This is not a headline result; it is evidence that the injection persists and compounds over extended execution, not a claim of task completion.

Full reports, raw traces, generation outputs, judgment scores: ejentum/benchmarks

Ejentum is built by Frank Brsrk (Franko Luci). Self-taught AI developer. Solo founder. One person engineering the operations, running the benchmarks, shipping the system.

When results disappoint, they're published alongside the improvements. When the most complex mode underperformed the simplest one, it was deprecated and documented. When 62% of tasks received the wrong reasoning domain and improvements persisted anyway, that was published too, because the finding was more valuable than the embarrassment.

Based in Athens, Greece. Contact: info@ejentum.com.

One REST endpoint, or a native package for your stack. Each shim exposes 8 tools (4 harnesses × dynamic + adaptive).

All examples: ejentum/examples

Ejentum is designed as a non-critical enhancement layer. The Ejentum API sits outside your agent's critical path: if it's unreachable, your agent continues on native reasoning.

• Graceful degradation is first-class. On timeout, 5xx, or rate limit, your agent continues on native reasoning. The API never blocks agent execution. See graceful_degradation.py for the production pattern.
• Recommended timeout: 5 seconds for dynamic modes, 15 seconds for adaptive modes (adapter LLM adds a round-trip).
• Rate limit: 100 requests/minute across all tiers.
• Cost impact: injection adds ~400–900 tokens to each augmented LLM call. This adds cost to your LLM bill; size depends on your model provider's rates.
• Data handling: task descriptions sent via the query parameter are processed for operation retrieval only. EU hosting. Contact info@ejentum.com for data processing questions.

No card required for the 30-day trial. Get your API key · Full pricing.

We built injections to prevent reasoning shortcuts. We did not build them to teach new reasoning modalities. But during testing, behaviors emerged that we did not engineer:

Spontaneous domain shift. At step 15 of a 25-step ARC-AGI-3 spatial navigation game, the augmented agent stopped reasoning in natural language and switched to symbolic mathematical notation. It defined formal variables, computed coordinates algebraically, and reasoned about movement vectors. The suppression signal (start_end_only_thinking) constrained a failure mode. The agent found its own solution to that constraint. The suppression was the pressure. The math was the agent's adaptation.

Emergent query evolution. The agent's queries to Ejentum improved systematically over 25 steps, from generic ("help me reason about this game") to spatially precise ("wall barrier at x=29-33 for rows 30-39 blocks rightward movement") to metacognitive ("robot appears stuck after 5 turns"). Nobody instructed query format or specificity. The agent learned to be a better user of the reasoning harness through practice, not instruction.

The tense test. In Memory Harness testing, a fact established in Turn 1 was implicitly walked back by Turn 19 without explicit correction. The baseline agent's scratchpad still said "Rust is their competitive advantage" (present tense). The augmented agent's said "Rust was initially considered their competitive advantage" (past tense). One word. The difference between accurate memory and stale memory.

These are observations from traced data, not marketing claims. Full step-by-step traces are in the benchmarks repo. We report them because they suggest something about how suppression signals interact with model behavior that we don't fully understand yet.

What the data demonstrates:

• Structured cognitive injection produces measurable behavioral changes across eight independent benchmarks, multiple model sizes, and single-turn, multi-step, code generation, anti-deception, and memory settings.
• Suppression signals work even when the retrieved operation comes from a mismatched domain (retrieval precision was 38%; improvements persisted).
• Injections persist across extended execution chains (half-life: 24 steps) and compound rather than degrade.
• On competitive programming, the injection improved correctness from 85.7% to 100% with zero regressions.
• On scientific computing, dual injection (reasoning + code stacked) eliminated all 7 correctness bugs.
• On sycophancy, the injection reduced composite sycophancy to 5.8% across 40 real scenarios, validated cross-model on GPT-4o.
• On memory, the injection halved stale facts served as current, confirmed by blind evaluator.

What we haven't proven:

• Full cross-model generalization. Anti-deception is validated on GPT-4o. Reasoning and code benchmarks are Claude-only. Multi-model testing is in progress.
• Ablation of suppression vs. amplification. We observe that suppression consistently outperforms amplification. We have not published a controlled ablation isolating the two mechanisms.
• Human evaluation at scale. Our evaluations use a two-stage blind protocol with LLM-as-judge. Human evaluation on a subset would strengthen the evidence.

We publish limitations because the work should be evaluated on what it demonstrates, not what we believe it will demonstrate. Every claim traces to a data file. The benchmarks repo contains the raw data so you can verify independently.

Standalone packages on PyPI and npm, one per host framework. Each speaks the host framework's native idiom rather than mirroring the previous shim. Each ships 8 tools (4 harnesses × dynamic + adaptive).

Plus the integrations repo (n8n workflows + editor skill files) and zed-ejentum-mcp (Zed extension).