Blog

July 2026

Flow is now open source — and it's a bet on who owns your conversations

Flow keeps your conversations on your device, routes each prompt to the model best suited to it — with a router that isn't a language model — and shows you what each reply saved. Today it's Apache-2.0 open source. Here's the whole thing.

Chat apps have quietly become working memory. If you use an LLM every day, your threads are where your half-formed ideas, your project context, and your good prompts actually live. And right now, for almost everyone, that memory sits on someone else's server — under someone else's retention policy, one deprecation notice away from disappearing.

We built Flow around a different default: your conversations are yours, they live on your device, and the app is built so no server can compress them, truncate them, or take them away. Today we're making the whole client open source under Apache-2.0, at github.com/kongen-labs/flow.

This is also a reframe. We used to call Flow "a free chat app." That undersold it and, honestly, muddied the "free" claim — you bring your own provider keys and pay those providers directly. So here is the sharper version of what Flow is:

GPTs come and go. You stay in control.

Four things sit under that line.

1. Your history lives on your device

Conversations are stored in your browser (IndexedDB), and there is no server copy. Export is plain JSON — your history is a file you own, not an account you rent. No "conversation too long." No silent compression behind your back. No losing a thread because a provider retired a model.

The honest boundary, stated up front because it's the whole point: "on your device" is only as durable as your device and your exports. Browser storage can be evicted under extreme disk pressure, and there's no cross-device sync yet — the phone copy and the laptop copy are separate until you export and import. So the durability promise rests on export, and we made export a one-click JSON file rather than a buried setting. We'd rather tell you where the edge is than round it off.

2. The router that picks your model is not a language model

This is the part that pays for our time, and it's the part worth being precise about.

A common pattern in "smart routing" is the LLM-judge approach: to decide where your prompt should go, it asks another model. That's a second inference call before you get any answer — slower, with its own token cost, and it hands your prompt to yet another model just to make a decision.

Flow doesn't do that. Each prompt is scored by Kongen Logic, a pattern-based, in-process classifier — it reads the reasoning depth of your prompt by structure, not by asking a language model. There's no extra LLM sitting between you and your answer.

Being exact, because this matters: your prompt text is sent to Kongen to be scored — that's step one. The claim is "no additional LLM in the loop," not "nothing is sent." The scoring step is computation, not another model reading your prompt. The routing decision it records is the decision itself — the reasoning regime, a confidence, the chosen model — not your prompt's text. Your provider keys, your conversation history, and the model's answers never touch our servers; answers stream provider → browser using your own key.

There's a longer story here for anyone who wants it. The scorer is grown on the UAF framework, and it's cultivated, not weighted: it wasn't fit to a pile of labeled prompts the way a neural net is trained, it was grown from structural patterns. UAF itself is a quantum-grounded theory of how structure forms. That is a claim about the theory and not about this software: the scorer you are calling is an ordinary classical implementation running on ordinary hardware. If that sounds unusual, the whitepaper has the full account. For using Flow, the only thing you need to know is the practical claim: what picks your model isn't an LLM, and every routing decision is shown so you can audit it and override it.

3. You watch what it saves — on your own data

Most routers ask you to trust a savings percentage. Flow shows you the number instead.

The mechanism is right-sizing: a one-line reformat doesn't need a frontier model, so it doesn't get one; "prove this bound" does, so it does. The savings are the outcome of matching the model to the job — trivial prompts stop hitting frontier pricing — never a matter of picking the "lowest-priced" model. Each reply shows its routing decision and an estimated cost, and Flow keeps a running, on-device estimated-savings total, labeled "est.," measured against always using your provider's frontier model.

We're deliberately not printing a marketing percentage in this post. The number that matters is the one Flow computes on your prompt mix, on your device, where you can check it. That's the house style: the proof is in the app, not the ad copy.

And there's a second consequence beyond your bill — sending "fix this typo" to a frontier model spends far more computation than the task needs. Right-sizing the model to the prompt means you waste less compute.

4. Bring your own keys — five providers, no lock-in

Anthropic, OpenAI, Google, Mistral, DeepSeek. Provider keys are stored locally in your browser and are never sent to our servers — calls go browser → provider. Switch providers without abandoning your history.

And now that the client is open source, "no lock-in" is a structural claim, not a promise. Apache-2.0 is permissive and carries an explicit patent grant — the kind of license teams are comfortable building on. Fork the client, read exactly what leaves your device, wire it into your own stack. We'll say the uncomfortable part out loud, because any engineer would notice it anyway: nothing in the license stops a fork from ripping out the Kongen call and routing some other way. What's in the open repo is the client — the UI, the local storage, the cost display. What's not in it is the routing intelligence; the scorer lives server-side behind the API. Our bet is simple: the routing is worth calling. If it ever isn't, you can leave, and that's the point.

Getting started

The gate is thin, and we won't pretend it isn't there: one email verification mints a free Kongen key — no password, no profile, no credit card. That key is what runs the routing.

• Try it: flow.kongenlabs.life — installs as a PWA on your phone.
• Read the source: github.com/kongen-labs/flow (Apache-2.0).

Save money. Save time. Keep everything.

flow · open-source · local-first · llm-routing · byo-keys

May 8, 2026

A Hypothesis About Prompt Structure

The hypothesis: the structural patterns that distinguish "easy" from "hard" prompts have the same mathematical shape as the patterns that emerge in market dynamics, gene expression, locomotion, and other domains where stable structures form from interacting forces. If those structural shapes are universal — not domain-specific — a scorer built on that shape should generalise to new ones better than any classifier trained on a single domain's data.

Correction (October 2026): this post first reported a genetics-to-language transfer figure, a language-to-locomotion figure, and data-centre detection figures, and listed capital markets and data-centre telemetry among the training domains. These are withdrawn outright. Neither transfer figure was checked against a noise control before it was published, and the genetics-to-language work is being rebuilt under a pre-registered design. The data-centre figures came from benchmarks our own pipeline generated and scored against itself, with thresholds hand-set per source. Every research result in this journal is unverified until it is re-derived on our rebuilt research platform. This supersedes the August note below, which said the genetics-to-language results stand; that sentence has been removed from it. This post, including its headline, also said our prompt router was trained across unrelated domains, among them biology and Go, and that the Logic SDK consumes the Pattern Transfer corpus. We have withdrawn both. The Logic scoring call computes its result from the prompt alone. Corrections are dated and stay where the claim was made.

Correction (August 2026): an earlier version of this post reported a 100% structural match between gene-expression patterns and capital-market support/resistance patterns. Our internal provenance audit found the capital-side data came from an untrained encoder and carried no market information, so we have retracted that result. We publish our corrections for the same reason we publish our methods.

Routing and cost

At the estimator’s defaults, routing is estimated to save 21 to 43% against sending every prompt to a frontier model, at list prices as listed on 5 October 2026; shorter requests save less (see how that is calculated, and plug in your own numbers). The Logic SDK calls themselves cost about $0.0007 per Kongen Token. The earlier post on the 20-line router has the per-batch breakdown.

What ships today

The full Pattern Transfer corpus is queryable via the Pattern Transfer API.

pip install kongenlabs

Get started free — 1,000 Kongen Tokens, no credit card. Larger workloads are pay-as-you-go after.

The MCP server is also live (pip install kongenlabs-mcp) — Claude Code, Cursor, and Windsurf can call Kongen natively. Documentation at kongenlabs.life/whitepaper.

cross-domain · llm-routing · pattern-intelligence

Early May 2026

Pattern Intelligence Reaches Datacenter Telemetry

The seventh signal layer, since paused (see the October 2026 correction below).

We've extended Kongen's pattern analysis to datacenter telemetry, a domain that looks nothing like the others on the surface.

The Pattern Transfer API stays unchanged. The endpoint at /v1/transfer/score now accepts datacenter signal vectors alongside the other six domains. The signal-vector contract is the same; the reference corpus is broader.

Correction (October 2026): this post first reported live production ingestion, 100% detection across simulated validation benchmarks, lead times of 5 to 110 minutes over threshold monitoring, a 90% alert-fatigue reduction and a 75% mean cross-domain transfer figure, all with zero per-dataset tuning. Our internal audit found the benchmarks were generated by our own pipeline and scored against itself, with thresholds hand-set per source, and that live ingestion had been paused in May 2026 for lack of usable signal. Those figures and that description are withdrawn. Every research result in this journal is unverified until it is re-derived on our rebuilt research platform. Corrections are dated and stay where the claim was made.

infrastructure-telemetry · cross-domain-validation · anomaly-detection

March 26, 2026

How We Route LLM Calls to the Right Model

Part of your LLM spend goes to models bigger than the prompt needs. Here's the fix.

If you're calling Claude or GPT from production code, you're almost certainly using one model for everything. Opus for "What is 2+2?" Sonnet for boilerplate summaries. Every prompt gets the same expensive treatment because building a router is hard and getting it wrong means bad answers in prod.

We built a scoring API that classifies each prompt's reasoning complexity (a call measured 106 ms at the median, end to end, in one October run; see Latency, below), then tells you which model to use. Routing is estimated at 21 to 43% lower cost, at list prices as listed on 5 October 2026 and the estimator’s defaults, than sending every prompt to a frontier model (see how that is calculated, with your own prompt mix). Shorter requests save less.

Five Reasoning Regimes

Every prompt falls into one of five regimes based on how much reasoning it actually requires:

The API returns the regime, a confidence score, and a recommended token budget. One call, with no model call to wait for:

from kongen import KongenClient

client = KongenClient()

# Simple arithmetic — don't waste Opus on this
result = client.logic.score("What is 2+2?")
print(result.regime)             # "trivial"
print(result.recommended_tokens) # 32

# Hard math — this actually needs a strong model
result = client.logic.score("Prove that sqrt(2) is irrational")
print(result.regime)             # "deep"

The 20-Line Router

Here's the complete working router. Drop it into any codebase that calls an LLM API:

import anthropic
from kongen import KongenClient

kongen = KongenClient()
claude = anthropic.Anthropic()

MODEL_MAP = {
    "trivial":     "claude-3-5-haiku-latest",   # $1/M tokens
    "fast":        "claude-3-5-haiku-latest",   # $1/M tokens
    "moderate":    "claude-sonnet-4-latest",    # $3/M tokens
    "deep":        "claude-sonnet-4-latest",    # $3/M tokens
    "exhaustive":  "claude-opus-4-latest",      # $15/M tokens
}

def smart_call(prompt: str) -> str:
    score = kongen.logic.score(prompt)
    model = MODEL_MAP[score.regime]
    resp = claude.messages.create(
        model=model,
        max_tokens=score.recommended_tokens,
        messages=[{"role": "user", "content": prompt}],
    )
    return resp.content[0].text

That's it. Every prompt gets classified, routed to the most efficient model, and given an appropriate token budget. The scoring call itself costs 1 Kongen Token (then about $0.00005; $0.0007 today).

Real Numbers

We ran a mixed workload of 5 representative prompts through the router vs. sending everything to Opus:

How It Actually Works

The scoring engine analyzes the structural features of each prompt — the balance between open-ended reasoning and concrete constraints — and maps that to a signal vector. A simple question produces a flat signal. A multi-step proof under constraints produces a layered one. The shape of that vector predicts reasoning complexity.

Latency

• p50: 169ms
• p90: 246ms

Update (October 2026): these March figures were published without their method. Measured on 5 October 2026 in one 25-second run of 80 consecutive calls from one client, through Cloudflare’s IAD edge on a kept-alive connection: 106 ms at the median, 144 ms at the 90th percentile. A new connection adds time that this run did not measure. An earlier version of this entry also compared the call with a database query; that comparison was never measured and is withdrawn.

Get Started

Get started free — 1,000 Kongen Tokens, no credit card. That's 1,000 prompt classifications — enough to validate savings on your actual workload before paying anything.

pip install kongenlabs

Playground at garden.kongenlabs.life/playground. Paste a prompt, see the regime classification live. No signup required for the playground.

Docs, SDK source, and pricing at kongenlabs.life. No credit card required for the free tier.

Correction (October 2026): an earlier version of this entry reported regime-classification accuracy above 97% and model invariance, and said the scoring approach generalizes across data domains, validated on datasets spanning biology, finance, strategy and language. The accuracy figures measured how often the answering model was right, not how often the scorer classified correctly, and the finance data was retracted in August 2026. Every research result in this journal is unverified until it is re-derived on our rebuilt research platform. We have withdrawn those statements. Its lead said most LLM spend is wasted, which we never measured, and its headline said routing happens "without losing quality": that described an intent, not a measured result, and we have published no quality comparison. Corrections are dated and stay where the claim was made.

llm-routing · cost-optimization · prompt-scoring · show-hn

March 13, 2026

Multi-Domain Validation

We tested our pattern analysis across six independent domains. Here's what we found.

The core question behind Kongen's scoring engine is whether a single approach to measuring signal complexity can generalize beyond any one domain. To find out, we ran a validation across six completely different data sources.

Correction (October 2026): an earlier version of this entry, including its headline, reported statistically significant transfer between domain pairs, accuracy above baseline on every validated pair, millions of signals analysed, and natural language as the strongest source of cross-domain transfer, and concluded that the signal vectors are not domain-specific. The financial-market data in that run was retracted in August 2026. Every research result in this journal is unverified until it is re-derived on our rebuilt research platform. We have withdrawn those results and that conclusion. Corrections are dated and stay where the claim was made.

March 10, 2026

LLM Reasoning Classification

We set out to answer a straightforward question: does our prompt scoring hold up across different LLM providers and model sizes?

We ran hundreds of prompts — math, logic, code, and open-ended analysis. The scoring engine classified each prompt's reasoning complexity before the model ever saw it.

Correction (October 2026): an earlier version of this entry, including its headline, reported that our prompt scoring is model-invariant, with the same prompts landing in the same reasoning regimes across model families. That result has not been verified under our current research controls, so we have withdrawn it. We publish our corrections for the same reason we publish our methods.

March 5, 2026

Why Cross-Domain Validation Matters for Prompt Routing

A common concern with prompt classification: how do you know it generalizes? What if the scoring engine only works on the kinds of prompts you tested it on?

Our approach was to validate the underlying signal analysis on data that looks nothing like text. We ran the same analysis pipeline on movement data, game state sequences, and biological signals — domains with completely different structure and semantics.

Correction (October 2026): an earlier version of this entry reported that signal patterns from one domain could predict outcomes in another with statistically significant accuracy, and concluded that the scoring engine generalizes to prompts it has never seen. Every research result in this journal is unverified until it is re-derived on our rebuilt research platform. We have withdrawn that result and its conclusion. Corrections are dated and stay where the claim was made.

February 28, 2026

Testing the Domain Barrier

We applied our pattern analysis to a new category of biological data — gene expression measurements from public research datasets. The question: do the same signal vectors computed for text also capture meaningful structure in genomics?

Correction (October 2026): this entry, including its headline, reported that signal patterns extracted from gene expression matched structural patterns in natural language at well above chance accuracy, and that signals from one domain predict outcomes in another. That genetics-to-language result was not checked against a noise control before it was published; it is withdrawn while the work is rebuilt under a pre-registered design. This supersedes the August erratum below, which said the genetics-to-language result stands; that sentence has been removed from it. Every research result in this journal is unverified until it is re-derived on our rebuilt research platform. Corrections are dated and stay where the claim was made.

Erratum (August 2026): an earlier version of this entry reported that biological signal patterns also matched structural patterns in financial time series, in both directions, and described a normalization technique that unlocked transfer to domains that previously showed no signal. Our internal provenance audit found the financial-side data came from an untrained encoder and carried no market information; the normalization step manufactured that apparent match, which is reproducible from random noise. We have retracted the financial-market result and the normalization-breakthrough framing. We publish our corrections for the same reason we publish our methods.

February 27, 2026

Shipping Fast: Six Domains in Three Days

We planned four weeks of integration work. We shipped in three days.

The goal was to connect six independent data analysis pipelines — each processing a different type of signal — into a single scoring system. By end of day, all six were connected and sharing structural features.

Over 500 automated tests passing. Zero failures. The speed came from a clean internal interface: every data source, regardless of domain, produces the same kind of signal vector. When the interface is right, integration is fast.

Correction (October 2026): an earlier version of this entry said natural language emerged as the strongest source of transferable signals. Every research result in this journal is unverified until it is re-derived on our rebuilt research platform. We have withdrawn that statement. Corrections are dated and stay where the claim was made.

February 26, 2026

From Research to Production

Today we deployed our first production scoring pipeline. Real data, real decisions, real stakes.

The system runs continuously: ingest signals, compute structural features, classify patterns, rank by confidence, and surface the highest-value results. The whole loop executes in minutes. We started with a conservative configuration — tight limits, single data source, narrow scope.

Now we find out if the patterns hold in the real world.

Update (October 2026): this pipeline was the markets organism's live trader. It was halted on 3 June 2026 and is not running; this site makes no claim about its performance.

January 2026

Why We Built Kongen

Every LLM call has a cost. Part of LLM spend goes to models bigger than the prompt needs.

We started with an observation we have not verified: similar structural motifs seemed to recur in very different kinds of data, from genomic signals and natural language to game states and physical motion. Whether they are the same patterns is something we test, not yet a result.

Correction (October 2026): this entry first said most of the cost of an LLM call is waste, which we never measured, and stated as fact that the same patterns appear in financial time series, genomic signals, natural language, game states and physical motion. The financial-market result was retracted in August 2026, and every research result in this journal is unverified until it is re-derived on our rebuilt research platform. Corrections are dated and stay where the claim was made.

That observation led to a scoring engine. If you can measure the structural complexity of any input, you can predict how much computational effort it needs. Applied to LLM prompts, this means you can route each call to the lowest-cost capable model.

Kongen Labs is the productization of that insight. We offer:

• Logic — Prompt scoring and reasoning regime classification
• Patterns — Cross-domain signal analysis via API
• Flow — Conversations that outlive any single model
• SDKs — Python and Node.js clients, plus an MCP server for tool-use agents

Get started free — 1,000 Kongen Tokens, no credit card.

"Route every call to the right model. Pay only for the intelligence you need."

Reference

About Kongen Labs

Who we are and what we're building.

The story behind Kongen and the team building a router that isn't a language model. Read the full About page →

Reference

Whitepaper

The technical foundation behind Kongen's pattern-based routing.

How Kongen scores a prompt's reasoning depth and routes it to the model best suited to it — the full technical account. Read the full whitepaper →