Executive summary

Analytics and AI have moved from experimentation to expectation in asset-heavy industries. For operators of plants, fleets, and critical infrastructure, even small improvements in yield, uptime, or energy efficiency translate into material and recurring P&L impact. Yet the real promise of Industrial AI is not abstract insight - it is better decisions made consistently in the flow of operations.

At its best, Industrial AI turns operational variability into economic advantage. It aligns production with volatile energy markets. It reduces waste in complex changeover processes. It shifts maintenance from reactive firefighting to proactive reliability. It connects siloed operational and commercial data to explain performance deviations in real time. In each case, value is created not by a model alone, but by improving a specific, high-stakes decision.

Arundo’s experience across chemicals, oil & gas, maritime, and renewables demonstrates that these gains are both achievable and repeatable. In energy-intensive chlor-vinyl production, optimization of modulation schedules against electricity price forecasts has delivered 3 - 5% energy cost savings, turning market volatility into structural OPEX advantage. In lubricant manufacturing, physics-based flush optimization has reduced product waste by 15 - 25%, eliminating millions in annual losses without increasing operational burden. In steam cracking, on-line furnace optimization has increased ethylene yield by 2 - 3%, materially improving profitability in highly competitive markets. Predictive maintenance solutions have avoided up to 75% of associated downtime events and extended asset life, shifting organizations from reactive repair to managed reliability. 

These examples share a common pattern. The problems are operational, not theoretical. The data is messy, distributed across historians, MES, CMMS, lab systems, and commercial platforms. The constraints are physical, financial, and regulatory. And the consequences are real: missed production, wasted feedstock, unplanned downtime, warranty exposure, or compliance penalties.

Industrial AI creates value when it helps answer concrete questions such as:

• What is the economically optimal production plan given today’s energy prices and plant constraints?
• Which compressors are operating outside normal envelopes - and which protocol should we follow now?
• How much should we flush between product change-overs to meet quality specifications without unnecessary waste?
• Why did this voyage underperform its benchmark - and what is the commercial exposure?

In each case, the outcome is not a dashboard. It is a changed action: a new powerload schedule, a modified process setpoint, a work order, or a documented commercial claim.

The opportunity for industrial organizations is therefore both significant and disciplined. Small percentage improvements compound across large energy bills, material flows, and asset bases. But realizing that value requires more than experimentation. It requires treating analytics and AI as operational capabilities - designed for reliability, embedded in workflows, governed like equipment, and improved over time.

The organizations that consistently translate AI investment into sustained P&L impact do not succeed because of superior algorithms. They win because they are disciplined about decisions, ownership, consequences, context, workflow, and lifecycle management. In other words, they run Industrial AI like they run their plants and fleets.

This is fundamentally different from digitizing horizontal processes such as HR, Finance, Sales, Marketing, or Legal. In those domains, the primary levers are labor productivity, cycle time, and information flow. In core operational processes, the stakes and constraints are different. The consequences include safety, uptime, environmental exposure, and regulatory compliance. The constraints are physical - governed by chemistry, thermodynamics, mechanics, topology, and asset configuration. And the business logic is not just productivity; it is material yield, energy cost, supply chain coupling, working capital, capital intensity, and reliability under load.

Industrial AI lives where physics, economics, and accountability intersect. That intersection demands a different level of discipline.

This playbook distills that discipline into ten practical claims. Each claim reflects a pattern observed in real deployments - what holds up under industrial constraints, what scales, and what quietly fails. They are design targets for anyone who wants AI to move from pilot to operational capability.

The through-line is simple: start with decisions, respect industrial consequences, design for adoption, and treat AI as a long-lived asset.

What follows is a set of claims intended to be read quickly, debated openly, and tested against your own operations.

1. Assign operational ownership, or don’t build it
   Test: If the recommendation is wrong, who is accountable - and do they have the authority to change the process, thresholds, and rollout?
2. Design for consequences, not accuracy
   Test: Can the solution fail gracefully (safe, bounded, reversible) without creating safety, compliance, or uptime risk?
3. Make data meaningful: Context, physics, topology
   Test: Can you state - explicitly - what asset, configuration, and operating mode the model assumes, and what “good” means in physical terms?
4. Close the loop: decisions into workflows
   Test: Does the output land where work happens (planning, control room, CMMS, ticketing), and does it trigger a clear next action that gets recorded?
5. Make “why” a first-class output
   Test: Can a user answer “Why this?” and “What would change it?” from the system itself - fast enough to matter on shift?
6. Operate AI like equipment
   Test: Is there an agreed service model (SLAs, monitoring, incident response, change control, rollback) with a named owner who holds the provider accountable over time?
7. Prove locally, platform what repeats
   Test: Are you funding and measuring local decision products to prove utility first - and then centralizing what proved reusable, not what was assumed reusable?
8. Scale with data contracts
   Test: Do you let the decision/problem define the required data shape (fields, semantics, context, latency, quality, availability), and is that shape captured as a versioned contract with the source-system owner?
9. Keep humans accountable; keep systems bounded
   Test: Is it explicit what the system may do automatically vs. what requires human approval - and are overrides, rationales, and outcomes logged?
10. Scale as a portfolio of decision products
    Test: Can you list your decision products with an owner, adoption metric, and ROI logic - and do you have a mechanism to fund, improve, or retire them?

Each of the ten claims is illustrated through a single case example - an energy optimization deployment in a chlor-vinyl value chain - to show how the principles hold up in real operations.

1. Assign operational ownership, or don’t build it

Industrial AI scales fastest when the organization is crisp about three things:

• Which decision is being improved
• What “good enough” means in practice
• Who owns the outcome (including how the organization will respond when reality diverges from the recommendation)

When these are explicit, AI stops being “a model” and becomes a capability that improves work in a repeatable way.

What this looks like in practice

• One decision, one user group, one context - delivering measurable improvement
• A named owner who can prioritize, approve changes, and drive adoption
• A clear definition of “good enough” tied to operational outcomes (time, cost, yield, reliability, risk)

Recipe

1. Name the decision in one sentence (verb + object + context).
2. Define success in operational metrics (what improves, by how much, and how often).
3. Define “good enough” as an action threshold (when the tool should trigger action).
4. Assign an accountable owner for the outcome (not just the platform).
5. Build for real-world iteration: capture feedback, exceptions, overrides, and outcomes.

Example (Energy Optimization)

Technically, we did not “optimize energy.” We improved one decision: the weekly production modulation schedule under electricity price volatility. The production planner owned the outcome, defined “good enough” as a minimum percentage monetary improvement threshold, and had authority to change the schedule. Without that ownership, it would have remained a model.

2. Design for consequences, not accuracy

Industrial environments reward systems that are reliable, available, and change-controlled - because the consequences of operational decisions are real: uptime, safety, environmental exposure, compliance, and trust.

This creates a distinct design center for Industrial AI:
availability, reliability, controlled change, and accountable decision-making.

What this looks like in practice

• The system behaves predictably within clearly defined boundaries
• Operational teams stay in control and understand the trade-offs
• Change is managed like any other operational change (tested, staged, reversible)

Recipe

1. Design for reliability first (monitoring, alerting, rollback, clear operating envelopes).
2. Use hybrid systems by default:
   
   • deterministic logic where bounded behavior matters
   • statistical models where complexity overwhelms rules
   • humans in the loop where accountability is non-transferable
3. Operationalize decision flow:
   
   • AI recommends
   • humans decide
   • deterministic systems execute
   • analytics verify outcomes
4. Treat site context as a feature, not a nuisance: encode constraints explicitly.

Example (Energy Optimization)

The system was designed around real constraints: production targets, rectifier limits, downstream dependencies, electricity contracts, and grid nominations. We prioritized feasibility, stability, and controlled change over marginal cost improvements that operators could not execute safely.

3. Make data meaningful: Context, physics, topology

In industrial operations, “more data” is rarely the unlock. The unlock is meaning.

A sensor value becomes actionable when it is connected to:

• asset identity and configuration
• operating mode and topology
• maintenance state and constraints
• outcomes and operational definitions of “good”

Industrial AI is strongest when it respects process physics and operational envelopes - and when those assumptions are legible to the people who must act.

What this looks like in practice

• Data that is connected to assets, modes, and outcomes
• Models whose assumptions match physical reality and operating constraints
• Outputs that operators can relate to what they see in the plant/fleet

Recipe

1. Start with semantics: define what each signal means, where it comes from, and when it is valid.
2. Model operating modes explicitly (startup/shutdown/steady-state, product grades, seasons, duty cycles).
3. Use physics-informed structure where it improves stability and trust.
4. Modernize proven domain models into decision services (live data + deployment + workflow).

Example (Energy Optimization)

Electricity prices alone aren’t very helpful. Value came from encoding site-specific topology: electrolyzer configuration, load-shifting limits, buffer capacity, maintenance calendars, and contract structures. The optimization respected process physics and operational envelopes rather than treating sites as interchangeable assets.

4. Close the loop: decisions into workflows

Industrial AI creates value when it closes an action loop.

The goal isn’t a model output. The goal is:
who sees what, when, in what format, with what authority, and what happens next.

When outputs are delivered in the cadence of work, adoption accelerates and impact becomes repeatable.

What this looks like in practice

• AI output arrives exactly where decisions are made
• The recommendation is easy to act on (or override)
• Actions and outcomes are captured so the system improves over time

Recipe

1. Map the current workflow and identify the decision bottleneck.
2. Design the action loop: trigger → recommendation → decision → execution → verification.
3. Engineer signal quality like alarm management: fewer, higher-quality interventions.
4. Fit the operating rhythm (daily, weekly, shift-based, voyage-based, etc.).
5. Instrument adoption: track usage, overrides, time-to-action, and impact.

Example (Energy Optimization)

The output was not just a dashboard. It was an executable weekly production schedule with daily re-optimization. Recommendations landed directly in the planning cadence already used by each site, aligning with existing shift and nomination processes.

5. Make “why” a first-class output

In industrial settings, trust is often about control, clarity, and accountability.

Adoption grows when the system:

• makes assumptions visible
• communicates constraints and trade-offs
• supports human judgment rather than bypassing it
• provides a defensible basis for action

Explainability isn’t “nice to have.” It is a core product feature.

What this looks like in practice

• Users can answer: “Why this recommendation?” and “What would change it?”
• The system supports investigation, not just scoring
• Decisions become faster, more consistent, and more defensible

Recipe

1. Explain in operational terms: constraints, trade-offs, boundaries, comparable historical situations.
2. Show the evidence trail (key drivers, relevant data slices, comparable runs).
3. Design for confidence calibration: when to act, when to escalate, when to wait.
4. Make accountability explicit: who decides, how overrides work, what gets logged.

Example (Energy Optimization)

Each recommendation exposed the trade-off: forecast price curve, constraint drivers, modulation limits, and cost impact. Planners could see what bound the solution and what would change it, enabling confident execution and defensible commercial decisions.

6. Operate AI like equipment

Industrial AI performs best when it is managed as a long-lived asset: governed, secured, monitored, improved, and eventually retired.

This becomes much easier when you separate three motions clearly:

1. Analytics development (discover/validate)
2. Industrialization & deployment (harden/integrate)
3. Operational analytics (run/monitor/improve)

What this looks like in practice

• Prototype speed and production reliability
• Clear handoffs between build, deploy, and run
• Monitoring, versioning, rollback, and auditability as standard practice

Recipe

1. Define lifecycle stages and stage-gates (what “ready” means at each step).
2. Standardize operational controls: monitoring, drift checks, incident response, rollback.
3. Govern the whole solution (rules, optimization, ML, agents - not just training pipelines).
4. Run continuous improvement driven by operational feedback and measured outcomes.

Example (Energy Optimization)

The optimizer was operated as an asset, not a project. The customer assigned a business owner accountable for realized savings and held Arundo - acting as the “OEM” - responsible for lifecycle performance under a service agreement. Performance was monitored, constraints evolved under change control, and improvements were versioned and deployed with the same discipline as production systems.

7. Prove locally, platform what repeats

In industrial environments, the most effective architecture emerges from proven decision impact.

A practical sequencing is:

1. Solve a real operational decision close to where work is done
2. Extract patterns that survive reality (data contracts, monitoring, security controls, deployment paths)
3. Centralize what truly repeats

This preserves speed to value while building a foundation that scales.

What this looks like in practice

• Early value delivered in the field
• Reuse of proven patterns across sites/assets
• Centralization that reduces friction rather than creating it

Recipe

1. Start with one high-impact decision and deliver an operational solution.
2. Document reusable patterns: interfaces, contracts, access controls, observability, deployment paths.
3. Centralize early the enablers that help everyone:
   
   • identity & access
   • logging & audit
   • security standards
   • data contracts
4. Centralize later what is inherently contextual:
   
   • business logic
   • models
   • context
   • data
5. Treat architecture as a product of learning, not a prerequisite for learning.

Differently put: centralize what repeats - when it repeats.

Example (Energy Optimization)

We started with one site and one decision. After proving economic impact, we standardized reusable elements - data interfaces, constraint templates, monitoring patterns - while preserving site-level logic and configuration. Architecture followed proven impact.

8. Scale with data contracts

Most asset-heavy organizations already make data-driven decisions - through fragmented, manual stitching across systems and tools.

A scalable alternative is to make the “source of truth” a logical framework rather than a single physical environment:

• domain-oriented ownership
• data as a product
• a self-serve catalog
• automated policy enforcement

In practice, data contracts function like APIs for data: they stabilize the interface between producers and consumers so analytics and AI can scale without constant rework.

What this looks like in practice

• Clear producer/consumer agreements (schema, SLAs, quality criteria, semantics)
• A discoverable catalog that makes onboarding fast
• Governance that is enforceable and auditable by default

Recipe

1. Define data products aligned to decisions (not “all data”).
2. Create contracts: schema, refresh rate, uptime target, quality checks, semantics.
3. Publish in a self-serve catalog with owners and examples.
4. Enforce policies as code (access, retention, sensitivity, freshness).
5. Iterate domain by domain and grow coverage through repetition.

This approach is compatible with data mesh principles and supports scale without turning every new use case into a bespoke integration.

Example (Energy Optimization)

Inputs were stabilized through clear contracts: electricity price forecasts, stock levels, demand projections, constraint parameters. By defining schemas, SLAs, and ownership per data product, onboarding new sites became configuration - not reintegration.

9. Keep humans accountable; keep systems bounded

Industrial AI is most powerful as hybrid intelligence:

• deterministic logic provides guardrails and auditability
• statistical models provide adaptability and pattern recognition
• humans provide accountability and judgment

The goal is repeatable operational improvement under constraints - not autonomy for its own sake.

What this looks like in practice

• The right tool for the decision: rules, optimization, ML, agents, or a combination
• Clear division of responsibility: recommend → decide → execute → verify
• Governance that covers the full hybrid stack

Recipe

1. Choose the method based on the decision (constraints, variability, accountability).
2. Combine guardrails with learning (bounded behavior + adaptive insight).
3. Keep humans in the loop where responsibility and safety demand it.
4. Govern the whole system, not just the ML component.

Examples include constrained optimization embedded in planning cadence, and agentic investigation workflows that unify operational and commercial context.

Example (Energy Optimization)

A constrained mathematical optimizer generated schedules within hard operational limits. Humans retained final authority to approve or override. Deterministic rules enforced feasibility; adaptive forecasting informed cost signals. The system recommended - planners decided.

10. Scale as a portfolio of decision products

Scaling Industrial AI is a capital allocation and operating model discipline.

Organizations that scale well:

• choose a small set of decisions that matter
• fund them like products
• assign accountable ownership
• measure outcomes
• continuously improve what delivers
• gracefully retire what no longer earns operational attention

What this looks like in practice

• A portfolio of decision improvements with clear ROI logic
• Repeatable rollout patterns with controlled variation
• Lifecycle operations as a standard capability, not a heroic effort

Recipe

1. Build a portfolio using three filters: value, readiness, ownership.
2. Prove decision impact in one context.
3. Harden what survived reality (contracts, monitoring, integration, governance).
4. Replicate across assets/sites with deliberate variation (not reinvention).
5. Operate and improve continuously with clear metrics and ownership.

Think: Pilot → Product → Portfolio

Example (Energy Optimization)

The optimizer became a funded decision product with measurable OPEX impact per site. After proving value in load modulation, adjacent decisions (grid nominations, buffer management, cross-site coordination) were evaluated as extensions - expanding a portfolio, not launching new experiments.

In conclusion: Run it like an asset

Industrial AI isn’t a breakthrough. It’s a discipline.

These ten claims aren’t meant to win an argument - they’re meant to hold up in operations. If you want to apply the playbook immediately, here’s the simplest starting move:

Pick one decision. Build the simplest analytics/AI that measurably improves it. Embed it in the workflow. Assign an owner. Run it like an asset.

If you want a practical diagnostic lens for your environment, start here:

• What decision are you improving?
• Who owns the outcome?
• Where does the recommendation land in the workflow?
• What context (asset/mode/topology/outcome) makes the output actionable?
• What would it take for the people on shift to say: “This helps.”

‍

Martin Lundqvist (LinkedIn)

‍