Author(s): Carlos Eduardo Favini
Originally published on Towards AI.
by Carlos Eduardo Favini
1. Semantic Ceiling: Why Industrial AI Stalls
After two decades of investment, nearly 70% of digital transformation initiatives have failed to progress beyond pilot stages (McKinsey, 2023Industry 4.0 provided connectivity – sensors, networks, data lakes – but not cognition. The result: dashboards that monitor but don’t make decisions, models that predict but don’t understand, and automation that breaks when the context changes.
The main problem is architecture. current system process data types – Predefined categories like “image,” “text,” or “sensor reading.” But operational reality does not fall into neat categories. A technical drawing encodes spatial intent. A gesture encodes an operational command. A vibration pattern encodes mechanical state. These are not “data types” – they are signals with semantic potential,
To move from connectivity to cognition, we need an architecture that can understand signals regardless of format – including formats that don’t yet exist. It should extract intent from the structure, not just patterns from the data. It must evaluate decisions through multiple cognitive lenses simultaneously. And it must learn and develop operational knowledge over time.
This article presents such an architecture – a neuro-symbolic framework that bridges the gap between raw signals and intelligent action.
2. Sensory cortex: carrier-agnostic perception
The first innovation is a perception layer that separates what does it indicate From what does the signal meanWe call this the sensory cortex,
Traditional systems ask: “What data type is this?” The sensory cortex asks: “Is there a structure here? And if so, is there any intention in that structure?”
This reframing enables the processing of signals that were not expected at design time – a critical capability for industrial environments where new sensor types, protocols, and formats are constantly emerging.
abstract hierarchy
The sensory cortex operates through five levels of abstraction:
Level 0 – Carrier: The physical or digital substrate that transports the signal. Electromagnetic (light, radio), mechanical (vibration, pressure), chemical (molecular), digital (bits), or unknown.
Level 1 – Pattern: Detectable regularities within the carrier. Spatial structures (2D, 3D, ND), temporal sequences (rhythm, frequency), relational networks (graphs, hierarchies), or hybrid combinations.
Level 2 – Structure: Non-random organization of suggesting information content. Repeatability, isomorphism, compressibility – entropy below the noise threshold indicates that something meaningful exists.
Level 2.5 – Proto-Agency: The vital bridge between structure and meaning. What does the structure suggest? encoded agendaIt is not the meaning of itself, but Doubt That meaning is there. Indicators include functional asymmetry (purposeful disruption of symmetry), oriented compression (patterns that “point” toward something), variational invariance (persistence in carrier changes), and apparent cost (structure too expensive to arise by chance).
Level 3 – Semantics: If proto-agency is detected, try to make meaning. The main question is not “What is it?” But “What does it allow to do?,
The concept of proto-agency (level 2.5) is novel. Traditional systems move directly from “pattern detected” to “meaning assigned”. The sensory cortex introduces an intermediate step: detecting suspicions of intent before attempting interpretation. This prevents false semantic attribution to random structure while enabling the identification of truly purposeful 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 Motors
Once the signals are understood and the semantics extracted, a decision must be made. Traditional systems evaluate decisions sequentially: security check → governance check → estimation → selection. This causes interruptions and important information is lost Why A decision is good or bad from different points of view.
The cognitive core takes a different approach: four special “motors” evaluate each input simultaneouslyEach offers a score from a different cognitive lens:
Praxeological Motor: Does this action achieve its intent? This motor evaluates means-end coherence, asking whether the proposed action actually achieves the stated goal. It is rooted in the logic of purposeful human action – the science of what works.
Nash Motor: Does this create balance? In complex systems, many stakeholders have competing objectives: production versus safety, short-term efficiency versus long-term maintenance. This motor establishes a Nash equilibrium – a stable state where neither party can unilaterally improve its position.
Chaotic Motor: Is it robust to disturbances? Small changes can turn into catastrophic failures. It performs motor sensitivity analysis, identifies strange attractors, and maps failure modes before they appear.
Meristic Meta-Motor: What patterns are present on scales? Working simultaneously at the micro, meso, and macro levels, this motor detects recurring structures, generates various hypotheses, and visualizes what Needed Exists but not yet. It proposes but never decides – creativity is in control.
4. Craft Display: Product, Not Yoga
Four motors generate scores in the interval (0,1). How should these be combined into a single decision metric?
The intuitive approach is valued on average: CP = 0.3×P + 0.3×N + 0.2×C + 0.2×MThis approach is fundamentally wrong,
Consider this scenario: the praxeological score is 0.95 (excellent intent alignment), the Nash score is 0.90 (good balance), the chaotic score is 0.85 (robust to perturbations), but the meristic score is 0 (meta-motor detects a fundamental pattern violation that other motors missed). The weighted average will be approximately 0.68. The system will proceed with what appears to be “Moderately good” decision.
But any motor scoring zero represents a categorical rejectionNo amount of excellence in three dimensions can compensate for a fundamental failure in one,
This is what I call the “yen example”: If you have 1 million yen and I have zero, our “average” wealth of 500,000 yen is a statistical lie. You eat food; I am hungry. Averages obscure the reality that one party has nothing.
Therefore, craft performance is calculated as product,
CP = Score_P × Score_N × Score_C × Score_M
it makes a absolute veto Property: Any one zero drops the entire score to zero. Excellence requires all motors to agree. There is no compensation here, no average for failure.
Implementation: Parallel Motor 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. Operational Genome: Knowledge as a Living Structure
Based on the knowledge of cognitive root causes we call the operational genome. The biological metaphor is intentional but entirely architectural: we use genomic terminology to describe inheritance and structure patterns, not to depict biological processes.
Coding: Nuclear unit of operational intent. structure: (Entity | Action | Target-State). Example: (valve-401 | close | isolated).
Jean: A sequence of coding forms a complete operational process. It includes prerequisites, instructions, exceptions, and success criteria.
Genome: Complete library of genes for one operational domain. Not static documentation – a living structure that evolves through use.
Critically, the genome encodes two different types of truth:
registered truth (Blockchain): Immutable record of what actually happened. Relevant, historical, dense. Foucauldian truth – situated and particular.
synthetic truth (DNA pattern): Plastic approximation of the ideal pattern. Universal, calculative, evolving. Idealistic Truth – We reach for aspirational forms but never reach them.
6. Complete decision flow
Bringing together the sensory cortex, cognitive core, and operational genome, the entire architecture forms a closed cognitive loop. Signals from the real world are understood, evaluated, acted upon and the results given feedback to improve the knowledge of the system.
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 expressed by the European Commission – emphasizes three pillars: human-centricity, sustainability and resilience. Each requires capabilities that current architectures cannot provide.
anthropocentrism There is a need to understand human expression – body language, glances, underlying intentions. The sensory cortex enables the perception of embodied communication by separating the carrier from the meaning.
sustainability There is a need to balance competing objectives between deadlines. The Nash motor finds a balance between immediate efficiency and long-term resource conservation.
resilience New disturbances need to be detected. Chaotic motor sensitivity identifies dependencies; Meristics visualize meta-motor failure modes before they occur.
The architecture presented here is a foundation – a structural substrate on which industrial cognition can be built. But the basic insight persists: Structure comes before meaning, and meaning emerges from potential action.The systems that understand this will define the next industrial age,
8. Open research question
Federation: How can operational genomes be shared across organizations while maintaining competitive advantage?
Proto-Agency Formalization: What are the mathematical bases for distinguishing purposeful structure from complex randomness?
Motor calibration: Is the product function universally appropriate, or are there contexts that require alternative aggregation?
Security Administration: What regulatory frameworks ensure that autonomous knowledge development improves rather than degrades security?
These questions define the range. Architecture provides a basis for their exploration.
About the author: Carlos Eduardo Favini researches neuro-symbolic architecture for industrial cognition. His work spans three decades of operational experience from offshore platforms to surgical centres. He is the author of “The Digital Genome”. connect Linkedin or explore the outline GitHub,
Published via Towards AI
