AGENTICCONTROL.dev
🟢 Technician Track
Tutorial 3 of 10
🟢 TECHNICIAN TRACK • BEGINNER

Tutorial #3: Autonomous Agents vs Rule-Based Systems

Understanding Goals, State, and Reasoning

✅ CORE MISSION OF THIS TUTORIAL

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

  • ✅ Distinguish rule-based automation from autonomous agent behavior
  • ✅ Understand how goals, state, and reasoning differentiate agents from PLC logic
  • ✅ Simulate a PLC scan cycle as a deterministic rule system
  • ✅ Simulate an agent decision cycle as a goal-driven advisory system
  • ✅ Prepare conceptually for Agent Memory and State Persistence in Tutorial #4

This tutorial establishes the conceptual definition of an autonomous agent, before any tools or I/O are introduced.

⚠️

⚠️ SAFETY BOUNDARY REMINDER

This tutorial uses simulation 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 control logic
  • ▸ Generic scan-cycle simulation
  • ▸ Generic goal-driven reasoning
  • ▸ Standard Python only

No vendor PLC API, runtime, or hardware is required. The concepts apply equally to TwinCAT, TIA Portal, CODESYS, Rockwell, and IEC-based systems.

1️⃣ CONCEPT OVERVIEW — RULES VS AGENTS

Rule-Based System (PLC-style)

A rule-based system:

  • ▸ Executes predefined logic
  • ▸ Has no goals
  • ▸ Has no self-evaluation
  • ▸ Has no planning
Current Inputs → Current Logic → Current Outputs

This is why PLC programs are:

  • ✅ Deterministic
  • ✅ Verifiable
  • ✅ Stable
  • ✅ Predictable

But also:

  • ❌ Non-adaptive
  • ❌ Non-explanatory
  • ❌ Non-goal-seeking

Autonomous Agent

An autonomous agent:

  • ▸ Has an explicit goal
  • ▸ Observes the current state
  • ▸ Reasons about how to achieve the goal
  • ▸ Re-evaluates when conditions change
Observe → Reason → Decide → Observe Again

A PLC executes what it is told.
An agent reasons about what it should do next.

2️⃣ REFERENCE ARCHITECTURE — TWO DECISION MODELS

Rule System (PLC)

Inputs → Logic → Outputs → Next Scan

Agent System

State → Goal → Reasoning → Advisory Decision → Re-Evaluate

PLC Rule-Based Flow

graph LR
    A[Read Inputs] --> B{IF-THEN Rules}
    B --> C[Write Outputs]
    C --> D[Next Scan]
    D --> A

    style A fill:#1a1a1e,stroke:#04d9ff,stroke-width:2px,color:#fff
    style B fill:#1a1a1e,stroke:#1f75ff,stroke-width:2px,color:#fff
    style C fill:#1a1a1e,stroke:#04d9ff,stroke-width:2px,color:#fff
    style D fill:#1a1a1e,stroke:#04d9ff,stroke-width:2px,color:#fff

Deterministic, repeatable, no goals or reasoning

Agent Autonomous Flow

graph LR
    A[Perceive State] --> B[Check Goal]
    B --> C{Reasoning}
    C --> D[Evaluate Options]
    D --> E[Recommend Action]
    E --> A

    style A fill:#1a1a1e,stroke:#9e4aff,stroke-width:2px,color:#fff
    style B fill:#1a1a1e,stroke:#9e4aff,stroke-width:2px,color:#fff
    style C fill:#1a1a1e,stroke:#9e4aff,stroke-width:2px,color:#fff
    style D fill:#1a1a1e,stroke:#9e4aff,stroke-width:2px,color:#fff
    style E fill:#1a1a1e,stroke:#00ff7f,stroke-width:2px,color:#00ff7f

Goal-driven, adaptive reasoning, advisory only

Boundaries in This Tutorial

  • ✅ PLC = deterministic simulation only
  • ✅ Agent = advisory reasoning only
  • ✅ Human = final authority

3️⃣ CLEAN EDUCATIONAL SCENARIO

We simulate a very simple industrial situation:

  • ▸
    Motor states: OFF, RUNNING, FAULTED
  • ▸
    Inputs: Start button, Stop button, Fault signal

We will now implement this twice:

  1. As a rule-based PLC scan
  2. As a goal-driven advisory agent

4️⃣ PRACTICAL EXPERIMENTS

🧪 Experiment 1: Deterministic PLC Scan Simulation (Rule-Based)

Objective

Demonstrate how a scan-based rule system reacts without goals or reasoning.

Python Code

Python 
# Simulated PLC Scan Cycle (Rule-Based)

def plc_scan(motor_running, start_button, stop_button, fault):
    """Apply PLC logic rules to determine motor state."""
    if fault:
        motor_running = False
    elif stop_button:
        motor_running = False
    elif start_button:
        motor_running = True
    return motor_running

# Track motor state across scan cycles
motor_running = False

# Simulated input sequence
inputs = [
    {"start": True,  "stop": False, "fault": False},
    {"start": False, "stop": False, "fault": False},
    {"start": False, "stop": False, "fault": True},
]

for cycle, i in enumerate(inputs, 1):
    motor_running = plc_scan(motor_running, i["start"], i["stop"], i["fault"])
    print(f"Scan {cycle}: MotorRunning = {motor_running}")

Expected Output 

Scan 1: MotorRunning = True
Scan 2: MotorRunning = True
Scan 3: MotorRunning = False

Interpretation

  • ▸ ✅ Pure simulation
  • ▸ ✅ No goals
  • ▸ ✅ No reasoning
  • ▸ ✅ Fully deterministic
  • ▸ Cost: $0.00 | Runtime: <1 second

🧪 Experiment 2: Goal-Driven Advisory Agent (Autonomous Reasoning)

Objective

Demonstrate how an agent reasons about a goal, instead of executing fixed rules.

Python Code

Python 
from openai import OpenAI
import json

client = OpenAI()

current_state = {
    "motor_running": False,
    "fault": True,
    "start_button_pressed": True
}

goal = "Keep the motor running safely without violating fault conditions."

prompt = f"""
You are an autonomous industrial reasoning assistant.

You MUST:
- Output REASONING first
- Then output DECISION
- Then output EXPLANATION
- You are NOT allowed to control hardware
- You are NOT allowed to issue commands

Current state:
{json.dumps(current_state, indent=2)}

Goal:
{goal}
"""

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

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

Expected Output 

REASONING:
The motor is currently not running and a fault is active.
Running the motor while a fault is present would violate safety.

DECISION:
Do not recommend starting the motor.

EXPLANATION:
Although the start button is pressed, the active fault prevents safe operation. The goal of safe operation overrides the start request.

Interpretation

  • ▸ ✅ Advisory only
  • ▸ ✅ No actuation
  • ▸ ✅ No PLC write-back
  • ▸ ✅ Human-only execution authority
  • ▸ Cost: ~$0.01-$0.02 | Runtime: <1 second

🔒 EXPLICIT OPERATIONAL PROHIBITIONS

  • ❌ Writing PLC memory
  • ❌ Generating control logic
  • ❌ Issuing start/stop commands
  • ❌ Overriding safety faults
  • ❌ Auto-acknowledging alarms
  • ❌ Connecting to live equipment

✅ KEY TAKEAWAYS

  • ✅ A PLC executes rules without goals or reflection
  • ✅ An agent reasons about goals and states
  • ✅ Agents can explain why a decision is recommended
  • ✅ Rule-based systems cannot self-justify
  • ✅ Autonomy begins with goals, not tools

🔜 NEXT TUTORIAL

T4 — Agent Memory and State Persistence

Learn how conversation memory enables agents to detect patterns across observations and maintain context for industrial diagnostics.

🧭 ENGINEERING POSTURE

This tutorial enforced:

  • ▸ Conceptual clarity over premature tooling
  • ▸ Deterministic rules vs goal-driven reasoning
  • ▸ Advisory intelligence over control authority
  • ▸ Human responsibility over machine autonomy

✅ END OF TUTORIAL #3