Made with AI. Directed by people.

Everything Blyzai produces is made with AI. The code, the models we adapt, the benchmarks, the documentation, this website. A person decides what gets built, directs the work, validates it on real hardware, and signs it. The AI does the rest — and it does most of it.

This is not a shortcut. It is the method. In our own projects, one or two people working this way deliver what we used to plan for a team of twenty to twenty-five. That is an estimate from our own experience of running technology teams for twenty-five years, not a benchmark — but it is why a lab this size can build products, adapt models and publish research at the same time.

Products. End-to-end: architecture, mobile, backend, on-device inference, real-time voice. LEXA, our Socratic tutor for secondary students, is the first; it runs offline on a €120 tablet. lexa.blyzai.com

Models. We do not train from scratch; we take open models and make them do one thing well where the cloud can't reach. That means fine-tuning for behaviour, preference alignment so it holds under pressure, distillation from large teachers into small students, and quantisation and cache optimisation so the result fits in the memory of a mid-range device. Our next model is a European open base tuned to refuse to give a student the answer.

Measurement. Every claim about performance we make, we have measured on the target hardware and published: the protocol as executed, the raw data, and what we did not measure. Benchmarks · DOI

Infrastructure and tooling. The pipelines, the evaluation benches, the deployment, this site — built and maintained by the same loop.

The loop has three roles, and one of them is human.

The director defines what gets built and why, sets the constraints, and validates every result on the target hardware. Nothing ships that the director has not seen run.

The architect — an AI — turns each decision into an atomic, verifiable task: one change, one check, a rollback point before touching anything, a validation step before committing. It reads first and reports before acting; it never assumes.

The builder — another AI, working in the codebase — executes those tasks and reports back with evidence: build output, test results, the exact command and its exact result.

And then an adversary reviews the work. A separate pass, with one instruction: break what was just built. Inject forbidden strings and see if the checks catch them. Disable JavaScript. Switch languages mid-page. Submit the form twenty times with garbage. Nothing closes while an adversarial pass still finds something that has to be fixed.

In every decision, and in every number.

The person chooses the problem, the product, the trade-offs and the stopping point. The person says no to a feature, not yet to a launch, and that figure is not measured, take it down. Every metric on this site has been measured by a person on a real device, has a source they can cite, or is labelled as an estimate. If none of the three is true, it is not here.

The AI writes. A person signs. That is the whole arrangement.

Local by default. What runs on the device is private by architecture, costs nothing per user, works without a connection and depends on nobody's pricing policy. The cloud is for what the device cannot do yet — and that frontier moves toward the device every year. We build on the side that advances.

Sovereignty is a technical property, not a slogan. An open model you can inspect, adapt and run yourself is one no provider can deprecate, reprice or retrain out from under you. We prefer open European models where they exist, and we say plainly where they fall short.

Privacy by architecture, not by policy. A promise in a document can be revised. A system that never sends the data cannot leak it.

Honest numbers. Measured, labelled, published with their limitations. A zero without a control proves nothing; we learned that the hard way and wrote it down.

Open where we can. Benchmarks, protocols, evaluation benches, and the rules of our own method.

The LEXA landing page was rebuilt in a day with that loop: seven adversarial reviews and sixteen findings, three of them blocking. One serious bug still reached production and lasted under an hour; the rule that would have caught it is now written down. This site went through the same loop the next day. Every finding, every rule learned from it and every decision is written down.

LEXA was built the same way, by one person: three tiers — on-device, cloud chat and real-time voice — on Android.

The rules of the method are public. Eleven of them, each with the mistake that produced it. Read them →

We do not publish figures we have not measured.

We do not let the AI decide what to build, or whether it is done.

We do not hide that we use AI. We think the opposite is coming: companies that hide it will have to explain why.

The same loop that builds software will direct machines. A model that runs on a device is a model that can run on a robot — with the same privacy by architecture, the same independence from the cloud, and the same person validating on real hardware. We are already working on edge hardware; embodied AI is the natural next step, and we intend to get there the same way: small models, local inference, measured on the real thing.

Speed without incoherence. One head, one set of decisions, executed at the throughput of a team.

Structurally low cost. The loop is the team. It is why our free tier can be free, and why we can run product, models and research at once.

Adapted models, not wrapped APIs. What we ship is a model tuned for a job and running where you need it — not a prompt in front of someone else's endpoint.

A method you can borrow. It is what we bring to the few companies we work with in applied AI. It is also why we call ourselves a lab, not a consultancy: the method is the product; the consulting is how we fund it.