Constraint-driven operations for a Belgian manufacturing SME

Anonymization note: This case study has been anonymized at the client's request. The company operates in precision manufacturing in the Antwerp region. Industry sector, company size, and quantitative results are accurate.

Background

A 45-person precision manufacturing company in Belgium faced a recurring problem: compliance reporting. Every month, their operations manager spent roughly 20 hours compiling quality metrics, supplier certifications, and regulatory documentation for ISO 9001 and sector-specific audits. The process was manual, error-prone, and frequently delayed.

The company had tried two previous automation attempts. A custom Python script that broke every time the ERP vendor pushed an update. A no-code workflow that worked for three months until the original builder left and nobody could maintain it. Both failed for the same underlying reason: no explicit rules about what the automation was supposed to do, and no mechanism to detect when it stopped working correctly.

The constraint-driven approach

We proposed a different model. Instead of building automation and hoping it keeps working, we start by writing down the constraints: explicit, testable statements about what must be true. Then we build agents that operate under those constraints, and auditors that verify them.

For this client, the initial constraint set included 14 rules:

• Monthly quality report must be generated by the 5th of each month
• Report must include data from all active production lines
• Supplier certifications must be current (expiry date > today)
• Any data gap > 24 hours must be flagged, not silently ignored
• Report must be reviewed by a human before external submission

Each constraint has an ID, a verification method, and a consequence if violated. The auditor agent runs nightly and files violation tickets. The builder agent picks up tickets and fixes them. The human reviews the fix before it deploys.

Implementation

The technical stack was intentionally simple. A scheduled agent pulls data from the ERP API and a shared drive where supplier certificates live. It generates a draft report in a standard format. A second agent audits the output against the constraint set. Violations become tasks on a board that the operations manager reviews each morning.

Setup took six weeks. Two weeks to document the existing process and write the constraint set. Two weeks to build the data connectors and report generator. Two weeks to build the auditor and integrate with their existing task management.

Total cost was under 12,000 EUR, including documentation, training, and a three-month support period.

Results

After four months of operation:

• Monthly reporting time dropped from 20 hours to 8 hours (60% reduction)
• Zero missed deadlines (previously 2-3 per year)
• Three supplier certification gaps caught before audit (previously discovered during audits)
• The operations manager now spends review time on exceptions, not data gathering

The constraint-driven model also survived its first real test: an ERP update in month three broke the data connector. The auditor immediately flagged a data gap violation. The builder agent could not auto-fix this (it required a connector update), so it escalated. The operations manager saw the ticket, we patched the connector, and the monthly report still shipped on time. Under the old model, this would have been discovered the day before the deadline.

Lessons

Three things mattered most:

Writing constraints first forces clarity. The client thought they knew their reporting requirements. Writing them as testable constraints revealed six ambiguities that had caused problems for years.

Auditors are more valuable than builders. The auditor agent is the one that catches drift, detects when data sources change, and surfaces problems before they become compliance failures. The builder is important, but the auditor is essential.

Humans stay in the loop where it matters. The constraint requiring human review before external submission was non-negotiable. The automation handles the grunt work; the human handles accountability.