From Test Methods to Executable LIMS Logic

Context

In pharmaceutical and quality control environments, analytical test methods define how products are measured, verified, and released. These methods contain detailed instructions covering calculations, thresholds, transformations, and decision criteria.

While LIMS platforms are designed to execute this logic, the methods themselves are often authored in documents — PDFs, validation reports, or method specifications. Translating these into executable LIMS code is a manual, specialist task.

This creates a familiar bottleneck. The logic exists, but it must be reinterpreted and reimplemented before it can be used operationally.

The Challenge

Unlike simple transcription, test methods contain mathematical and procedural logic that must be translated precisely.

Typical challenges included:

• Mathematical formulas expressed in natural language or notation

• Domain-specific calculations (e.g. dilutions, assay calculations, limits)

• Variability in how methods are written and structured

• Lack of direct correspondence between method text and LIMS Basic syntax

• High accuracy requirements in a regulated environment

The risk was not just inefficiency. It was correctness.
A small error in translation could lead to incorrect results, compliance issues, or failed validation.

The goal was therefore not automation alone, but trusted translation of analytical logic into executable code.

Our Approach

We designed an agentic generation and verification pipeline to convert test methods into LIMS Basic code.

The architecture followed a structured loop:

• Extraction
  Method content was parsed and structured into intermediate representations, capturing formulas, variables, and dependencies.

• Generation
  Large language models, supported by retrieval from LIMS documentation and code examples, generated candidate LIMS Basic code.

• Verification
  A symbolic validation layer compared the mathematical intent of the source method with the generated code, ensuring equivalence independent of syntax.

• Refinement Loop
  Where mismatches or gaps were identified, the system iteratively refined prompts and regenerated code until alignment was achieved.

This was not a single-step generation task. It was a closed-loop system designed to converge on correctness.

The Outcome

The system produced validated LIMS Basic code aligned with the original test method logic.

Key outcomes included:

• Significant reduction in manual coding effort

• Improved consistency across method implementations

• Early detection of ambiguities or inconsistencies in source methods

• A structured pathway from method definition to executable system logic

Most importantly, the introduction of a verification layer meant the output could be trusted, not just generated.

Why It Matters

This problem sits at the intersection of AI, mathematics, and regulated systems.

Many organisations assume that generating code from text is straightforward. In reality, when the code represents scientific or analytical truth, the challenge becomes fundamentally different. It is no longer about syntax. It is about preserving meaning.

By combining generation with verification, this approach moves beyond typical AI-assisted coding. It creates a pathway for translating complex, domain-specific logic into systems while maintaining confidence in correctness.

In regulated environments, that distinction is critical.