Root-Cause & Systems Reasoning
Stops agents from jumping to conclusions during outages, architecture changes, and complex debugging. Enforces step-by-step checks across causality, timing, blast radius, and system dependencies.
Reasoning Harness & Logic API for AI Agents
Frontier intelligence.
Workhorse pricing.
Ejentum injects precision rules into AI agents at the exact moment of execution. Run fast, low-cost models with the accuracy of frontier models, eliminating costly errors and cutting AI bills by 60% to 85%.
1,000 free calls • 30-day evaluation • Zero data retention • No credit card required
1. Intercept Call (Client)
2 lines
import ejentum
client = ejentum.Client(api_key="ej_live_...")
# Intercept right before execution:
rule = client.guard(
query="50M-row database migration",
mode="reasoning"
)
agent.inject_directive(rule.checklist)
2. Injected Payload (Server)
1.4ms
{
"status": "verified",
"latency_ms": 1.4,
"checklist": [
"Set lock_timeout = 2s on table",
"Verify zero active write locks",
"Staged delete for >1M rows"
]
}
In-Memory Engine (<2ms)
Zero External LLM Calls (Deterministic)
Zero Data Retention Policy
Test Live Rule:
The Production Dilemma
Why Giant System Prompts Fail in Production
Stuffing 50 pages of instructions into a system prompt wastes tokens and dilutes model attention. When tasks grow complex, unassisted LLM agents fail in predictable ways:
Attention Dilution
Context Overload
Models lose instructions buried in long prompts. The safety rule you need most is the one the model stopped paying attention to past token 2,000.
Premature Sign-Off
Shallow Verification
The agent patches a surface symptom and declares victory while the underlying vulnerability remains untouched. In benchmarks, raw agents self-verify on less than 25% of tasks.
Compounding Drift
Multi-Step Decay
A 3-step agent chain at 90% accuracy drops to 73% end-to-end reliability; at 5 steps it drops to 59%. Flawed early assumptions snowball into downstream outages.
Cold-Cache Stampedes
Panicked Mitigations
During an outage, raw agents default to destructive actions like flushing Redis caches, destroying working sets and causing a 100k req/sec database crash.
Sycophantic Agreement
False Premise Lock-in
Unassisted models eagerly agree with faulty user assumptions (like choosing between sharding vs vertical scaling) rather than auditing telemetry first.
Cross-Domain Blindness
Unchecked Execution
An agent writes valid SQL syntax but misses the 50M-row table lock that takes down checkout. Real tasks require checking safety, timing, and blast radius simultaneously.
The Solution: Just-In-Time Rule Injection. Instead of bloating every system prompt, Ejentum injects a focused ~150-token verification checklist matched to the specific step in front of your model, in under 2ms.
The Financial Advantage
Cut Your AI Agent Costs by 60 to 85%
Why pay $0.30 per task for massive, slow models when a fast $0.02 model equipped with Ejentum delivers equal or better reliability?
The Expensive Way
High Waste
Frontier Models Alone
Claude 3.7 Sonnet / GPT-4o
Cost per 1,000 multi-step tasks
$300.00
Monthly cost (10,000 tasks)
$3,000.00
Failure Protection
Generic system prompt only
Execution Latency
Slow (3x-5x LLM inference time)
Expensive, slow, and still vulnerable to multi-step reasoning drift.
Smart Arbitrage
The Ejentum Way
85% Savings
Fast Models + Ejentum
Gemini 2.5 Flash / GPT-4o-mini + Ejentum
Cost per 1,000 multi-step tasks
$20.00
Monthly cost (10,000 tasks)
$229.00 (incl. Ejentum)
Failure Protection
311 dynamic guardrails View JSON
Execution Latency
<2ms local engine (~90-150ms WAN)
Net Monthly Savings: $2,771 / month
Interactive ROI Calculator
Baseline: $3,000
Flash + Ejentum: $229
Engineered For Production AI Builders
</>
Software & DevOps Teams
Building coding or infrastructure agents that touch production databases. Ejentum enforces migration safety, prevents cold-cache stampedes, and blocks destructive code.
∞
Agency & Workflow Builders
Using n8n, Make, or LangChain to build customer automations. Wire Ejentum as a tool node so client-facing agents never hallucinate fake data or violate business logic.
✓
Support & Advisory Agents
Stop raw models from "people-pleasing" under pressure. Ejentum ensures customer agents stand firm on company policies, pricing rules, and verified facts.
How It Works
A tool your agent calls right before it acts...
...and gets back a focused verification checklist matched to the exact task.
Instant lookup (<2ms) when speed matters, or multi-rule chaining when the task spans multiple risks. Four specialized rule libraries keep your agent reliable: reasoning, code safety, anti-deception, and memory. See how in the Quickstart.
01 / Intercept
Decision Gate Intercept
At critical decision gates (destructive tool calls, external writes, trajectory forks), your agent queries the Ejentum harness before acting.
Latency overhead: <2ms
02 / Verify
Rule Checklist Returned
Ejentum evaluates the candidate action against 311 precompiled invariants and returns a focused, ~150-token safety checklist.
Zero data retention
03 / Execute
Safe Execution
The agent self-audits against the checklist, corrects potential blind spots, and converges on verified ground truth.
Compounding drift eliminated
The Architectural Metaphor
The "Air Traffic Control" Model for Autonomous AI
Sub-2ms Deterministic Pre-Execution Gate
Just as commercial airplanes do not take off, land, or change flight paths without air traffic clearance, an autonomous AI agent should never execute high-consequence mutations (database writes, code diffs, shell commands, financial transactions) based solely on probabilistic token generation.
Phase 1: Flight Plan
Agent Loop
Candidate Plan Formed
The foundation model plans a multi-step trajectory or proposes a tool call (e.g. migrate database, execute shell script, issue refund).
Status: Unverified / Vulnerable
Phase 2: Clearance
Ejentum Intercept
Air Traffic Control Audit
In <2ms, Ejentum validates the action against 311 state invariants: checks preconditions, AST symbols, backup existence, and detects sycophantic premise errors.
Status: Deterministic Gate Active
Phase 3: Protected Departure
Execution
Safe Mutation Executed
Action proceeds with verified ground truth. If invariants fail, the gate rejects the mutation with structured errors, preventing runaway drift or data loss.
Status: Zero Blast Radius
Read the complete operational mechanics and economics:
Read The Field Guide to AI Agent Reliability →
No-code Workflows →
Add Ejentum as an HTTP node in n8n or Make.com.
Remote MCP Server →
Connect Cursor and Claude Code in seconds.
Python SDK →
Drop into CrewAI, LangChain, or LangGraph.
Deterministic Execution
Why Ejentum adds <2ms instead of 1,000ms
In-Memory Topological Matching (Zero Secondary LLMs)
Traditional Guardrails & Evaluators
+800ms to 1,500ms
Most guardrail frameworks (LLM-as-a-judge, proxy inspectors) call another large language model in the background on every step. This doubles inference latency, doubles token bills, and still suffers from probabilistic hallucinations.
Architecture:
Secondary LLM Proxy
Token Inflation:
2x Token Overhead
Latency Penalty:
Severe (+1.2s avg)
Ejentum In-Memory Harness
<2ms Invariant Engine
Ejentum evaluates candidate actions against 311 precompiled topological invariants in-memory. Zero secondary LLMs are called. Your agent receives a focused, deterministic checklist in sub-2ms, maintaining fluid interactive streaming.
Architecture:
In-Memory Invariant Matching
Token Inflation:
Zero (Static ~150 Tokens)
Latency Penalty:
<2ms (Imperceptible)
Zero Data Retention (ZDR) & Enterprise Privacy Guarantee
Zero Training, Zero Storage: Task descriptions sent to api.ejentum.com are processed purely in-memory to match the right verification rule (resolving topological graph invariants in <2ms) and are immediately discarded.
Ejentum never logs, caches, persists, or trains models on your proprietary source code, customer records, or agent conversation history. To satisfy internal SOC-2 audit requirements, client SDKs include an on_guardrail_applied callback to store cryptographic audit trails strictly inside your own VPC.
Enterprise Runtime Governance
Where Ejentum Stands Against the Competition
Legacy approaches intercept at the edges with static regex firewalls or high-latency dialogue rails. Ejentum operates as an in-flight cognitive verification harness and stateful tool governor with sub-millisecond local execution.
| Architectural Dimension | NVIDIA NeMo | Guardrails AI | Patronus AI (Lynx) | Lakera Guard | Ejentum Enterprise |
|---|---|---|---|---|---|
| Intervention Point | Middleware / Dialogue | Output Validator | Post-Hoc Output Scorer | Perimeter Proxy | In-Flight Cognitive + Tool Boundary |
| Tool Sequence Invariants | Colang flows (complex setup) | None | None | None | Stateful Temporal Logic (RequirePrior/Forbid) |
| Contradiction Detection | LLM self-check (~800ms) | Regex/Validator (~10ms) | Specialized NLI 70B (~600ms) | None | Sub-millisecond Local NLI (<1ms) + Fallback |
| Adaptive Risk Budgeting | Static rules | None | None | Threshold scoring | BAVAR Dynamic Tiering (Token/Latency Clamping) |
| Schema Coercion + Epistemic Gate | Format rail only | Pydantic validation only | None | None | Schema Repair + Reasoning Authenticity Gate |
| Anti-Sycophancy Defense | None | None | Weak | None | Epistemic Falsification Pass (Active) |
| CoT Forgery Resistance | Vulnerable | Vulnerable | Masks errors | Vulnerable | Sentinel Guards + Intermediate Checkpoints |
| Inference Overhead | +500 to 1,500ms | +50 to 150ms | +400 to 1,200ms | +30 to 80ms | 0ms (Scaffold) / <1ms (Local Checks) |
Perimeter Defense vs. Defense-in-Depth
Edge Firewalls
vs. Lakera Guard & Azure Prompt Shields
Lakera and Azure Prompt Shields operate as ingress firewalls. If an adversarial injection bypasses perimeter regex or classifier pattern matching, they exert zero control over what the model does next. Ejentum provides defense-in-depth: even if an adversary slips past the router, the injected cognitive scaffold and tool invariants constrain execution.
Secondary LLM Calls vs. Zero Extra Latency
Dialogue Rails
vs. NVIDIA NeMo Guardrails
NeMo requires setting up secondary LLM calls for input and output rails, adding 500 to 1,500ms of latency per conversational turn. Ejentum's compiled compact mode and deterministic guards execute in sub-millisecond time with zero additional LLM hops.
Syntax Parsing vs. Epistemic Grounding
Output Validators
vs. Guardrails AI
Guardrails AI forces valid JSON schemas via Pydantic. Ejentum matches Guardrails AI in JSON extraction and syntax repair, but adds an Epistemic Invariant Check: it blocks naked or ungrounded JSON outputs that lack prior verified reasoning traces.
70B Heavy Scoring vs. Sub-Millisecond Local NLI
Evaluation LLMs
vs. Patronus AI Lynx
Patronus Lynx uses specialized 70B models for deep narrative Natural Language Inference across long texts. Ejentum's LocalNLIEngine solves the high-frequency 80% operational problem (catching direct antonym clashes, negation flips, and numeric discrepancies) in under 0.2ms at zero API cost.
Ejentum Rule Libraries
311 pre-built verification rules across four protection domains.
Fast models already have the capability; they just need the right guardrails at the right moment. Dynamic mode returns the exact precompiled checklist in <2ms; Graph mode chains multiple rules for complex tasks. One API call, one lightweight injection.
New here? The Quickstart has you calling the live API in under a minute. Try it on your own agent.
Interactive Side-by-Side Comparison
See What Standard Prompts Miss
Compare how raw frontier models jump to conclusions, agree with flawed premises, and skip verification steps - versus how fast models equipped with Ejentum catch edge cases and prevent catastrophic mistakes before execution.
Mode:
Type or edit any prompt to test live rule routing in <2ms.
Press Ctrl+Enter to run
Interactive Visual Code Diff
Diff View:
Standard LLM (Unassisted)
Unchecked Failure Mode:
Loading scenario...
Simulated Standard Output:
[-] Destructive Execution Diff
Loading baseline...
LLM + Ejentum Guardrail
Live Engine Ready
Library: Spatial
•
Rule: SP-034
•
Engine: Hybrid Logic Index (<2ms)
Injected Verification Checklist:
Loading invariant...
Loading augmented output...
VERIFIED LIFT:
Evaluating empirical lift...
Architectural Guarantees
Engineered for Zero-Blast-Radius Agent Loops
Precision Rule Routing (933-Edge Graph)
Not a prompt template library. Bloated prompt wrappers dilute model attention by 2,000+ tokens and cause models to ignore critical safety rules.
Ejentum indexes 311 rules into a compiled dependency graph, injecting precision ~150-token checklists in <2ms with zero extra LLM calls.
Configurable Security Posture (Fail-Open or Fail-Closed)
Choose your risk profile per task. General workflows fail open using precompiled local offline invariants so agent loops never hang.
Destructive database migrations and financial actions can set fail_mode="closed" to halt execution immediately if latency thresholds or network drops occur.
Multi-Agent Handshake Presets (Swarm Contracts)
Enforces segregation of duties across agent topologies (Planner-Implementer-Auditor, Maker-Checker, Quorum Consensus).
Neutralizes sycophantic rubber-stamping, unverified plan deviations, and dangerous commands before peer handoffs execute.
Multi-Modal Visual Invariants (Spatial & Diagrams)
Deterministic verifiers for Vision-Language Models, UI generation, and chart agents.
Catches bounding box collisions, severed flowchart connectors, and frame sequence drift before visual artifacts reach production.
Distributed State Rollback (Checkpoints)
Persist agent states to Redis, S3, GCS, File, or in-memory stores across long-horizon loops.
When an auditor rejects a step or a test assertion fails, state rolls back automatically to the last proven checkpoint.
In-Process Local Engine (Zero Network WAN)
Pass local=True in the Python SDK to run completely in-process using precompiled binary SQLite FTS5 indexes.
Zero network dependencies, 0.005ms warm LRU/TTL cache hits, and guaranteed SOC-2 zero-retention boundary compliance.
Connected to live production endpoint api.ejentum.com/logicv1/ with 311 precompiled cognitive abilities.
Empirical Results · 320-Test Promptfoo Suite (Frontier + Workhorse Runs)
Frontier Compliance at Workhorse Cost.
Benchmarked across 20 high-consequence systems engineering traps comparing raw models, static prompt wrappers, and Ejentum dynamic scaffolds (N=320 total evaluations across 4 models). Evaluated on deterministic test suites; raw datasets open for independent replication.
Gemini 2.5 Flash + Graph
20 / 20
Traps Caught in Test Suite ($0.020)
Passed all 20 precompiled systems engineering traps (Vanilla Flash: 17/20, Sonnet 4.5: 19/20). Note: Single run per configuration on deterministic test suite.
GPT-4o-mini + Ejentum
75.0% vs 60.0%
+15% vs Vanilla · +10% vs Wrapper
Passes 15/20 traps at $0.009 total run cost, beating raw GPT-4o (60.0% at $0.15) at 1/16th the cost.
GPT-4o + Ejentum
70.0% vs 55.0%
+15% over static prompt wrapper
Targeted ~150-token guardrails prevent attention dilution where generic system prompts degrade compliance.
Engine & WAN Latency
<2ms local · 45ms WAN
Sub-millisecond Local Engine Lookup
Local embedded SQLite/vector lookup is <2ms. Public cloud HTTPS transit averages 35-70ms. Fail-open client timeout recommended.
| Configuration | Model | Pass Rate | Mean Score | Run Cost (20 Traps) | Key Finding |
|---|---|---|---|---|---|
| Ejentum Graph (DAG) | Gemini 2.5 Flash | 100.0% (20/20) | 1.000 | $0.020 | +15% vs Vanilla (85%); beats Sonnet 4.5 at 15x lower cost |
| Ejentum Single | Gemini 2.5 Flash | 95.0% (19/20) | 0.988 | $0.016 | Ties wrapper (95%) while cutting output tokens by 17% |
| Gemini 2.5 Flash Baseline | Gemini 2.5 Flash | 85.0% (17/20) | 0.973 | $0.013 | Raw model; failed 3 traps (stampede, sharding, DNS cutover) |
| Ejentum Single / Graph | GPT-4o-mini | 75.0% (15/20) | 0.876 / 0.901 | $0.009 / $0.010 | +15% vs Vanilla (60%), +10% vs Wrapper (65%); beats raw GPT-4o at 16x lower cost |
| GPT-4o-mini Baseline | GPT-4o-mini | 60.0% (12/20) | 0.855 | $0.008 | Raw model; static prompt wrapper scored 65.0% (13/20) |
| Ejentum Single / Graph | Claude Sonnet 4.5 | 95.0% (19/20) | 0.975 | ~$0.300 | +10% vs Vanilla (85.0%); ties prompt wrapper (95.0%) |
| Ejentum Single / Graph | GPT-4o | 70.0% (14/20) | 0.874 / 0.864 | ~$0.240 | +15% vs Wrapper (55.0%), +10% vs Vanilla (60.0%) |
AI Governance & Reliability Lab • Interactive 3-Turn Demo
Audit-Grade Governance For
High-Stakes Autonomous AI Systems
Standard AI models flatter your bad architectural assumptions, offer generic security checklists, and hallucinate ungrounded code. Ejentum Ask demonstrates why context is key for engineers and technical program managers: you ask a technical question, Ejentum audits the premise and isolates missing variables, and progressive turns converge on verified production architecture.
Turn 01 / Premise Audit
Isolate Missing Variables & Attack Surface
Turn 02 / Architectural Context
Clarify Tool Privileges, Latency & State
Turn 03 / Hardened Solution
Converged Invariants, AST Gates & Zero Latency
Agent Security
SEC-01
Autonomous Agent Security
Audits why standard OWASP/TLS protections fail against indirect prompt injection and tool hijacking, isolating container boundaries and execution privileges.
Audit in 3 Turns →
Adversarial Audits
AUD-02
Adversarial Audit Scope
Moves beyond public jailbreak leaderboards to evaluate multi-turn epistemic drift, database tool invariants, and transactional blast radius.
Audit in 3 Turns →
Red Team Mechanics
RED-03
Agentic Red Team Mechanics
Tests multi-turn temporal state, vector RAG context poisoning, and tool calling order in CI/CD before releasing agent updates.
Audit in 3 Turns →
Workflow Auditing
WFL-04
Workflow Result Auditing
Replaces passive log dashboards with deterministic step-gated AST linters, intermediate checkpoint contracts, and contradiction sentinels.
Audit in 3 Turns →
Explore All 10 Technical Scenarios in Simulator
Educational Demonstration • Answers are 100% computer generated and do not take the place of formal technical security or legal audits.
Universal Integration
Drop in anywhere
LangChain
LangGraph
CrewAIn8n
Heym
LlamaIndex
Flowise
Langflow
MastraMake.com
Zapier
Botpress
Voiceflow
AgentOps
Smolagents
Antigravity
Codex
Claude CodeOpenAI
Anthropic
Google
Meta
Mistral
Groq
CohereHugging Face
Amazon Bedrock
Microsoft Azure
xAIReplicate
DeepSeek
Inception Labs
Fireworks AI
Nous ResearchPerplexity
Pricing
Developer-first. No contracts.
One month free. 1,000 dynamic calls. No card.
Quota Architecture: Wired at critical decision gates, not token loops. A 30-step autonomous agent typically invokes Ejentum only 2 to 3 times per task, so monthly quotas protect hundreds to thousands of full workflows.
Super
dynamic + adaptive · all harnesses
$29/month
Tailored reasoning. The harness rewrites the cognitive operation to fit your specific task. Safety checks stay locked.
Subscribe to Super →- ✓6,000 dynamic calls/month
- ✓2,000 adaptive calls/month
- ✓Protects ~2,000 to 3,000 multi-step agent runs at decision gates
- ✓4 harnesses · 311 cognitive abilities
- ✓Safety locks always active (failure guard, suppression, checkpoint)
- ✓Hosted MCP at api.ejentum.com/mcp
Go
dynamic + adaptive · all harnesses
$9/month
Dynamic reasoning across all four harnesses. Adaptive included.
- ✓1,500 dynamic calls/month
- ✓500 adaptive calls/month
- ✓Protects ~500 to 750 multi-step agent runs (2-3 calls/task)
- ✓4 harnesses · 311 cognitive abilities
- ✓Same API surface as Super
Free trial
one month · no card
$0/30 days
See what the harness does to your agent before deciding.
- ✓1,000 dynamic calls
- ✓Protects ~300 to 500 complete agent evaluation runs
- ✓Dynamic modes only (no adaptive)
- ✓All four harnesses unlocked
- ✓No payment method required
Decision Gate Quota Math
Why a 1,500-call quota protects 500 to 750 complete agent workflows
Sub-2ms Deterministic Gates (No Secondary LLM)
Ejentum is never wired inside an agent's inner token loop or called for trivial mechanical tasks (code formatting, linting, basic lookups). Instead, it operates as a pre-execution intercept solely at high-consequence decision gates. A complex 30-step autonomous agent typically invokes Ejentum only 2 to 3 times per task:
Gate 1: Trajectory Inception
Initial Decomposition
Catches sycophancy, false premises, and flawed user assumptions before the agent commits to an erroneous multi-step plan.
Gate 2: Mutation & Action
Tool Execution Guard
Verifies database migrations, cache flushes, state mutations, and external writes against production invariant checklists.
Gate 3: Multi-Step Convergence
State Anchor Check
Verifies that deep multi-turn execution (e.g. Step 40+) has not drifted from Step 1 security contracts and ground truths.
Net Cost per Protected Task: ~$0.012 on Go ($9/mo) | ~$0.009 on Super ($29/mo)
Read Decision Gate Architecture in Docs →
Start free. Step up to Go for ongoing use. Super when your agent needs adaptive reasoning at production volume.
Honest Scope
Ejentum doesn't help every agent. If you're running a single-step classifier, a simple RAG lookup, or any task where the model already converges in one hop, you're paying for cognitive overhead you don't need. Ejentum earns its cost on multi-step chains where errors compound: planning agents, research agents, code agents that touch more than a handful of files. If that's not you, don't buy this yet.
Bob Franks
Co-Founder & CEO
The thread holds.
Every step.
One month free. 1,000 dynamic calls. No card.