A single call
trivial · fast
For builders of autonomous systems.
Tell your agents how hard to think before they spend the call.
Quantum-grounded. Cultivated, not weighted. No LLM picks it. A different kind of intelligence.
Send the step. Kongen returns a typed reasoning regime, a confidence, and a token budget. One call. No model behind it. Same input, same answer, for a given scorer version.
1,000 KT freeno credit cardopen‑source SDKs
01The decision
One call in. One typed decision out.
An intelligence layer for agent orchestration: every step comes back with a reasoning regime, a confidence and a token budget. Typed values your code branches on, from an engine that makes zero inference calls. What you do with them stays yours. Pick a regime to see a real step scored.
# the request curl https://api.kongenlabs.life/v1/logic/score \ -H "X-API-Key: $KONGEN_API_KEY" \ -H "Content-Type: application/json" \ -d '{"text": "Given these three failing tests, find the shared root cause and propose a fix."}'
# the response { "regime": "deep", "confidence": 0.78, "confidence_adj": 0.0, "recommended_tokens": 1500, "tokens_used": 1, "request_id": "req_..." }
Real output from the shipped scorer. Same input, same answer, for a given scorer version.
Score a step of your own: 1,000 KT free, no credit card.
Start freeWhich model a tier means is your decision, not ours. Budget is what the API returns for the step; tier price is this page's reference list price per million output tokens, as listed on 5 October 2026, so it follows the tier and not the budget. How that is worked out.
confidence
0 to 1, how decisively the step committed. Gate on this one: a low answer is the step to widen or to put in front of a person.
recommended_tokens
The budget. It goes straight to your max-tokens.
02The agent’s shape
Pick the agent, not just the model.
The regime says how much thinking a step needs. Use it to decide what runs the step: a single call, one agent with tools, a plan that checks itself, or a team. The confidence decides who reviews the work.
One agent, with tools
moderate
Plan, act, check
deep
A team
exhaustive
Below your confidence threshold
Any shape gets a reviewer, or a person at the gate. A team costs the most of any shape, and the regime is how you keep it for the steps the scorer calls exhaustive.
An example map: the shapes, the threshold and the tiers are yours to set.
# the regime picks the shape -- your map, not ours SHAPE = { "trivial": single_call, "fast": single_call, "moderate": agent_with_tools, "deep": plan_act_check, "exhaustive": agent_team, } def run(task): d = kongen.logic.score(task) # 1 KT, no model call agent = SHAPE[d.regime] if d.confidence < 0.6: # it did not commit agent = with_reviewer(agent) # or a person at the gate return agent(task, max_tokens=d.recommended_tokens)
03In the loop
Ask before every call. Act on the answer.
An agent step is decide, call, check. Kongen is the decide.
$ pip install kongenlabs
Click to copy
Python and TypeScript SDKs, and an MCP server, on the same key. What the API returns.
# pip install kongenlabs from kongen import KongenClient kongen = KongenClient() def step(task): d = kongen.logic.score(task) # 1 KT, no model call if d.confidence < 0.6: # it did not commit return escalate(task) # widen, or ask a human return call_model( task, model=TIER[d.regime], # your map, not ours max_tokens=d.recommended_tokens, )
04The obvious objection
Why not just ask a model to decide?
Because that is a model call too, and Kongen makes no inference call of its own.
What you save by not asking a model to decide
9.4× faster
to decide, per step, at the median
25 hours a month of waiting, back to your tasks
100,000 steps × 0.89 s each
+140% ROI
on Kongen’s fee, every decision
$98 a month, back to your budget
100,000 steps × $0.00098 each · priced per token, not per second
- Every decision
- 1.0 s → 0.11 s
- A six-step task, deciding
- 6.0 s → 0.6 s
- Each decision costs
- $0.00168 on the model · $0.0007 on Kongen
How these are worked out. Kongen’s measured median is 106 ms: 80 consecutive calls to its scoring endpoint in one 25-second run on 5 October 2026, timed end to end from one client through Cloudflare’s IAD edge on a connection already open (kept alive). Opening a new connection, or calling from farther away, adds time that this run did not measure. Each decision is 1 KT ($0.0007). You set how long your model takes. Faster is your model’s time divided by Kongen’s. ROI is what the model’s decision costs, minus Kongen’s $0.0007, divided by $0.0007. The model’s decision is priced at list prices as listed on 5 October 2026, for a call that reads 270 tokens and writes 30: $4 and $20 per million tokens in and out for a frontier model, $1 and $5 for a small one. A longer prompt costs the model more. Hours are agent time saved, added up over every step.
Same step, decided twice
# the step
"Given these three failing tests, find the shared root cause and propose a fix."
A model deciding
1.00 s$0.00168step done{"regime": "deep", "budget": 1500, "why": "debugging across several tests"}
Runsdeep
Kongen
0.11 s$0.0007step done{"regime": "deep", "confidence": 0.78, "recommended_tokens": 1500}
Runsdeep
Kongen decided 9.4× faster0.11 s against 1.00 s, at the decision time set above
The model lane runs at the decision time set above, and the answers it moves between are examples, not a measured model’s output. The Kongen lane is the scorer’s real answer for this step, at its published median time.
9.4× faster to start
A model has to generate before the step can begin. A Kongen answer is arithmetic over the input: there is no sampling to wait for.
Repeatable
Same step, same answer, for a given scorer version. That is a decision you can write a test against, reproduce an incident from, and budget from.
Cost-optimised
One KT a decision, and the steps that do not need the frontier tier move off it: an estimated 21 to 43% off the cost of sending every step to a frontier model, at the estimator’s defaults; shorter requests save less. See how it is calculated.
Kongen scores the step: a regime, a confidence and a token budget, from an engine that makes no inference call of its own. It does not pick a model and it does not hold your model map.
Routing is one thing to do with that answer. Capping a budget is another, and escalating a low confidence to a person is another. The layer that decides stays yours, and it stays ordinary code, which is what makes it something you can test against and budget from.
A model asked to make that call is one more call in the loop, and one that can answer two ways on two runs. Scored 2,000 times on the prompt above, these four fields came back identical.
05The comparison
Six steps, priced twice.
One loop, run two ways: every step on the frontier tier, and every step on the tier its regime earns.
StepAlways frontierEarned tier
List changed files$0.0200$0.0057trivial → small
Write a commit message$0.0200$0.0057fast → small
Explain a slow query$0.0200$0.0207deep → frontier
Find a root cause$0.0200$0.0207deep → frontier
Find a deadlock$0.0200$0.0207exhaustive → frontier
Weigh mitigations$0.0200$0.0207exhaustive → frontier
Total$0.1200$0.0942
The same loop, per million tokens
$20.00
every step on the frontier
$15.70
every step on the tier it earns
21.5%
stays in your budget
Four of the six still go to the frontier tier. The two that do not are the difference: $0.0258, or 21.5%.
Illustrative: six steps is not a measured workload. The headline band this site quotes is an estimated 21 to 43% against sending every step to a frontier model, at the estimator’s defaults; shorter requests save less. Prices are a 1,000-token reference request at $20 and $5 per million output tokens, list prices as listed on 5 October 2026, plus $0.0007 per scoring call. See how it is calculated.
06Receipts
Two numbers, and where each one comes from.
One measured, one estimated; each links to where it comes from.
21 to 43% lower cost, estimated
Each step on the tier its regime earns, against every step on a frontier model, at the estimator’s defaults; shorter requests save less. The model map is yours, not ours. See how it is calculated.
2,000 of 2,000 the same
One step, scored 2,000 times against the shipped scoring module: the four fields came back identical every time, for that scorer version. Score one twice and compare. What the API returns.
07What you can use, and what is coming
Six products. One Kongen key.
Three you call directly. Three grow in the Garden.
Call Kongen directly
Logic SDK Available now
POST /v1/logic/score: one call returns the regime, the confidence and the token budget for a step: the same answer for a given scorer version, with no model call to wait for. It is the decision the rest of this page is about. Python and TypeScript SDKs on the same key.
Pattern Transfer Available now
POST /v1/transfer/score: score a structural signature against the organisms' cross-domain reference patterns, and get back what it matches and how closely. The reference patterns are research outputs, some from work we have since withdrawn. Unverified: to be re-derived on our rebuilt research platform.
MCP Server Available now
POST /v1/mcp/tools/call: the same key spoken as Model Context Protocol, so an agent calls Kongen natively instead of through glue you maintain.
In the Garden
Flow Available now
Chat without choosing the model. Flow tells you which one answered and what it cost, and its client is Apache-2.0, so you can read exactly what it sends and what it shows.
Loop Not shipped yet
A harness between your agents and the models they call: route each step, check what comes back, gate what gets through. Nothing to install yet.
The data-centre app Research stage
A research-stage app on machine telemetry. Its first figures came from synthetic data and are withdrawn; nothing about it is claimed yet.
Open source on GitHub, MIT: Python SDK, TypeScript SDK, MCP server, examples. Flow is Apache‑2.0.
09How it is grown
We grow digital organisms.
Each one senses a different world: genes, language, reasoning, code. One seed, many worlds.
One pattern language.
It isn’t something we invented. It’s the mathematics Turing found in living nature, inside a framework grounded in quantum physics: the same rules that give a leopard its spots.
A nursery, not a research project.
Same seed, new senses. Every organism starts from the same seed and is cultivated through a defined sequence of stages, every stage recorded, until it matures in its own field.
What one learns, the others can read.
They share one language, so what one organism learns reaches the others through Kron, the meta layer.
Kongen for the intelligence · the Garden for the produce
Kongen grows the intelligence. The Garden cultivates it.
Kron flows from the source. One spark wakes the garden, and what any organism learns flows back through Kron to the rest.
FlowLoopData centre app