Author's): Carlos Eduardo Favini
Originally published in Towards Artificial Intelligence.
Author: Carlos Eduardo Favini
1. The Semantic Ceiling: Why Industrial Artificial Intelligence Is Stopping
After two decades of investment, approximately 70% of digital transformation initiatives do not progress beyond pilot stages (McKinsey, 2023). Industry 4.0 delivered connectivity – sensors, networks, data lakes – but not cognitive capabilities. The result: dashboards that monitor but don't make decisions, models that predict but don't understand, and automation that breaks down when the context changes.
The fundamental problem is architecture. Current system process data types – predefined categories such as “image”, “text” or “sensor reading”. But operational reality is not divided into neat categories. A technical drawing encodes spatial intention. The gesture encodes an operational command. The vibration pattern encodes the mechanical state. These aren't “data types” – they are signals carrying semantic potential.
To move from connectivity to cognition, we need an architecture that can receive signals regardless of format – including formats that do not yet exist. It must extract intent from structure, not just pattern from data. Must evaluate decisions simultaneously through multiple cognitive perspectives. Over time, he must learn and develop operational knowledge.
This article presents such an architecture – a neurosymbolic structure that bridges the gap between raw signals and intelligent action.
2. Sensory cortex: medium-agnostic perception
The first innovation is the perceptual layer that separates what carries the signal With what does the signal mean?. We call this the sensory cortex.
Traditional systems ask, “What type of data is this?” The sensory cortex asks, “Is there a structure here? And if so, does that structure carry an intention?”
This reformulation enables the processing of signals that were not anticipated at the design stage – a critical feature in industrial environments where new sensor types, protocols and formats are constantly emerging.
Hierarchy of abstractions
The sensory cortex operates at five levels of abstraction:
Level 0 – Carrier: A physical or digital substrate that transports a signal. Electromagnetic (light, radio), mechanical (vibration, pressure), chemical (molecular), digital (bits), or unknown.
Level 1 – Pattern: Detectable patterns within the carrier. Spatial structures (2D, 3D, nD), temporal sequences (rhythm, frequency), relational networks (graphs, hierarchies) and hybrid combinations.
Level 2 – Structure: Non-random organization suggesting information content. Repetition, symmetry, compressibility – entropy below the noise threshold indicating that something significant exists.
Level 2.5 – Proto-Agency: The critical bridge between structure and meaning. Does the structure suggest coded program? It's not about the meaning itself, but about suspicion this meaning exists. Indicators include functional asymmetry (intentional breaking of symmetry), oriented compression (patterns that “point” to something), transformation invariants (persistence of carrier changes), and apparent cost (structure too expensive to have arisen by chance).
Level 3 – Semantics: If proto-agency is detected, try to extract meaning. The key question is not “what is it?” But “what does this allow?“
The concept of Proto-agency (level 2.5) is innovative. Traditional systems go directly from “detected pattern” to “assigned meaning.” The sensory cortex introduces an intermediate stage: detecting a suspected intention before attempting to interpret it. This prevents false semantic attribution to random structure while allowing recognition of truly intentional signals.
Implementation: SensoryCortex class
from dataclasses import dataclass
from enum import Enum
from typing import Optional, Dict, Any
import numpy as npclass CarrierType(Enum):
ELECTROMAGNETIC = "electromagnetic"
MECHANICAL = "mechanical"
DIGITAL = "digital"
UNKNOWN = "unknown"
@dataclass
class PerceptionResult:
carrier: CarrierType
pattern_type: str
structure_score: float # (0,1) non-randomness
proto_agency_score: float # (0,1) suspicion of intention
semantic_potential: Optional(Dict(str, Any)) = None
class SensoryCortex:
"""Carrier-agnostic perception layer."""
def perceive(
self,
signal: bytes,
metadata: Dict = None) -> PerceptionResult:
carrier = self._detect_carrier(signal, metadata)
pattern = self._extract_pattern(signal, carrier)
structure_score = self._analyze_structure(pattern)
proto_agency = self._detect_proto_agency(pattern, structure_score)
semantics = None
if proto_agency > 0.6: # Threshold for semantic extraction
semantics = self._extract_semantics(pattern, carrier)
return PerceptionResult(
carrier,
pattern.type,
structure_score,
proto_agency,
semantics)
3. Cognitive core: four parallel engines
Once the signals are spotted and the semantics are extracted, decisions need to be made. Traditional systems evaluate decisions sequentially: security check → management check → reasoning → choice. This creates bottlenecks and causes the loss of key information Why a decision is good or bad from different perspectives.
The cognitive core takes a different approach: Four specialized “engines” evaluate each input simultaneouslyeach of which provides assessment from a distinct cognitive perspective:
Praxeological engine: Does this action fulfill its intention? This engine evaluates means-end consistency, asking whether the proposed action actually achieves the intended goal. It is rooted in the logic of purposeful human action – the science of what works.
Nash engine: Does this strike a balance? In complex systems, many stakeholders have competing goals: production versus safety, short-term performance versus long-term maintenance. This engine finds Nash equilibria – stable states in which neither side can unilaterally improve its position.
Chaotic engine: Is it resistant to interference? Small changes can turn into catastrophic failures. This engine performs sensitivity analysis, identifies strange attractors, and maps failure modes before they manifest themselves.
Meristic meta-engine: What patterns exist at different scales? Operating simultaneously at micro, meso, and macro levels, this engine detects repeating structures, generates variant hypotheses, and imagines what should it exists, but it is not there yet. It proposes but never decides – creativity in containment.
4. Craft efficiency: product, not sum
The four engines produce results in the range (0,1). How to combine them into one decision indicator?
The intuitive approach is based on a weighted average: CP = 0.3×P + 0.3×N + 0.2×C + 0.2×M. This approach is fundamentally wrong.
Consider the following scenario: the praxeological score is 0.95 (excellent intention matching), the Nash score is 0.90 (good balance), the chaotic score is 0.85 (perturbation-resistant), but the meriistic score is 0 (the metaengine detects basic pattern violations that other engines missed). The weighted average would be approximately 0.68. The system will continue with what appears to be a “moderately good” decision.
But any engine that has zero points represents a categorical rejection. No amount of perfection in three dimensions makes up for fundamental failure in one.
This is what I call the “yen example”: if you have 1 million yen and I have zero, then our “average” wealth of 500,000 yen is a statistical lie. You eat dinner; I'm starving. Mediocrity obscures the reality that one party has nothing.
Therefore, the craft efficiency is calculated as product: :
CP = Result_P × Result_N × Result_C × Result_M
It creates absolute veto property: every single zero collapses the entire result to zero. Perfection requires the consent of all engines. There is no compensation, no error averaging.
Implementation: Parallel engine evaluation
from concurrent.futures import ThreadPoolExecutor
from functools import reduce
import operatorclass CognitiveCore:
def __init__(self):
self.motors = {
'praxeological': PraxeologicalMotor(),
'nash': NashMotor(),
'chaotic': ChaoticMotor(),
'meristic': MeristicMetaMotor()
}
def evaluate(self, intent, context):
# Parallel evaluation — concurrent runs
with ThreadPoolExecutor(max_workers=4) as executor:
# Submit evaluation tasks
futures = {
name: executor.submit(
motor.evaluate,
intent,
context
)
for name, motor in self.motors.items()
}
# Gather results once completed
scores = (
futures(name).result()
for name in self.motors
)
# Craft Performance = PRODUCT (not sum)
# Any zero = total zero (absolute veto)
craft_performance = reduce(
operator.mul,
(s.score for s in scores),
1.0
)
return craft_performance, scores
5. The operational genome: knowledge as a living structure
The cognitive core relies on a knowledge base we call the operational genome. The biological metaphor is intentional, but strictly architectural: we use genomic terminology to describe patterns of inheritance and composition, not to imply biological processes.
Codon: Atomic unit of operational intent. Structure: (Element | Action | Target state). Example: (Valve-401 | Close | Isolated).
Gene: The sequence of codons that make up a complete operational procedure. Contains prerequisites, instructions, exceptions, and success criteria.
Genome: Complete gene library for the operational domain. Not static documentation – a living structure that evolves with use.
Most importantly, the genome encodes two different types of truth:
Recorded truth (blockchain): Immutable records of what actually happened. Contextual, historical, crystallized. Foucault's truths – localized and detailed.
Synthetic truth (DNA Patterns): Plastic approximations of perfect patterns. Universal, calculating, evolving. Platonic truths – forms of aspiration that we approach but never achieve.
6. Complete decision process
By connecting the sensory cortex, cognitive core and operational genome, the complete architecture creates a closed cognitive loop. Signals from the real world are perceived, evaluated and taken into account, and the results provide feedback to improve the system's knowledge.
Implementation: Closed Cognitive Loop
# Initialize the cognitive system
cortex = SensoryCortex()
core = CognitiveCore()
# Load the specific unit's genome
genome = Genome.load("./assets/refinery/unit-42.json")# Step 1: Perceive incoming signal
perception = cortex.perceive(incoming_signal, metadata)
# Step 2: Check proto-agency threshold
if perception.proto_agency_score < 0.6:
genome.store_unresolved(perception)
return
# Step 3-4: Match intent to candidate genes
intent = perception.semantic_potential
candidates = genome.match(
intent,
telemetry.current_state()
)
# Step 5: Evaluate through PARALLEL motors
# This creates a list of (gene, score, explanation)
evaluated = (
(gene, *core.evaluate(gene, context))
for gene in candidates
)
# Step 6-7: Select best and execute
# Find the gene with the highest Craft Performance (cp)
best_gene, best_cp, _ = max(
evaluated,
key=lambda x: x(1)
)
if best_cp > 0.5:
outcome = orchestrator.execute(best_gene)
# Register truth (Blockchain)
genome.register_truth(best_gene, outcome)
# Update fitness (Evolution)
genome.update_fitness(best_gene, outcome)
7. Implications for Industry 5.0
Industry 5.0 – as formulated by the European Commission – emphasizes three pillars: human-centricity, sustainable development and resilience. Each of them requires capabilities that current architecture cannot provide.
Human focus it requires understanding human expression—gestures, glances, hidden intentions. The sensory cortex enables the perception of embodied communication by separating the medium from the meaning.
Sustainability requires balancing competing goals over different time horizons. Nash Motor finds the balance between immediate performance and long-term asset conservation.
Resistance requires detection of new disorders. Chaotic Engine identifies sensitivity relationships; Meristic Meta-Motor imagines failure modes before they occur.
The architecture presented here is a foundation – a structural foundation on which industrial cognition can be built. But the basic knowledge is as follows: structure precedes meaning, and meaning emerges from potential action. The systems that understand this will define the next industrial era.
8. Open research questions
Federation: How can operational genomes be shared across organizations while maintaining a competitive advantage?
Proto-agency formalization: What is the mathematical basis for distinguishing purposeful structure from complex randomness?
Engine calibration: Is the product function universally appropriate, or are there contexts requiring alternative aggregation?
Security management: What regulatory framework ensures that autonomous knowledge evolution improves rather than worsens security?
These questions define the boundary. Architecture is the basis for their exploration.
About the author: Carlos Eduardo Favini studies neurosymbolic architectures for industrial cognition. His work spans three decades of operational experience, from offshore platforms to surgical centers. He is the author of the book “Digital Genome”. Connect LinkedIn or review the framework at GitHub.
Published via Towards AI
