Quickstart

Connect your model to the reasoning engine

One JSON block. Your model keeps its own API key — the Kohnex Brain engine adds expert reasoning on top of every answer.

1. Add to your MCP config

{
  "mcpServers": {
    "kohnex": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://kohnex.com/sse"],
      "env": { "API_KEY": "khnx_..." }
    }
  }
}

Works with OpenCode, Claude Desktop, Cursor, VS Code, and any MCP client.

Core concept

The Kohnex Brain engine

Kohnex is a reasoning engine, not a library. It holds expert reasoning inbuilt — a 1,800-node knowledge graph across 38+ domains — and it creates new reasoning on demand when nothing inbuilt fits.

Inbuilt reasoning

2,000+ expert reasoning modes distilled from the knowledge graph, covering coding, security, diagnosis, strategy, and 18 more domains. The engine matches your question to the right reasoning in milliseconds and injects it into your model's thinking.

Created reasoning · forge

For novel problems, the engine builds new reasoning from scratch: multiple agents generate, critique, red-team, and synthesize — then score the result on a quality rubric. Nothing is copied; everything is forged.

Reference

Engine tools

Every tool calls the same engine. Always start with maple() — it finds the reasoning your question needs.

Find reasoning

maple

Find the right reasoning

Scores candidates 0–100 for your question. Returns names, taglines, and domains. Always call this first.

blitz · New

Multi-mode engine search

Keyword, semantic, or hybrid search with domain filtering. For large reasoning libraries.

willow

Browse by domain

Lists the reasoning the engine holds, filterable by domain. Use when exploring.

kohnex_stats

Engine statistics

Totals, domains, and per-domain reasoning counts.

Load reasoning

cedar

Load full reasoning

Takes a reasoning ID. Returns complete steps, output format, and instructions.

Combine reasoning

birch

Blend two reasoning modes

Combines two engine reasoning modes into one custom flow for complex tasks.

fuse · New

Weighted blend

Blends with per-mode weights and conflict resolution. Higher weight wins.

Create reasoning

aspen

Draft new reasoning

The engine drafts new reasoning from a plain-language description.

forge · New

Swarm-forge new reasoning

Multi-agent build: generate → critique → red-team → synthesize, with quality scoring.

Knowledge engine

oak

Full knowledge activation

Fires the whole knowledge network for cross-domain synthesis on hard questions.

kohnex_path

Concept connections

Shortest path between any two concepts in the knowledge graph.

kohnex_domain

Domain deep-dive

Lists every node in a knowledge domain.

kohnex_mode

Thinking modes

Describes any of the 28 engine thinking modes and when to use it.

kohnex_explore

Deep exploration

Multi-mode deep-dive on any topic with cross-domain connections.

Reasoning methodologies

methodologies

Reasoning methodologies

Browse, load, generate, create, fork, and manage structured reasoning methodologies.

Reference

Workflow

The standard flow: the engine finds the reasoning, loads it, your model follows it.

User asks question
  → maple()          Engine finds the right reasoning
  → Pick top         From scored candidates
  → cedar(id)        Engine loads the full steps
  → Follow steps     Model reasons like an expert
  → Answer           Structured, expert-level

Reference

Reasoning domains (22)

The domains the engine reasons across. maple() routes your question to the right one.

Logic & Proof
Discovery
Focus & Depth
Decision & Strategy
Diagnosis
Consensus
Future & Scenarios
Evidence
Creative
Systems
Resilience
Linguistic
Temporal
Ethical
Algorithmic
Conceptual
Causal
Model & Framework
UI Design
UX Strategy
Coding & SE
Cybersecurity Expert

Reference

Examples

Two sample prompts showing the engine flow.

Example 1

Security analysis

What are the security risks of deploying AI agents in production?

Ask the engine (maple) for security reasoning → load it (cedar) → answer like a threat analyst
Example 2

Code review

This Python function is too slow. Help me optimize it.

Ask the engine (maple) for performance reasoning → load it (cedar) → answer like a staff engineer