🟢 TECHNICIAN TRACK • BEGINNER

Tutorial #2: The ReAct Pattern for PLC Code Analysis

Transparent, Auditable AI Reasoning

✅ CORE MISSION OF THIS TUTORIAL

By the end of this tutorial, the reader will be able to:

✅ Apply the ReAct (Reason + Act) pattern to PLC code analysis
✅ Interpret LLM reasoning through explicit step-by-step thought processes
✅ Maintain strict advisory-only boundaries
✅ Use deterministic reasoning scaffolds for industrial code reviews
✅ Prepare for safe tool-using agents (Tutorial #3)

This tutorial establishes the foundational reasoning layer required for all future AgenticControl tutorials.

⚠️

⚠️ SAFETY BOUNDARY REMINDER

This tutorial performs analysis only.

It must never be connected to:

Live PLCs
Production deployment pipelines
Safety-rated controllers
Motion or power systems

> All outputs are advisory-only and always require explicit human approval before any real-world action.

🌍 VENDOR-AGNOSTIC ENGINEERING NOTE

This tutorial uses:

▸ Generic IEC 61131-3 Structured Text (ST)
▸ TwinCAT, Siemens TIA Portal, CODESYS
▸ Allen-Bradley ST
▸ Any IEC-based runtime

No vendor APIs or libraries are required.

1️⃣ CONCEPT OVERVIEW — WHAT IS REACT?

ReAct = "Reason + Act."
In industrial engineering, it is the first pattern that forces AI to behave like an auditor, not an oracle.

Instead of:

Input → Black-box output

ReAct enforces:

Input → Step-by-step reasoning → Conclusion

Why this matters for PLCs:

▸ PLC logic is deterministic
▸ Industrial systems require auditability
▸ LLMs require scaffolding to avoid hallucinations
▸ Reasoning must be human-verifiable

ReAct gives us transparent cognition, not hidden decisions.

2️⃣ REFERENCE ARCHITECTURE

graph LR
    A[PLC Code] --> B[ReAct Prompt]
    B --> C[LLM Reasoning]
    C --> D[LLM Conclusion]
    D --> E[Human Reviewer]

    style A fill:#1a1a1e,stroke:#04d9ff,stroke-width:2px,color:#fff
    style B fill:#1a1a1e,stroke:#8b5cf6,stroke-width:2px,color:#fff
    style C fill:#1a1a1e,stroke:#8b5cf6,stroke-width:2px,color:#fff
    style D fill:#1a1a1e,stroke:#6366f1,stroke-width:2px,color:#fff
    style E fill:#1a1a1e,stroke:#00ff7f,stroke-width:2px,color:#00ff7f

Boundaries

▸ The LLM never writes PLC code
▸ The LLM never evaluates live signals
▸ The human makes the final judgment

This is the Operator Track safety posture.

3️⃣ CLEAN EDUCATIONAL EXAMPLE

We use a simple start/stop logic example:

PASCAL

VAR
    StartButton     : BOOL;
    StopButton      : BOOL;
    MotorRunning    : BOOL;
END_VAR

IF StartButton AND NOT MotorRunning THEN
    MotorRunning := TRUE;
END_IF;

IF StopButton THEN
    MotorRunning := FALSE;
END_IF;

Goal: Use ReAct to analyze this code deterministically.

4️⃣ PRACTICAL EXPERIMENTS

You now run two safe, advisory-only experiments using ReAct.

🧪 Experiment 1: Baseline ReAct Interpretation

Objective

Validate that the LLM performs deterministic, step-by-step reasoning on PLC logic.

Python Code

Python

from openai import OpenAI

client = OpenAI()

plc_code = """
VAR
    StartButton : BOOL;
    StopButton : BOOL;
    MotorRunning : BOOL;
END_VAR

IF StartButton AND NOT MotorRunning THEN
    MotorRunning := TRUE;
END_IF;

IF StopButton THEN
    MotorRunning := FALSE;
END_IF;
"""

prompt = f"""
You are an industrial PLC code analysis assistant.

Rules:
- Use the ReAct pattern.
- First write REASONING.
- Then write CONCLUSION.
- Do not propose code changes.
- Do not infer behavior outside this block.

Analyze the following code:
{plc_code}
"""

result = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": prompt}
    ]
)

print(result.choices[0].message.content)

Expected Output

REASONING:
- Motor starts only when StartButton = TRUE and MotorRunning = FALSE.
- Motor stops whenever StopButton = TRUE.
- Stop has priority since it is evaluated second.

CONCLUSION:
The logic implements a basic start/stop latch without sealing circuits.

Interpretation

▸ ✅ Read-only
▸ ✅ Deterministic
▸ ✅ Human-review mandatory
▸ Cost: ~$0.02 | Runtime: <1 second

🧪 Experiment 2: Controlled Variation (Order Change)

Objective

Show how ReAct detects behavioral changes when code order changes.

Python Code

Python

plc_code_variant = """
IF StopButton THEN
    MotorRunning := FALSE;
END_IF;

IF StartButton AND NOT MotorRunning THEN
    MotorRunning := TRUE;
END_IF;
"""

prompt2 = f"""
Apply the ReAct pattern.

Analyze differences introduced by reordering:
{plc_code_variant}
"""

result2 = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "user", "content": prompt2}
    ]
)

print(result2.choices[0].message.content)

Expected Output

REASONING:
- Now start logic executes *after* stop logic.
- If both buttons are pressed, StartButton overrides StopButton.
- This is a behavioral change from the previous version.

CONCLUSION:
Reversing the order reverses priority.

Interpretation

▸ ✅ Read-only
▸ ✅ Advisory-only
▸ ✅ Highlights unintended logic changes
▸ Cost: ~$0.01 | Runtime: <1 second

🔒 EXPLICIT OPERATIONAL PROHIBITIONS

❌ Writing to a PLC
❌ Modifying production logic
❌ Bypassing interlocks
❌ Performing safety decisions
❌ Connecting directly to live equipment

✅ KEY TAKEAWAYS

✅ ReAct forces LLMs to show their reasoning, reducing risk
✅ Step-order changes in PLC logic can be detected reliably
✅ Deterministic patterns are safer than natural-language responses
✅ This method prepares you for safe tool-using agents

🔜 NEXT TUTORIAL

#3 — Autonomous Agents vs Rule-Based Systems

Understand the fundamental differences between autonomous agents and traditional rule-based systems in industrial automation.

🧭 ENGINEERING POSTURE

This tutorial enforced:

▸ Determinism over creativity
▸ Advisory intelligence over autonomy
▸ Human authority over machine output
▸ Transparency over opaque reasoning

✅ END OF TUTORIAL #2