Home AI Solutions Ready-made Solutions Peers & Simulation RAG & Retrieval Use Cases Frameworks Blog Deutsch Contact Us

Technical analyses

Evidence-led. Grounded in production. Explicit about limits.

Since 2023, we have analyzed what works reliably in AI systems — using numbers, sources, and clearly stated technical limits.

The Metric That Agreed With Us Too Often

For six weeks our faithfulness score climbed while support tickets climbed with it. Automated RAG evaluation was not broken; it was answering a narrower question than we thought we had asked. What reference-free metrics genuinely catch, the failure they are blind to by construction, and the cheap human check we now run underneath them.

Retrieve Only When It Helps

Retrieving on every turn made our assistant worse at the easy questions: three loosely related excerpts and a hedge where one sentence would do. Where we put the decision to retrieve, why we kept it in the pipeline rather than training it into the model, and the two signals that turned out to predict it well enough.

The Small Model That Stayed in Production

We put a 7B model in as a stopgap for one classification step and never replaced it. Not because small models caught up, but because we finally scoped the step so that its difficulty matched the model. What that scoping looks like, where we still reach for a large model without hesitating, and the measurement that settles the argument.

State Belongs in a Store, Not in the Context

Our assistant contradicted itself about a delivery date it had confirmed six minutes earlier. The instinct is to reach for a bigger window; what actually fixed it was writing decisions into a store the moment they are made, and reading them back as facts rather than as history. What we page in, what we never page in, and the failure that made the rule non-negotiable.

Prompts Are Code, So We Stopped Editing Them Like Prose

Our system prompt reached nine hundred words assembled by six people over four months, every line added for a reason and no reason written down. Nobody would delete anything because nobody could predict the cost. How we made prompts reviewable, what a test per instruction changed, and the two hundred words that turned out to do nothing.

What We Refuse to Automate

A customer asked us to automate a step their staff finish in forty seconds. We declined, because short does not mean simple: the task drew on context that exists nowhere in the systems an assistant can reach. The three tests we run before agreeing to automate anything, and why our refusal list has grown rather than shrunk.

The RAG We Actually Built, Against the One in the Diagrams

Reference pipelines show eight or nine stages. Ours has four, and two exist only because a specific failure forced them in. A survey published that December gave names to what we had assembled by accident, which made it possible to say what we had skipped on purpose. What each stage cost, what it caught, the one we added and removed again, and the two we still do not run.

Host It or Call It: The Question Behind the Model Choice

Every few months a customer asks whether they should run the model themselves, and almost never because of capability. Open weights reaching parity with hosted models changed a procurement question, not an engineering one. The four things we weigh, what self-hosting actually costs once someone has to be on call for it, and the two situations where we recommend it without hesitating.

Synthetic Data: Where We Use It and Where We Will Not

Four hundred model-generated test cases made our suite look thorough and measure almost nothing: they agreed with the system because they came from the same understanding of the task. Where model-generated data genuinely earns its place, the line we draw between generating an input and generating the expected answer, and what a verifier has to be for self-training to mean anything.

The Question No Single Chunk Can Answer

A three hundred page manual retrieved perfectly for every torque figure and failed on what the machine was for. The answer to a global question is not in any one passage, so no amount of better ranking finds it. What we added, what a summary layer costs to keep honest when the source changes, and why we only build one where the questions actually justify it.

Asking Twice and Voting: When Repetition Is Worth Paying For

A classification step disagreed with itself on six percent of inputs. Five runs and a majority vote removed it. The same trick on a summarisation step bought nothing at five times the cost. What separates the two is whether the outputs can be compared at all, and we have a two-line rule for it now. Also the harder case: a wrong answer that repeats is not a right one.

The Context Budget Is a Hard Limit, Not a Soft One

Nobody decided to send twenty thousand tokens of context. It accumulated in small defensible increments, and quality fell without any single change being the cause. Fitting inside the window is not the same as being usable, the material that hurt us was relevant rather than junk, and a budget only works if adding something means removing something.