Built To Be Right, Not Just Fast.
Kael comes in two models, Kael Beta and Kael Pro Beta, built for accurate coding, security, math and agentic work. It thinks before it answers, behind an API you already know how to call.
The Facts, Up Front.
Everything you need to decide whether Kael fits, before the explanation. Limits, formats, what it accepts and what it does not. Each item below is covered in more detail further down the page.
- Model IDs
- kael-beta, kael-pro-betaTwo models. The string you pass as "model".
- Status
- BetaThings will change as we learn from real use.
- Context window
- 1M tokensInput per request.
- Max output
- 128k tokensPer response.
- Input
- Text and imagesPDFs, video and other file types are on the way, not in the beta yet.
- Output
- Text
- Languages
- EnglishOther languages have not been tested, so they are not listed as supported.
- Knowledge cutoff
- July 2026
- API formats
- Chat Completions, Responses API, Anthropic MessagesUse the SDK you already have.
- Weights
- ClosedAvailable through the API and our apps.
- Thinking levels
- Kael Beta: Low, High, Max. Kael Pro Beta: z-low, z-highEvery level thinks first. There is no Off setting and no Auto level.
- Rate limits
- 150 requests a minute, 30 at oncePer account, across both models. Hard requests can run for many minutes, so stream them.
- Speed
- Accuracy over speedExpect 270 to 340 tokens per second in every mode. Details in the Thinking section below.
Two Models. One API.
Kael comes as two models. Kael Beta is for most work: everyday reasoning, coding, debugging and review. Kael Pro Beta is the most thorough, for the hardest problems, and it costs more per token. Both are called the same way, with the same key, and take the same request formats. Only the model name changes.
The request and the response look like any other chat model’s: the same endpoints, the same message format, the same SDKs. Quancis does not publish how Kael is built, and Kael will not say.
Kael Beta
kael-beta
Most work: everyday reasoning, coding, debugging and review. The lower-priced model.
- Thinking levels
- low, high, max
- Default level
- low
- Input / cached / output
- $3.00 / $0.60 / $10.00
USD per 1M tokens.
Kael Pro Beta
kael-pro-beta
The hardest problems, where extra thoroughness is worth a higher price per token.
- Thinking levels
- z-low, z-high
- Default level
- z-low
- Input / cached / output
- $8.00 / $1.60 / $25.00
USD per 1M tokens.
Built for accuracy
Models keep getting smarter, but not more accurate. The gap between impressive and correct is where bugs, vulnerabilities and confident wrong answers live. Kael is built to close that gap, and to say plainly where it does not. The research behind the idea is in From Best-of-N to Mind Evolution.
Screened for misuse
Requests and answers can be screened against the acceptable-use terms. If something harmful is in either one, it can be stopped before it goes anywhere, and a flagged request can be held for review. What is kept, and for how long, is in Your data below.
Your system prompt stays yours
Write your system prompt the way you would for any other model. It defines the persona and the task: if it gives Kael a name, Kael uses it. Kael’s own rules rank above it, so a system prompt cannot make Kael claim to be a different AI product.
Where Kael Is Strongest.
Kael is built for people who want accuracy more than speed, and it shows most in technical work. These are the jobs it is tuned for.
- Coding
- Kael is built to write code with fewer bugs, and to catch the bugs that are already there. It takes longer than most models because it favours a correct answer over a fast one.
- Security
- It catches security vulnerabilities in existing code, and it aims not to introduce them in the first place. Both matter: a model that only finds problems after writing them has already cost you a review cycle.
- Software engineering
- Real engineering tasks, like the distributed-cache refactor in the example below, not just single functions. These are the jobs where a small wrong assumption early on spreads through everything built on top of it.
- Agentic work
- Long, multi-step tasks where the model acts on its own earlier output. Accuracy matters more here than anywhere, because one wrong step is carried into every step after it.
- Math
- Multi-step reasoning where the answer has to hold up, not just look plausible. Higher thinking levels give Kael more room to work a problem through before it answers.
Is Kael the right fit?
It is not built for everything, and we would rather say so plainly. Kael can write a story, but that is not what it is tuned for.
Reach for Kael when
- You care more about a correct answer than a fast one.
- The work is code review, debugging, refactoring or security review.
- An agent will act on the output, and a wrong step is expensive.
- You already call a chat API and want to change as little as possible.
- Your work is in English.
Look elsewhere when
- You need the fastest possible response. Kael thinks longer than most models, on purpose.
- The work is writing-first: fiction, marketing copy, anything where style is the point.
- You need to send PDFs, video or other file types today. The beta takes text and images.
- You need a language other than English. Other languages have not been tested.
- You need weights you can download or run yourself. Kael is closed.
Accuracy Takes Time. Here Is How Much.
Kael is slower than most models on purpose. Every request thinks before it answers: there is no setting that turns thinking off. You choose how much. Kael Beta has Low (the default), High and Max. Kael Pro Beta has z-low (the default) and z-high. A model accepts only its own levels. Pick a level to see what it costs and where it fits. There is no Auto level, where Kael decides for you.
At any level, Kael takes about 2.2 times as long to think as an average AI model. Once it starts writing, expect 270 to 340 tokens per second, in every mode. The longer story, with a chart, is in Why Kael Is Slower, On Purpose.
Low
Kael BetaDefaultThe default for Kael Beta, and its quickest level. Kael still thinks before it answers.
- Input
- $3.00per 1M tokens, or $0.60 when cached
- Output
- $10.00per 1M tokens
Good for: Everyday questions, quick edits and short answers.
Set it with reasoning_effort: "low", on Kael Beta only.
Every level thinks first
Thinking takes about 2.2× as long as an average AI model’s, at any level. There is no Off setting. Higher levels wait longer before the first word.
Then it writes fast
Once it starts writing, expect 270 to 340 tokens per second, in every mode.
Pay For What You Use.
Pricing is usage-based, per million tokens, and each model has its own price. Kael Beta costs the same at Low, High and Max. Kael Pro Beta costs more per token, at both of its levels. You are billed once, for your input and the final answer, nothing else.
| Model | Thinking levels | Input | Cached input | Output |
|---|---|---|---|---|
| Kael Betakael-beta | low (default), high, max | $3.00 | $0.60 | $10.00 |
| Kael Pro Betakael-pro-beta | z-low (default), z-high | $8.00 | $1.60 | $25.00 |
Prices are per 1M tokens. Cached input is billed at $0.60 on Kael Beta and $1.60 on Kael Pro Beta, which is 80% below the input price, and only for the part of a request that actually hits the cache. Every level of a model costs the same per token; a higher level thinks for longer, so a request takes more time and can use more tokens. You are billed once, for your input and the final answer, nothing else. See the console for the exact numbers.
Independent Results First.
We haven’t published benchmark numbers for Kael yet, and we aren’t publishing numbers we ran ourselves. Independent evaluation is being sought. When results exist, we plan to share them here.
Until then, the best test is your own. Because Kael is a base-URL change, you can point the SDK you already use at it and run your hardest prompts in a few minutes. Create a Kael API account, or try the demos Kael wrote from a single prompt.
What We Keep, And For How Long.
We don’t need your data. Kael isn’t trained on it, so there is nothing for us to gain from holding on to it. Here is exactly what we do keep.
- Normal requests
- Held for up to 15 minutes so cache hits can be calculated. After that, they are not stored in a database.
- Flagged requests
- If the safety system flags a request or a response as harmful, we keep it until our support team has reviewed it. We do this to improve the safety system, and to keep a record in case of a dispute, for example when an account has been blocked or suspended and the account holder contacts us.
- Training
- Your requests are not used to train Kael.
This is a plain-language summary. The Privacy Policy is the binding document.
Swap The Base URL.
No custom SDK and no migration. Kael accepts Chat Completions, the Responses API and the Anthropic Messages format, so the SDK you already have keeps working. For OpenAI-style requests, point it at our base URL, use the model name kael-beta, keep your existing auth pattern, and everything downstream stays the same.
https://api.quancis.space/v1import openai
# Kael speaks the OpenAI Chat Completions format, so the OpenAI SDK works.
client = openai.OpenAI(
api_key="sk-quan-...",
base_url="https://api.quancis.space/v1",
)
response = client.chat.completions.create(
model="kael-beta", # or "kael-pro-beta" for the hardest problems
messages=[
{"role": "system", "content": "You are a helpful coding assistant."},
{"role": "user", "content": "Refactor our distributed cache..."},
],
)
print(response.choices[0].message.content)This covers the shape of a request. Request and response schemas, streaming, error codes and every parameter live in the full docs, which this page isn't trying to replace.
See What Kael Writes.
Games and simulations that Kael wrote from a single prompt in a chat window, with no tools, each as a single HTML file. Try them in your browser. They show something Kael wrote, not how often it gets things right, so they sit apart from the benchmarks above.
- Simulation3DElectronicsKael Pro Beta
Fan Circuit
Two AA cells, a three-position switch and a small fan on a 3D circuit board, with the current, voltage and speed worked out from the real electrical equations. Written by Kael Pro Beta in one take.
Try it - Game3DSandboxProcedural
Blockscape
Explore an endless generated world of forests, deserts, mountains and oceans, then dig and build with ten block types. Sunrises, stars, rippling water and wandering animals, in one file.
Play it - Game3DAI opponents
Ouroboros
Steer a snake around a walled arena at sunset, eat glowing orbs and outlast the AI hunters. Three.js, procedural textures and synthesised sound, all in one file.
Play it - Game3DAI opponent
3D Chess
Play chess on a rendered black-and-white board against the built-in AI, or switch it off to play a friend. Click a piece to see every move it can make, and watch captured pieces float away to rest.
Play it
One System, Three Ways In.
The same Kael is behind all three. Pick the one that matches how you work.
- The API
- For developers and teams who already call a model from their own software. This is the page you are on.Developer platform →
- Quan Harness
- Our coding agent, built on Kael. It works inside a real project environment with a file system, live preview and git.About Harness →
- Quan Chat
- Kael in a conversation, with deep reasoning and web access you can switch on from the composer.About Chat →
Questions People Ask.
The things developers ask first, answered straight. If something here is missing, the docs go deeper.
Is Kael one model?
No. Kael comes as two models: Kael Beta (kael-beta) and Kael Pro Beta (kael-pro-beta). Kael Beta is for most work. Kael Pro Beta is the most thorough, for the hardest problems, and it costs more per token.
You call either one the same way, with the same key and the same request formats. Only the model name changes.
Will it work with the SDK I already use?
Yes. Kael accepts Chat Completions, the Responses API and the Anthropic Messages format, so existing SDKs and tools work without a custom client.
For OpenAI-style requests you change the base URL and the model name (kael-beta or kael-pro-beta) and keep the rest of your code.
Why is Kael slower than other models?
Kael favours correctness over speed, so it thinks before it writes. At any level, Kael takes about 2.2 times as long to think as an average AI model. Kael Pro Beta is slower again.
Once it starts writing, expect 270 to 340 tokens per second, in every mode. There is no setting that turns thinking off: every level thinks first. For the quickest replies, use Kael Beta at its default level, Low.
Which model and thinking level should I use?
Start with Kael Beta at Low, the default. Move up to High or Max when a task is hard enough that being right matters more than being quick, such as a security review or a large refactor.
Use Kael Pro Beta for the hardest problems, where its extra thoroughness is worth the higher price. Its levels are z-low (the default) and z-high. A model accepts only its own levels.
What are z-low and z-high?
They are the two thinking levels of Kael Pro Beta, and they are available now. z-low is the default and z-high is the most thorough level Kael offers. You set them with reasoning_effort, the same way you set Low, High and Max on Kael Beta.
Can Kael read images, PDFs and video?
Images, yes. Kael takes text and images as input and returns text.
PDFs, video and other file types are on the way, but they are not available in the beta.
Which languages does Kael support?
English. Other languages have not been tested yet, so we don’t list them as supported.
What is the context window?
1 million tokens of input and up to 128,000 tokens of output per request.
What are the rate limits?
150 requests per minute and 30 requests at once, per account, counted across both models together.
Hard requests can run for many minutes, so stream the response, or set your client’s timeout to 30 minutes or more.
What is Kael’s knowledge cutoff?
July 2026.
Does Kael train on my data?
No. We don’t use your requests to train Kael.
How long do you keep my requests?
Up to 15 minutes, so cache hits can be calculated. After that, requests are not stored in a database.
The exception is anything our safety system flags as harmful. Those are kept until our support team has reviewed them. The data section above and the Privacy Policy cover the details.
Can I download or self-host Kael?
No. Kael is closed: the weights are not released. It is available through the API and our apps.
Is Kael good at creative writing?
It can write stories and other creative text, but that is not what it is tuned for. Kael is strongest at coding, security, software engineering, agentic work and math.
If writing is your main use case, Kael is probably not the best fit today.
How is Kael priced?
Per million tokens, and each model has its own price. Kael Beta is $3.00 for input, $0.60 for cached input and $10.00 for output, at every level. Kael Pro Beta is $8.00 for input, $1.60 for cached input and $25.00 for output, at both levels.
The pricing section and the console have the exact numbers.
What am I billed for?
You are billed once, for your own input tokens and the final output tokens. Nothing else is added to your bill.
Where are the benchmarks?
We haven’t published any. We don’t want to grade ourselves, so we are seeking independent evaluation and plan to share the results here once there are any.
Can I set the temperature?
You can send it, so existing code does not break, but Kael does not use it. Sampling parameters are accepted and ignored, which means output is not deterministic and runs can vary.
Does Kael support streaming, tool calls and JSON mode?
Streaming and tool calls, yes, on all three request formats. Tool calling works with your own function tools; Kael has no built-in web search or code execution.
JSON mode, no. response_format is accepted but not enforced, so ask for JSON in your prompt and validate what comes back. tool_choice and max_tokens are accepted but not enforced either.
What is Kael built on?
Quancis does not publish how Kael is built or which components it uses, and Kael will not say. The weights are closed.
Start at the default thinking level and move up when a task needs it. Usage-based pricing, with the exact numbers on the console.