Interim update, written shortly after the first interim review.
An agentic system with BMW: the code calculates, the model explains
In the seminar Building Agentic Products we're working with BMW on a system that spots early warning signs of unplanned machine stops. An interim update, as abstract as confidentiality requires.
The most important rule in our design fits into one sentence: the code calculates every number, the language model calculates none.
Since September I’ve been in the seminar Trends and Concepts, this year’s topic: Building Agentic Products. Our industry partner is BMW. We’re six people from HPI, and the final presentation is at the end of January. The project is under NDA. So this post only covers which problem we’re tackling, how, and with what. No names of sites or machines, no numbers, no process flows.
The problem. In highly automated production, machines report errors and states all the time. A few of those announce an unplanned stop, and exactly those early signs are easy to miss. On top of that, delays without an actual stop often don’t create a message of their own. This is about messages, not sensor data. Continuous measurements are out of scope on purpose.
The approach has four parts. Detect: deterministic statistics on patterns in the messages. Prioritise: how hard would what’s building up hit production? Notify: tell the right role, clearly and in time. And learn: feedback flows back in. On top of that sits, by design, an agent with a language model that works only through tools. It may look things up, investigate, explain what it finds and route it to the right people. It can’t make up numbers because it doesn’t calculate any. And anything that would be written back to the ERP system is a draft that a human approves. The data stays local.
The demo on this page is a concept illustration with invented, generic data; none of it comes from the partner. It shows the flow in five steps: messages come in, the code detects a pattern, the agent investigates it through its tools, writes a draft, and a human approves it or doesn’t.
Live demo · sample data
Machine events
Click a station to trigger a fault burst there
Pipeline (deterministic)
-
Detectstatistics on event patterns
-
Prioritiseimpact on the flow
-
Notifytell the right role
-
Learnfeed decisions back
Agent · works only through tools
Every number is a reference to a tool result
Draft · maintenance notification
Draft · nothing written yet
Concept illustration for the ongoing seminar “Trends and Concepts: Building Agentic Products” with BMW as industry partner. It shows only the design rules of the team’s concept: code computes every number, the language model works through tools and explains, a human approves every write-back. Stations, fault codes and values are invented; no partner data, no process details, not the team’s UI.
My part. I took part in the on-site interviews with the partner. After that I built the reporting and early-warning pipeline, the part that recognises from the messages that something is building up and reports on it. We designed the system itself together as a team.
Why this split? Because a language model that does its own maths will hallucinate a number at some point, and in production a wrong number is worse than none. A model that only explains what deterministic code has found can be checked. At Kobe we handled it similarly: nothing gets sent before a human approves it.
What I’m taking away so far: on-site interviews belong at the start, not at the end. And an agent doesn’t become useful by being allowed a lot, but by it being clear what it’s not allowed to do.
Tools and skills: Python, pandas, DuckDB and Parquet for the data, pytest, a planned agent with tools, user interviews with the industry partner, human-in-the-loop design, and working under NDA.
The final presentation is in January. There’ll be more here then, as far as I’m allowed to show it.