Start here
How the Kohnex engine works
Kohnex does not change your model. It changes how the model thinks — the engine injects expert reasoning into the model's chain-of-thought before it answers. The reasoning is inbuilt, and when nothing inbuilt fits, the engine forges new reasoning on the spot.
Ask the question
Your model gets the question from you — the same way it always does.
Engine forges the reasoning
forge() builds expert reasoning for your task — with a quality score from 0–100.
Check the score, tune it
Above 90: use it. Below: tune depth, rounds, population and retry until sharp.
Your model follows it
The same model now answers step-by-step — like a senior engineer, not a guesser.
Before (model alone): "The bug is probably a typo. Check your code." After (model + Kohnex engine): "1. Reproduce the failure reliably. 2. Read the error message exactly. 3. Trace the code path from input to failure. 4. Check the assumptions the code makes. 5. Fix the root cause, verify nothing else breaks."
Tutorial 01
Your first engine call
Give the agent a problem — forge() builds the reasoning, scores it, and your model follows the steps.
Our application is timing out under load. Use forge() to build reasoning for diagnosing performance issues. Check quality.overall — above 90, follow the steps exactly and keep the answer plain and practical. Below 90, retry with depth="deep".
forgeForge the reasoning
Describe the task. Returns expert steps plus a 0–100 quality score.
qualityTrust the score
Above 90 means battle-tested. Below means tune depth, rounds, population and retry.
followFollow the steps
Your model answers step-by-step — like a senior engineer, not a guesser.
Tutorial 02
Real-world examples
Three complete workflows — complex coding and debugging, security hardening, and product strategy. Copy each prompt as-is.
Complex coding & debugging
A production service intermittently fails with a race condition. Watch how engine reasoning forces the model to think like a senior engineer — reproduce first, never guess.
Our checkout service intermittently fails with a race condition under concurrent requests. Use forge() to build reasoning for this kind of bug with depth="deep". Check quality.overall, then follow the steps exactly: reproduce the failure, read the error, trace the path, check the assumptions, and fix the root cause. Show your reasoning at each step before the fix.
No guessing. Every step must be shown before the fix.
Pulse (diagnose), Spike (focus), Chain (prove it).
Models jump to "probably a typo." Engine reasoning forces structure.
Security review & threat analysis
A security review is only as good as the thinking behind it. This prompt makes the model hunt like an attacker — including what it is not looking for.
Review this Node.js API for security vulnerabilities. Use forge() to build reasoning for security review with depth="deep". Check quality.overall, then follow the steps: list the attack surface, trace each entry point, hunt for the least obvious threat (what am I NOT looking for?), and rank findings by exploitability. End with a practical hardening checklist.
Attack-surface first, not a generic "use HTTPS" list.
Shield (defense), Ghost (break it), Strike (adversarial).
Models list known issues; engine reasoning makes them hunt for the unknown.
Product strategy & positioning
Strategic questions get a 4-step OODA-style treatment: observe the market, orient with evidence, decide between options, act with a plan.
We make a lightweight analytics tool and a big competitor just dropped a free tier. Use forge() to build reasoning for strategy with depth="standard". Check quality.overall, then follow the steps: observe the market moves, orient with what is actually changing, weigh our options (fight, pivot, focus, partner), and recommend one decision with a 90-day action plan. Challenge your own recommendation at the end.
Observe → orient → decide → act. No gut-reaction strategy.
Warpath (strategy), Radar (market scan), Fork (futures).
Models answer "lower your price." Engine reasoning forces a full strategic loop.
Quick reference
Forge playbook: which settings for which task?
One tool, tuned per task. Describe the job, check the score, tune until sharp:
| Task | Forge call |
|---|---|
| Fix a bug | forge, depth="deep" |
| Security review | forge, depth="deep" |
| Architecture call | forge, depth="standard" |
| Quick question | forge, depth="quick" |
| High-stakes build | forge, rounds=3, population=5 |
| Niche domain | forge, domain="..." |
Model Guides
Make your model smart
The same engine flow works on any model — frontier or open-weight. Here's how it plays out.
GPT + Kohnex for Code Review
Ask for a review with the engine finding security reasoning. GPT checks each file line-by-line instead of giving a generic "looks good."
DeepSeek + Kohnex for Debugging
DeepSeek gets diagnosis reasoning from the engine: reproduce → read error → trace path → check assumptions → fix root cause.
Claude + Kohnex for Architecture
Architecture questions get systems reasoning: parts, connections, feedback loops, leverage points — not just a diagram.
Llama + Kohnex for Strategy
Llama uses decision reasoning to weigh options with evidence and commit — observe, orient, decide, act.
Go deeper
Compose the engine
A strong workflow describes, forges, checks, and tunes — the engine covers the whole arc.
1. forge() → engine builds the reasoning + quality score 2. Check score → above 90: use it; below: tune and retry 3. Tune → depth, rounds, population up until sharp 4. Cite the pattern → name it in your answer 5. Follow the reasoning → apply the steps to your question