The hardest thing about selling smart factory solutions is that you can't see them until they're built.
Slides don't show you what connected machine data actually feels like. A proof of concept takes weeks and budget approval. And by the time you've evaluated three vendors, you've lost half a year.
We've sat across the table from enough plant managers to know the look: polite interest, genuine skepticism, and the unspoken question of "but what does this actually look like in practice?"
So we built something to close that gap.
The problem with demos
Every Industry 4.0 vendor has a demo. Most of them are dashboards backed by random data generators, maybe a video of a factory floor, sometimes a sandbox environment that takes 20 minutes to set up. They show features, not outcomes.
The result is a disconnect between what's promised and what's understood. A production manager watches a canned demo and thinks: "Looks nice, but what would this do for my factory?" A maintenance lead sees a dashboard and asks: "Where's the machine context? Where's the failure history?" An inside sales rep wonders: "Can I actually tell a customer where their order stands?"
These aren't unreasonable reactions. They're the natural result of demos that show technology instead of showing value.
What we actually built
Alpamayo Chocolate Live is a virtual chocolate factory with 78 simulated machines across seven production areas — from raw material storage through bean processing, grinding, conching, molding, quality control, packaging, and utilities.
Every machine streams real sensor data. Production orders flow from ERP through the shopfloor. Quality checks happen. Bottlenecks form and resolve. Shipment deadlines approach.
The entire data pipeline is real: 78 machine simulators expose data over OPC-UA, S7, and Modbus. PREKIT edge connectors ingest and contextualize the signals. An MQTT-based Unified Namespace keeps everything connected. The website consumes this data live over WebSockets.
There's no canned data, no recorded playback. What you see is what's happening right now.
Why chocolate?
Partially because chocolate production has a satisfying end-to-end story — from cocoa beans to wrapped bars. Partially because "visit our virtual steel mill" is a harder sell at a trade show.
But mostly because the fictional Alpamayo Chocolate company gave us something we couldn't create with a generic demo: a context. A CEO named Coco Nibbs with a real (fictional) problem. A partnership story. An ERP that has actual customer orders. Inside sales reps who need to know where a shipment stands.
Context is what makes data meaningful. A temperature reading from "Machine 7" tells you nothing. A temperature reading from Drum Roaster 03, currently processing order MO-2036-0041 for Alpachocolate Single Origin 85%, tells you everything.
Five roles, one factory
The demo doesn't just show data. It shows the same data through five different lenses:
- Production Manager — throughput bottlenecks, schedule risk, order exposure, work-centre drilldowns
- Maintenance Lead — fault patterns, downtime impact, condition trends, predictive-maintenance view
- Process Engineer — yield loss, recipe sensitivity, quality drift, OEE component drilldowns
- Inside Sales — order traceability, shipment confidence, customer communication
- Smart Factory Architect — API contracts, MQTT topics, MCP interfaces, governance
Each role sees the factory differently. But they all draw from the same connected data backbone. That's the point — connected manufacturing isn't about one dashboard. It's about making the right information available to the right person at the right moment.
Ask the factory
The other lens is conversational. There's a chat assistant embedded on the home page and on every role page, with its own workspace at /chat. You can ask it the kind of questions an operator actually asks: "Why did throughput drop in Bean Processing this morning?", "Which machines are trending toward failure?", "Where is order MO-2036-0041 right now?"
It answers from live state, not training data. Under the hood it's a bounded two-stage loop: a planner model decides which read-only factory commands to run, then a synthesizer turns the evidence into the answer. Every tool call is shown inline, so you can see exactly what data the agent looked at.
Both models run locally on a Mac Studio in our office via Ollama — no cloud dependency, no production data leaving the premises. That's the same architecture we'd hand a customer who needs an AI copilot but can't ship sensor data to a public LLM provider.
What this proves
The chocolate factory demonstrates several things that are hard to prove on slides:
Data continuity is real, not theoretical. You can follow a production order from ERP release through every work center to dispatch. The data doesn't break at system boundaries.
Role-based value is visible. The same underlying data creates different operational value for different people. A maintenance lead and an inside sales rep look at the same factory and see completely different priorities — both valid, both grounded in the same truth.
Open architecture is inspectable, not just diagrammed. The same Grafana dashboards a plant operator would use, the same PREKIT Hub a deployment engineer would log into, the same ERP that holds the production orders — they're all running alongside the factory and reachable from the /applications hub. The API contracts and MCP interfaces sit on top of that. You can poke at the actual stack instead of trusting an architecture slide.
Agentic AI that actually works. Ask the factory a question in natural language and you get a grounded answer — the agent runs real read-only commands, reads live MQTT state, and shows its tool calls inline. It works because the open contracts underneath were built for it, not bolted on. And because the same tools are published as an MCP manifest, external agents (Claude Desktop, your own copilot) can plug in the same way.
A foundation for partners
Here's where the vision goes beyond a sales tool.
We built Alpamayo Chocolate as an open foundation. PREKIT provides the integration backbone — the Unified Namespace, the edge connectors, the API surface, the governance model. But a smart factory isn't built by one vendor.
Condition monitoring, predictive maintenance, quality analytics, energy optimization, production scheduling — these are solutions that different companies do well. What they all need is a connected, contextualized data foundation to work with.
Alpamayo Chocolate is that foundation. We're inviting partners to integrate their solutions into this factory and show what they actually do — not on slides, not in sandboxes, but on live production data with real context.
If you build a predictive maintenance solution, show it predicting failures on 78 machines that are streaming real sensor data. If you build a quality analytics platform, show it catching yield loss on actual chocolate production runs. If you build an agentic AI copilot, show it answering questions about a factory that's actually running.
The data is there. The architecture is open. The factory is live.
Try it yourself
The factory is public — no login, no setup, no sales call required. Visit alpamayo-chocolate.com, pick a role, and explore.
If you want to go further: claim a chocolate. The "Steal a Chocolate" flow lets you place a real sample order, attach it to a live production run, and track it through the factory. We ship to Switzerland, Germany, and Austria.
And if you're building Industry 4.0 or industrial AI solutions and want to showcase them on a live factory — get in touch. The foundation is built. Let's fill it with solutions that matter.
The Alpamayo Chocolate factory is live at alpamayo-chocolate.com. The PREKIT platform that powers it is documented at alpamayo-solutions.com/prekit. For partnership inquiries, contact us.