AI Agents and Agentic AI – Navigating a Plethora of Concepts for Future Manufacturing

TL;DR

Everyone in manufacturing is suddenly talking about “AI agents” and “Agentic AI” as if they’re the same thing. They’re not, and the difference matters for what you can actually promise to ship. This paper is a survey/position piece that traces the lineage from classic rule-based expert systems through machine learning, through Transformer-based LLMs and their multimodal cousins (MLLMs), to LLM-Agents, MLLM-Agents, and finally Agentic AI — a spectrum of increasing autonomy, not a hard category. It then walks four concrete capability tiers GenAI-enabled agents unlock in a factory (semantic knowledge retrieval, multimodal perception and diagnosis, adaptive optimization, and — at the top — fully autonomous goal-setting) and closes with the un-glamorous but real blockers: messy industrial documents, multimodal alignment, black-box interpretability, workforce resistance, and unclear ROI. There’s no benchmark, no new algorithm, and no code — the value is a shared vocabulary and a maturity ladder you can use to scope your own project honestly instead of over-promising “agentic AI” when what you can actually ship this quarter is a RAG chatbot over your own maintenance logs.

Problem & Motivation

Manufacturing has a real, specific need: production lines generate constant streams of heterogeneous data (ERP/MES/SCADA logs, sensor readings, machine vision, PDFs of maintenance manuals) and need systems that can perceive, reason, and act on that mess in real time. Fixed-rule automation and classic ML choke on this — they need predefined features and struggle the moment a scenario falls outside their training distribution.

GenAI changed what looked possible almost overnight, but it also flooded the discourse with terms that get used interchangeably when they shouldn’t be: “AI agent,” “LLM-based agent,” “multimodal agent,” “Agentic AI.” The authors’ actual complaint isn’t technical — it’s definitional. If a vendor says they’ll deploy “an agentic AI system” for your shop floor, do they mean a chatbot with tool access, or a system that can autonomously redefine your production priorities without you in the loop? Those are wildly different projects with wildly different risk profiles, and right now the industry doesn’t have a shared way to tell them apart. That ambiguity is the pain this paper sets out to remove.

What’s New (Core Contribution)

This is a survey/taxonomy paper, so the contribution is a map, not a mechanism. Four things it actually delivers:

• A single evolutionary lineage, not four disconnected trends. Before: rule-based expert systems, classic ML/RL agents, LLMs, and MLLMs were discussed as separate research threads. Now: the paper threads them into one line — symbolic/expert systems → connectionist ML/RL agents (AlphaGo-era) → LLM-Agents → MLLM-Agents → Agentic AI — where each stage inherits the last stage’s gaps and closes one of them.
• “Agenticness” as a spectrum, not a checkbox, imported from OpenAI’s governance framing and Gartner’s 2025 trend report and applied specifically to manufacturing. Instead of asking “is this agentic AI, yes or no,” you score a system on four dimensions (goal complexity, environmental complexity, adaptability, independent execution) and the answer is “how agentic,” not “is it.”
• Four-component reference architectures for LLM-Agents and MLLM-Agents, laid side by side so the delta between them is visible: LLM-Agents reason over text through Profiling → Memory → Planning → Action; MLLM-Agents swap the front end for a Multimodal Perception → Fusion & Reasoning → Decision & Planning → Action & Execution pipeline that can ingest vision, sensor, and structured data alongside text.
• A four-tier manufacturing capability ladder (semantic retrieval → multimodal perception → adaptive optimization → autonomous goal-setting) that gives every one of the abstract agent types above a concrete “what does this let a factory actually do” answer, each backed by a named real-world system (a fab-floor virtual assistant, a CNC chat interface, a ceramic-tile defect diagnoser).

Be honest about what’s not new: none of the underlying technology (Transformers, RAG, knowledge graphs, MAS, RL) is introduced here — it’s all cited from elsewhere. The genuine contribution is the organizing scheme and its explicit anchoring to manufacturing decision-making, which is scattered and implicit in the source papers this one surveys.

How It Works (Technically)

There’s no single mechanism to trace end-to-end here — it’s a taxonomy paper, so “how it works” means “how the concepts nest inside each other.” Three structures carry the whole paper.

1. The evolutionary path (five stages).

flowchart LR
  S1["Stage 1<br/>Rule-based expert systems<br/>(if-then chains, no learning)"] --> S2
  S2["Stage 2<br/>ML / RL decision-making<br/>(learns from data, e.g. AlphaGo)"] --> S3
  S3["Stage 3<br/>LLM-Agents<br/>(language reasoning + tools)"] --> S4
  S4["Stage 4<br/>MLLM-Agents<br/>(+ vision, sensor, structured data)"] --> S5
  S5["Stage 5<br/>Agentic AI<br/>(self-directed goals, minimal oversight)"]

Each arrow is a specific capability gap getting filled. Stage 1→2: hand-written rules can’t learn, so statistical learning takes over. Stage 2→3: classic ML/RL models are narrow and can’t hold a conversation or reason over instructions, so LLMs bring language understanding and zero/few-shot generalization. Stage 3→4: text-only agents are blind to the factory floor’s actual sensory reality, so MLLMs bolt on vision, audio, and structured-data understanding. Stage 4→5: even a multimodal agent is still task-bound — it optimizes a goal you handed it — so Agentic AI is the step where the system starts setting and revising its own sub-goals.

2. Two architectures, laid side by side. This is the part worth internalizing if you build agent systems for a living, because it’s exactly the difference between “an LLM with tools” and “a perception-grounded agent.”

flowchart TD
  subgraph LA["LLM-Agent (text-only)"]
    direction LR
    P1["Profiling<br/>identity, role, constraints"] --> M1["Memory<br/>past interactions, context"]
    M1 --> PL1["Planning<br/>decompose task into steps"]
    PL1 --> A1["Action<br/>tool calls / knowledge synthesis"]
    A1 -.feedback.-> M1
  end
  subgraph MA["MLLM-Agent (multimodal)"]
    direction LR
    P2["Multimodal Perception<br/>text + image + sensor + structured"] --> F2["Fusion & Reasoning<br/>build one environment model"]
    F2 --> D2["Decision & Planning<br/>formulate strategy"]
    D2 --> A2["Action & Execution<br/>act across data formats"]
    A2 -.feedback.-> P2
  end

Read the LLM-Agent row like this: Profiling is the system prompt that pins down who the agent is and what it’s allowed to do — this is what stops a maintenance-log assistant from also trying to reschedule production. Memory is exactly what you’d expect from building a multi-agent system yourself: a store of past turns/retrieved context that keeps the agent from re-asking questions or contradicting itself. Planning is task decomposition — break “diagnose this fault” into “pull sensor history → check manual → cross-reference known failure modes.” Action is where tool calls or RAG retrieval actually touch the world.

The MLLM-Agent row does the same job but the front door is wider: Multimodal Perception ingests a thermal scan and an ERP record and a maintenance-log paragraph in one pass instead of forcing everything through a text bottleneck. Fusion & Reasoning is the genuinely hard new step — it has to reconcile a vibration spike, a temperature trend, and free-text technician notes into one coherent read of “what’s actually wrong,” which is a much harder alignment problem than text-only retrieval. The rest (Decision & Planning, Action & Execution) mirrors the LLM-Agent’s Planning/Action, just now conditioned on a richer world-model.

The four "agenticness" dimensions (Goal Complexity, Environmental Complexity, Adaptability, Independent Execution) plotted for four system types. Toggle a system to see how the shape grows as you move from rule-based automation to Agentic AI — it's a spectrum, not a step function. (Built from the paper's definitions, not measured data — illustrative.)

3. Demystifying “agenticness.” The paper borrows this term from OpenAI’s governance paper rather than defining a new metric, but it’s worth translating because it’s the closest thing to a formal idea here. A system’s agenticness is scored (informally) across:

• Goal complexity — can it handle one narrow task, or a portfolio of interacting objectives (throughput and energy cost and safety)?
• Environmental complexity — does it operate in one clean, single-stakeholder context, or across long-horizon, multi-party, messy real-world conditions (a whole supply chain, not one machine)?
• Adaptability — when something novel happens, does it fail, alert a human, or handle it?
• Independent execution — how much of the loop (sense → decide → act) happens with no human approval step?

Operationally: a rule-based PLC scores near-zero on all four. A RAG chatbot over maintenance manuals scores a little higher on goal complexity (it can answer varied questions) but stays near-zero on independent execution (a human still acts on the answer). A closed-loop predictive-maintenance agent that reschedules its own inspection windows scores meaningfully higher on adaptability and independent execution. Full Agentic AI — autonomously redefining what “good” production looks like this week — is the paper’s aspirational top-right corner. Nobody in the paper claims to have built that top corner for a factory yet; it’s a direction, not a shipped product.

The pattern, simplified

There’s no novel algorithm to extract, but the four-module LLM-Agent loop is the closest thing to executable structure in the paper, and it’s the piece you’d actually type first. Here it is stripped to its essence, specialized to a manufacturing diagnosis example:

# The LLM-Agent loop from Section 3.1, made concrete for a CNC-fault triage agent.
# profile: fixed identity/constraints. memory: retrieved + past context.
# plan: decompose the task. act: call a tool or synthesize an answer.

def llm_agent_step(task, profile, memory, tools):
    # Profiling module: who this agent is allowed to be and do
    system_context = profile["role"] + profile["constraints"]

    # Memory module: pull relevant past interactions / retrieved docs (RAG)
    context = memory.retrieve(query=task, top_k=5)

    # Planning module: break the task into an ordered list of sub-steps
    plan = llm(f"{system_context}\nContext:{context}\nDecompose task: {task}")

    # Action module: execute each step, calling tools (sensor query, manual lookup)
    results = []
    for step in plan.steps:
        if step.needs_tool:
            results.append(tools[step.tool_name](step.args))
        else:
            results.append(llm(f"{system_context}\n{step.instruction}"))

    memory.write(task, plan, results)          # persist for next turn
    return synthesize_answer(results)           # e.g. "likely cause: spindle bearing wear"

Swap tools for a sensor API + manual-lookup RAG index and memory for a vector store, and you have the paper’s Figure 2 architecture as a runnable skeleton. The MLLM-Agent version is the same shape with context = memory.retrieve(...) replaced by a fusion step over text, image, and sensor tensors before planning — the “Fusion & Reasoning” box earns its keep exactly here.

Built on Prior Work

Results & Evidence

There is no experiment, benchmark, or new system in this paper — it’s explicitly a review/position piece submitted to a journal, not a methods paper. The “evidence” offered is:

• Three cited deployed-or-prototyped systems that anchor the lower rungs of the capability ladder: an Intelligent Manufacturing Virtual Assistant (semiconductor fab, LLM-Agent + system integration for natural-language queries and fault reports), ChatCNC (real-time RAG over CNC/IIoT sensor data for conversational machine monitoring), and an MLLM-based RAG system for ceramic-tile defect diagnosis (fuses bibliographic sources, sensor data, and visual defect images).
• A qualitative argument by analogy for the higher rungs (adaptive optimization, autonomous decision-making) — the paper explicitly says these “remain in the early stages” and cites progress in adjacent fields (medical MLLMs, embodied robotics like PaLM-E) as circumstantial evidence that the underlying tech could transfer to manufacturing, not that it has.

What this does not establish: any performance numbers, cost/latency figures, comparison against non-agentic baselines, or a working autonomous factory system. The three cited case studies are single-site, narrow-scope proofs of concept, not validated production deployments at scale. If you’re asking “does Agentic AI work in manufacturing yet,” the honest answer per this paper’s own evidence is: RAG/MLLM agents for retrieval and diagnosis, yes, in pockets; fully autonomous goal-setting Agentic AI, not demonstrated anywhere in the cited literature.

How You’d Use It

Treat this paper as a maturity ladder for your own agent projects, not a spec to implement. Each tier is a distinct build with a different risk profile — use the vocabulary to stop your own team (and yourself) from conflating them.

• Tier 1 — Semantic retrieval agent — your applications. A RAG-plus-knowledge-graph LLM-Agent over ERP/MES/PLM logs and unstructured manuals. This is the IMVA/ChatCNC pattern: lowest risk, fastest to ship, and the natural entry point if you’ve never built an AI agent before. You’re building the Profiling/Memory/Planning/Action loop above almost verbatim.
• Tier 2 — Multimodal diagnostic co-pilot. Add a vision/sensor front end (thermal, vibration, acoustic, machine-vision) and a fusion step, matching the ceramic-tile case study. This is where predictive-maintenance and quality-control copilots become genuinely differentiated, and the fusion/alignment step is the hard technical part.
• Tier 3 — Adaptive optimization loop — your automations. Close the loop: feed the agent’s diagnoses back into scheduling, energy strategy, or supply-chain adjustments with a feedback/refinement mechanism. Still task-bound (it optimizes objectives you defined), but now continuously, not on a fixed retrain cycle.
• Tier 4 — Agentic AI / autonomous orchestration — your business. Cross-system, goal-redefining autonomy across scheduling + logistics + enterprise management. The paper is explicit this is aspirational — treat it as a roadmap destination and a governance conversation (accountability, ROI measurement, human-in-the-loop guardrails), not something to plan into this quarter.

The “agenticness” framing is also a useful internal QA tool for your own work: before you call something “agentic,” score it against the four dimensions. If independent execution is near-zero (a human approves every action), call it an LLM-Agent or a copilot, not Agentic AI. That precision keeps your own expectations honest, especially once press coverage of “Agentic AI” starts setting them for you.

Build Your Own (Minimal Recipe)

You’re not building the paper’s taxonomy — you’re building the Tier 1/Tier 2 systems it describes, since those are the only ones with cited working examples.

Tier 1 (a day or two to a working prototype):

1. Knowledge index — chunk and embed manuals, logs, and reports; stand up a vector store (or a lightweight knowledge graph if entity relationships matter, e.g. part → failure mode → fix).
2. Profiling — a system prompt that scopes the agent’s role and hard constraints (e.g., “you diagnose, you do not issue shutdown commands”).
3. Memory — conversation history + retrieved context, concatenated into the prompt; a simple key-value or vector-backed store is enough at this scale.
4. Planning + Action — an LLM call that decomposes the query, then either answers directly or calls a tool (a MES/SCADA read API, a document lookup). This is the llm_agent_step loop above.

Tier 2 (the genuinely hard step up): add a vision-language model (or a small classifier + captioning pipeline if budget is tight) that turns images/sensor traces into text descriptions or embeddings the same retrieval pipeline can consume, then a fusion prompt that asks the LLM to reconcile the multimodal evidence before answering. The hard part isn’t wiring the model in — it’s getting the fusion step to not silently trust one modality over another (e.g., ignoring a clear vibration anomaly because the maintenance log is reassuring). Budget real evaluation time here; this is where MLLM-Agents fail quietly.

Libraries/models to reach for: any current-generation LLM with strong tool-use for Tier 1; a vision-language model (open or hosted) plus your existing MAS/orchestration framework (LangGraph, or your own ARC-style setup) for Tier 2’s fusion and planning; a vector DB (Chroma, pgvector, etc.) for memory/retrieval at both tiers.

How to Improve It

The paper’s own “Challenges” section is a ready-made backlog. Turned into testable, buildable ideas:

1. Build the cross-format document reconstruction layer the paper says is missing. Manufacturing manuals arrive as Word→PDF exports, LaTeX renders, and scanned images that break naive parsers (formula distortion, vector-graphic loss). A layout-aware parser (e.g., a document-vision model plus rule-based reassembly) that preserves table/formula structure is a concrete product, not just a research gap.
2. Design and benchmark a fine-grained cross-modal alignment step. The paper names this as unsolved (“achieving fine-grained cross-modal semantic alignment”) but gives no mechanism. Build a small evaluation set (sensor trace + manual excerpt + ground-truth diagnosis triples) and measure whether your Tier 2 fusion step actually improves diagnosis accuracy over text-only RAG — this is the missing benchmark the paper itself lacks.
3. Attach an explainability layer before touching Tier 4 autonomy. The paper flags interpretability as a hard blocker for high-stakes decisions. A concrete step: require every Tier 2/3 agent action to emit a structured “evidence trace” (which objects/sensors/documents supported this decision) — cheap to build, and it directly answers the accountability concern in Section 6.3.
4. Instrument agenticness, don’t just claim it. Turn the four dimensions into an actual scorecard (a rubric or even a lightweight eval harness) you run against any agent system before deployment. This makes “how agentic is this” answerable with evidence instead of marketing language — and gives you a differentiator when competitors are handwaving.
5. Attack the ROI-measurement gap directly. The paper admits AI’s manufacturing ROI “may not be immediately measurable.” Define leading indicators per tier (retrieval: time-to-answer vs. manual search; diagnosis: false-negative rate on known failure modes; optimization: schedule adherence delta) so you can see value before the six-month lagging metrics arrive.

Glossary

• AI agent — a system that perceives its environment, reasons, and acts autonomously toward a goal.
• LLM-Agent — an AI agent whose reasoning core is a large language model, typically structured as Profiling + Memory + Planning + Action.
• MLLM-Agent — an AI agent built on a multimodal LLM, able to perceive and reason over text, images, sensor data, and structured data together.
• Agentic AI — the high-autonomy end of the spectrum: systems that can independently set, revise, and pursue complex goals with minimal human oversight.
• Agenticness — a graded measure (not a yes/no label) of how autonomous a system is, scored across goal complexity, environmental complexity, adaptability, and independent execution.
• GenAI (Generative AI) — AI models that generate new content (text, images, code) rather than only classifying or predicting; LLMs and MLLMs are GenAI models.
• RAG (Retrieval-Augmented Generation) — a technique where a model retrieves relevant documents/data before generating an answer, instead of relying only on what it memorized during training.
• Knowledge graph — a structured network of entities and their relationships (e.g., part → failure mode → fix), used to ground an agent’s retrieval in explicit facts.
• Multimodal fusion — combining information from multiple data types (text, image, sensor) into one coherent representation the agent can reason over.
• MES / SCADA / PLM / ERP — Manufacturing Execution System, Supervisory Control and Data Acquisition, Product Lifecycle Management, Enterprise Resource Planning: the IT/OT systems that hold a factory’s structured operational data.
• XAI (Explainable AI) — techniques that make a model’s decisions traceable and auditable, rather than a black box.
• Digital twin — a live, data-synced digital replica of a physical asset or process, used to simulate and monitor it.