What we claim, and what we don't

CX+AI is a programming language. Everything else on this site — the AI, the engine, the tools — hangs off that fact, so this page starts there, defines the words we use precisely, and says plainly what we do not claim. If you are evaluating CX+AI seriously, read this page first.

The language

CX+AI respects C — honours it, even — and puts development on steroids: AI, and designs proven over decades.

That sentence is the whole project, so here is each clause as a checkable claim:

It honours C. CX+AI is C expanded, not C replaced. C's semantics, C's number behavior, C's speed model — and all of C remains available, including a raw escape hatch into it, because taking power away from a C programmer is the one thing we refuse to do. If you know C, you already know most of CX+AI; what you learn on top is subtraction, not ceremony.
Less code, not more. The language's tone rule is written into its own development: the fewest lines that keep full clarity. Containers, strings, and over eight hundred built-in operations mean the loop you were about to write usually already exists as a word.
Two engines, one behavior. Every program compiles to native C and runs on a compact register VM, and the two are held to behave identically — that parity is enforced by the project's own test discipline, not promised.
The accelerants are not experiments. What makes development faster here is AI plus established designs — rapid development in the compiled tradition, the ergonomics that languages like Go and Rust re-proved for systems programmers — proven ideas assembled, not novelties risked on your project.

The AI — the other side of the language

CX+AI is built for two readers. What the language is to a person, it is to the AI: the same words, the same rules, and the same constraint — C itself. A person writing CX+AI is held by the compiler to C's semantics; an AI writing CX+AI is held to exactly the same discipline, on exactly the same surface. This is not an assistant bolted onto a language — it is one coin with two sides, and it is the design model, not a slogan: the manuals are compiled before publication because an AI will read them as ground truth, the error door reports in structured data because the reader may be a program or a model, and the builtin surface the AI writes against is the same one you do.

The model itself is local and small, with guardrails, as personal as possible — the outlook of the Kwaai community (kwaai.ai), of which we are members: personal AI, under personal control, on personal hardware.

Three words carry the AI claims, so here is what each one means — and doesn't:

Deterministic

We do not claim the model generates deterministically — language models sample; ask one twice and you may get two answers. The claim is different, and stronger: generation happens once, and what runs afterwards is not the model — it is code. The AI's output is compiled and installed as an ordinary program: fixed, inspectable, versioned, running at native speed with the model out of the loop. The determinism lives in the artifact, not the sampling. An AI answer must be trusted every time it is spoken; an AI artifact is inspected once and then owned.

Bounded

Code that arrives at runtime — AI-generated behavior, loaded modules — does not simply run: it must pass an admission gate first. The gate restricts it to a safe subset of the language; admitted code runs entirely on the register VM; and the loader that admitted it is not reachable from inside — a loaded module can never raise its own privileges. Code that violates the gate is refused at load, loudly, at its line — never silently weakened and run anyway.

One further bound is real today and worth naming: admitted code runs under a loop budget — a million iterations by default, per rule tick and per module call, charged on every backward branch. Exhaust it and the call dies with a named error instead of hanging. That count is complete rather than approximate, because the admitted subset bans recursion, so a backward branch is the only way to loop forever. The host can tighten the budget, or lift it for code it trusts; the admitted code cannot reach the dial.

What we do not yet claim: an instruction ceiling (the loop budget counts iterations, not work), per-behavior memory quotas, host-configurable narrowing of the admitted surface, or a published threat model. Those are roadmap, and until they ship this page keeps saying so. CX+AI today targets operational decision logic — rules, thresholds, game behavior, workflow steps. It is not certified for, and does not target, safety-instrumented or hard real-time control.

Observable

Four mechanisms, all in the current release: cx --decompile turns installed behavior back into readable source · onwatch() compiles a watch into the program, its condition checked at build time so a typo is an error, never a watch that silently never fires · onerror() hands failures to your handler as structured data, readable by programs (including an AI asked to fix its own code) as well as people · and the build log on this site publishes the project's own development feed continuously.

One clarification, since we celebrate decompiling: the licence forbids decompiling the compiler itself. Different objects. Your programs and the AI's generated behavior are yours to inspect without limit; the CX+AI implementation is the project's protected work.

The source, plainly

The source is not public during this phase. Releases ship as binaries with examples and checksums. Serious collaboration or source-licensing enquiries: hello@cxai.plus.

The licence, in plain words

The full text ships in every download and is reproduced on the licence page. The short version — and the licence text, not this summary, governs:

Free to download and use, including commercially. No fee, no seat limit.
Your right to each version you obtain is perpetual and irrevocable.
Programs you build are entirely yours. No CX+AI licence term attaches to your code, your executables, or your revenue.
The bundled examples are free to reuse without attribution.
You may not redistribute, reverse-engineer, or clone the CX+AI implementation itself.