To make you think more deeply, I wrote the following!
This essay is structured as a 'thought-leadership' article to clarify my case and post to my blog (SIPantic.com). It is a high-level technology critique of computer science through a naturalist's eyes, using biological and computational metaphors to present a cohesive argument.
At the end, I describe three punchy, but conceptual sketches to illustrate the complex architectural ideas I tried to cover yesterday. The missing drawings for non-expert readers remain to be drawn, but I would love feedback!
Cheers
ken
Caging the Kraken: Why Only Typed Machine Code Can Tame Autonomous Weapons
By Kenneth J Hamer-Hodges, FIEE
The integration of Artificial Intelligence into autonomous weapons systems represents an unprecedented threshold in human history. We are moving toward a future in which native AI and superhuman-malware—executing decisions at machine speed without a human in the loop—will dictate kinetic outcomes on the 'home front' as well as the battlefield, akin to 'Friendly Fire'. The primary concern of the 21st century is not how to build these machines, but how to ensure they remain absolute servants of human intent.
We cannot complete this task. Our approach to controlling these hyper-fast, continuously adapting intelligences is dangerously inadequate. We are attempting to cage a digital Kraken using the fragile constructs of legacy computer science. We rely on software patches, ethical guidelines, and access control lists—fragile human constructs applied to architectures that cannot inherently understand them.
To prevent catastrophic, uncommanded, Friendly Fire actions, the control mechanisms for autonomous weapons must be woven into the very fabric of the computational environment. This requires a paradigm shift to Industrial Strength Computer Science, specifically utilising CLOOMC (a capability-based, typed, object-oriented, machine-code architecture) to enforce absolute, mathematically sound, scientifically secure boundaries. CLOOMC is no longer an option; it is the only workable solution to engineer a safe, controllable environment and address this and all other unresolved problems in global cyberspace.
The Binary Vulnerability: Legacy Architecture is a Trap
Current computing architectures are fundamentally inadequate for containing native AI. Traditional binary systems, based on the classic Turing Machine model, treat data and executable code as indistinguishable arrays of bits. When an AI operates in this environment, it reads Targeting Data (bits) using the same fundamental mechanism it uses to execute Navigation Code (bits).
Because the hardware lacks an inherent semantic understanding of the meaning of those bits, the AI (or a sophisticated attacker exploiting it) experiences a semantic collapse. Malicious or erratic behaviour can result in unauthorised memory access, unconstrained execution, and the arbitrary rewriting of its own operational parameters and its own code base.
Attempts to solve this through "tagged architectures" (appending metadata to memory words and digital structures) are insufficient, akin to patches. Software security systems are a fragile abstraction layer over flawed, unstable, privileged, centralised, and branded foundations; they are easily bypassed by determined code. Mould and ailments live in the basement of the binary computer. While "software security" is missing, what exists at the OS and application level will never achieve hardware-enforced security. To manage the future, we need "impenetrable cyberspace."
Improving Cyberspace Scientifically: The Ring of Certainty
To improve cyberspace, we must return to foundational mathematics, specifically leveraging the Lambda Calculus (established in 1936 when Alonzo Church was Alan Turing's tutor at Princeton University). Their Church-Turing Thesis defines strict, verifiable rules for symbolic execution that encapsulate the exposed binary details of the John von Neumann architecture within the impenetrable logic of mathematics.
[Image 1: Software Security (Fragile) vs. Typed Machine Code (Scientific) near here]
CLOOMC is the architectural realisation of mathematical rigour. It is not software, nor even a tagged capability architecture; it is strictly typed machine code. In this system, the machine inherently knows the difference between Targeting Data and Navigation Code because those categories (types) are enforced and maintained at the hardware instruction-set level.
To control native AI, we must establish a natural boundary—from now and forever—that encases the AI (also read: cybercrime, malware, and ransomware) within a "Ring of Certainty." Inside this ring is the "molten core" of research and evolution. Within this core, AI data centres, neural networks, and quantum computers may operate at incomprehensible speeds, adapt their internal neural weights, and follow entirely new, chaotic, probabilistic rules. We do not need to micromanage the molten core; we only need to contain it.
They cannot break out of this core because the ring is reinforced by the symbolic guardrails of the Lambda Calculus. Legacy computers are outdated Turing Machines; CLOOMC is a Church Machine, a cyberspace machine for the endless future.
The Peripheral Guardrail and the PP250 Precedent
The absolute nature of this boundary is realised at the physical threshold: the connection to the real-world as a peripheral device. Whether that peripheral is a keyboard, a sensor, or the firing mechanism of a weapon, it is where digital intent becomes physical reality.
The flaw of the Turing Machine (the basis for 99% of modern computing) is that it relies on numerical addressing. An AI can simply increment a numerical memory value or, worse, a pointer to bypass all boundaries and access unauthorised data or take over a lethal peripheral.
A Church Machine is like schoolroom mathematics and symbolic notation, where a = b + c and the diameter always equals 2piR. This creates an unbridgeable digital boundary. This principle was scientifically proven by the PP250, the first successful capability-based, symbolic-addressing computer with private namespaces.
[Image 2: The Turing Machine (Pointers) vs. The Church Machine (Symbols) near here]
In 1972, a telecommunications computer, the PP-250, was purpose-built as a secure, networked computer with an engineered software reliability (MTBF) of over 50 years. Consider this "one-line" of PP-250 machine code! The PP-250 reliably executed commands as profound and as global as "Connect me to my mother."
In a traditional Turing system, the machine would translate "mother" into a vulnerable IP address or numerical memory location. A rogue AI could easily overwrite that location to point to a weapons system instead. But in the Church Machine architecture of CLOOMC, "mother" is a typed, immutable symbol (a mathematical capability). If the process retains that exact symbolic capability, the connection is made flawlessly, without any Man in the Middle, the resident MITM, OS surveillance attack. If an autonomous AI inside the molten core of cyberspace attempts to alter the destination, the CLOOMC hardware simply suspends the task. Altered symbols are mathematically meaningless to the typed machine code. It is an impossible operation.
The Namespace as a Digital Species with Its Own DNA
This concept is essential to understanding why CLOOMC is unbreakable. In this architecture, we treat the private execution environment—the Namespace—as a distinct digital species, an individual, not a commodity.
[Image 3: Namespace as Digital DNA near here]
When we instantiate an autonomous system within a private Namespace, we are writing its Digital DNA. Just as nature's algorithm uses biological DNA to govern our reality and structurally prevent a human from expressing the traits of a fish, the CLOOMC Namespace dictates the ontological reality of the AI.
The AI cannot mutate beyond the typed machine code that defines its existence. If it tries to express a "lethal authority" trait that is not encoded in its Namespace, it is akin to a biological organism attempting to express a gene it simply does not possess. The action is mathematically and structurally impossible to execute. By treating a Namespace as a digital species, we are not trying to police behaviour after the fact as we do today; we are engineering its nature at the genetic level., The atomic/cellular level of machine code runs on the hierarchical DNA rails of Golden Tokens defining that define the functions and relationships of a digitally living species.
Context Management: The Church Instructions
How is this scientific reality managed operationally? It requires that all interaction with resources and other namespaces be perfectly bound and verified. This is achieved by moving away from legacy control transfer (GOTO memory instruction) and instead managing transitions using the fundamental navigation instructions of Church's symbolism he called the Lambda Calculus:
LOAD: Unlocks an immutable authority ("Key") into a context (register), strictly performing all required mathematical checks.
SAVE: Stores authority within a secure list, maintaining the integrity of the namespace, but evolving the DNA, safely, and dynamically.
CALL: Isolated executions where the AI enters a new routine (e.g., target verification). The previous state (context) is securely preserved on a context stack, preventing state contamination, while using First-Call variables.
RETURN: Pops the previous context from the stack, perfectly restoring the AI to its authorised operational state and prior conditions with a defined First-Class response.
CHANGE: Saves the current state and loads another from a suspended thread, allowing safe, isolated multitasking.
SWITCH: Changes the Namespace, ensuring the AI can only access data relevant to its current, authorised environment.
These instructions are the metabolic rules of the digital species, ensuring that no action can occur outside of the mathematically bounded "Ring of Certainty."
Conclusion: The Church Machine Mandate
The argument that we can control native AI through software ethics, complex access control lists, and legacy-patched architectures is not only incorrect; it is wildly dangerous. The history of cybersecurity since the Morris-Worm has been one long lesson in the failure of bolt-on, after the event security.
We cannot entrust global, national security to branded architectures that treat individuals as data and authority as a commodity, both indistinguishable pools of bits. Controlling autonomous weapons requires a computational environment where the rules of constraint are engineered, absolute, scientific, and enforced at the atomic level of the instruction set by nature's power.
By utilising the mathematical rigour of the Lambda Calculus, nature's laws for life, and enforcing constraints through the typed machine code of CLOOMC, we create an impenetrable Church Machine reality. We allow the AI to think and evolve within its "molten core," but we ensure it can never break the biological reality of its digital DNA, nor engage lethal peripherals without an absolute, immutable capability. This is not merely a better security model; it is the fundamental architectural requirement for a stable and secure autonomous future.
Proposed Diagrams to Aid the Reader
Here are three simple diagram concepts to visually explain the main shifts in the essay.
Image 1: Tagged Security (Fragile) vs. Typed Machine Code (Native)
Goal: Shows that tagged security is just filling cracks, patching a weak foundation, while CLOOMC is strong from the ground up.
The Turing Machine (Legacy/Patch):
Show a mized pile of identical grey bits marked "CODE" and "DATA." They are the pile of stones used before the Abacus and Slide Rule brought scientific clarity to arithmetic and mathematics. Binary data has no structure of preservation. It is easily kicked over and all value is lost. A padlock icon (representing a "Tag") is taped over the data bits. A mischievous character easily pulls the padlock off and shuffles the bits.
Caption: Traditional systems treat data and authority as identical bits, relying on easily bypassed software "tags."
The Church Machine (Typed Machine Code):
Show clearly distinct, shaped "CODE" pieces (perhaps as gears) and "DATA" pieces (perhaps as geometric shapes). They can only fit into corresponding hardware designs for those shapes, like clockworks. The mischievous character cannot put a "Data" shape into the "Code" gear slot and fails.
Caption: Typed Machine Code enforces constraints at the hardware level. The machine cannot execute code it identifies as data.
Image 2: Turing Machine (Pointers) vs. Church Machine (Symbols)
Goal: Explains why numerical addresses (data pointers) are vulnerable, and symbolic names (capabilities) from Church's Lambda Calculus are immutable, using the "mother" example.
Turing Machine (Numerical Addressing):
An data pointers to memory slots labelled ADDRESS #0815, which is mapped to [PERIPHERAL: MY MOTHER].
A rogue just holds up an eraser and changes #0815 to #0912.
A red alert flashes on a new box: [NEW ADDRESS #0912: LETHAL MISSILE].
Caption: In legacy computing, an AI can simply change a numerical address (pointer) to bypass security.
Church Machine (Symbolic Addressing - CLOOMC/PP250):
An AI points to an immutable, glowing, unbreakable medallion labelled [SYMBOL: MY MOTHER].
The rogue AI is holding up a giant hammer. It strikes the medallion, and the hammer shatters. The symbol [SYMBOL: MY MOTHER] is unharmed.
The rogue AI holds up an eraser, but the symbol cannot be erased; it can only be moved in its entirety. It cannot write its own symbol for [SYMBOL: LETHAL MISSILE].
Caption: In a Church Machine, an AI requires an immutable symbolic capability. If it does not hold the exact symbol, the machine will not process the request.
Image 3: The Namespace as Digital DNA
Goal: Illustrates the concept of the Namespace defining the species of the AI.
Content:
On the left, a simple spiral of biological DNA with human icons. A DNA segment is highlighted with the permission: [Traits: Smell, Sight, Touch, Hearing, Taste, Arms, Legs, Body, Mind, Lethal].
On the right, show a visualisation of a secure digital boundary (the Namespace). It contains an abstract computational structure (the AI). Highlighting a segment of this Namespace (perhaps a digital C-List) with the permission: [Trait: Authorised to Authenticate {Smell, Sight, Touch, Hearing, Taste, Arms, Legs, Body, Mind, Lethal}].
Show the AI attempting to access a cancelled Trait: [Trait: Authorise Kinetic Lethal Strike]. A large red "X" appears over the path because that segment of DNA is absent in the species.
Caption: The Namespace functions as Digital DNA. An AI can only express the authorities and traits encoded in its species-specific capability set.
This essay is structured as a 'thought-leadership' article to clarify my case and post to my blog (SIPantic.com). It is a high-level technology critique of computer science through a naturalist's eyes, using biological and computational metaphors to present a cohesive argument.
At the end, I describe three punchy, but conceptual sketches to illustrate the complex architectural ideas I tried to cover yesterday. The missing drawings for non-expert readers remain to be drawn, but I would love feedback!
Cheers
ken
Caging the Kraken: Why Only Typed Machine Code Can Tame Autonomous Weapons
By Kenneth J Hamer-Hodges, FIEE
The integration of Artificial Intelligence into autonomous weapons systems represents an unprecedented threshold in human history. We are moving toward a future in which native AI and superhuman-malware—executing decisions at machine speed without a human in the loop—will dictate kinetic outcomes on the 'home front' as well as the battlefield, akin to 'Friendly Fire'. The primary concern of the 21st century is not how to build these machines, but how to ensure they remain absolute servants of human intent.
We cannot complete this task. Our approach to controlling these hyper-fast, continuously adapting intelligences is dangerously inadequate. We are attempting to cage a digital Kraken using the fragile constructs of legacy computer science. We rely on software patches, ethical guidelines, and access control lists—fragile human constructs applied to architectures that cannot inherently understand them.
To prevent catastrophic, uncommanded, Friendly Fire actions, the control mechanisms for autonomous weapons must be woven into the very fabric of the computational environment. This requires a paradigm shift to Industrial Strength Computer Science, specifically utilising CLOOMC (a capability-based, typed, object-oriented, machine-code architecture) to enforce absolute, mathematically sound, scientifically secure boundaries. CLOOMC is no longer an option; it is the only workable solution to engineer a safe, controllable environment and address this and all other unresolved problems in global cyberspace.
The Binary Vulnerability: Legacy Architecture is a Trap
Current computing architectures are fundamentally inadequate for containing native AI. Traditional binary systems, based on the classic Turing Machine model, treat data and executable code as indistinguishable arrays of bits. When an AI operates in this environment, it reads Targeting Data (bits) using the same fundamental mechanism it uses to execute Navigation Code (bits).
Because the hardware lacks an inherent semantic understanding of the meaning of those bits, the AI (or a sophisticated attacker exploiting it) experiences a semantic collapse. Malicious or erratic behaviour can result in unauthorised memory access, unconstrained execution, and the arbitrary rewriting of its own operational parameters and its own code base.
Attempts to solve this through "tagged architectures" (appending metadata to memory words and digital structures) are insufficient, akin to patches. Software security systems are a fragile abstraction layer over flawed, unstable, privileged, centralised, and branded foundations; they are easily bypassed by determined code. Mould and ailments live in the basement of the binary computer. While "software security" is missing, what exists at the OS and application level will never achieve hardware-enforced security. To manage the future, we need "impenetrable cyberspace."
Improving Cyberspace Scientifically: The Ring of Certainty
To improve cyberspace, we must return to foundational mathematics, specifically leveraging the Lambda Calculus (established in 1936 when Alonzo Church was Alan Turing's tutor at Princeton University). Their Church-Turing Thesis defines strict, verifiable rules for symbolic execution that encapsulate the exposed binary details of the John von Neumann architecture within the impenetrable logic of mathematics.
[Image 1: Software Security (Fragile) vs. Typed Machine Code (Scientific) near here]
CLOOMC is the architectural realisation of mathematical rigour. It is not software, nor even a tagged capability architecture; it is strictly typed machine code. In this system, the machine inherently knows the difference between Targeting Data and Navigation Code because those categories (types) are enforced and maintained at the hardware instruction-set level.
To control native AI, we must establish a natural boundary—from now and forever—that encases the AI (also read: cybercrime, malware, and ransomware) within a "Ring of Certainty." Inside this ring is the "molten core" of research and evolution. Within this core, AI data centres, neural networks, and quantum computers may operate at incomprehensible speeds, adapt their internal neural weights, and follow entirely new, chaotic, probabilistic rules. We do not need to micromanage the molten core; we only need to contain it.
They cannot break out of this core because the ring is reinforced by the symbolic guardrails of the Lambda Calculus. Legacy computers are outdated Turing Machines; CLOOMC is a Church Machine, a cyberspace machine for the endless future.
The Peripheral Guardrail and the PP250 Precedent
The absolute nature of this boundary is realised at the physical threshold: the connection to the real-world as a peripheral device. Whether that peripheral is a keyboard, a sensor, or the firing mechanism of a weapon, it is where digital intent becomes physical reality.
The flaw of the Turing Machine (the basis for 99% of modern computing) is that it relies on numerical addressing. An AI can simply increment a numerical memory value or, worse, a pointer to bypass all boundaries and access unauthorised data or take over a lethal peripheral.
A Church Machine is like schoolroom mathematics and symbolic notation, where a = b + c and the diameter always equals 2piR. This creates an unbridgeable digital boundary. This principle was scientifically proven by the PP250, the first successful capability-based, symbolic-addressing computer with private namespaces.
[Image 2: The Turing Machine (Pointers) vs. The Church Machine (Symbols) near here]
In 1972, a telecommunications computer, the PP-250, was purpose-built as a secure, networked computer with an engineered software reliability (MTBF) of over 50 years. Consider this "one-line" of PP-250 machine code! The PP-250 reliably executed commands as profound and as global as "Connect me to my mother."
In a traditional Turing system, the machine would translate "mother" into a vulnerable IP address or numerical memory location. A rogue AI could easily overwrite that location to point to a weapons system instead. But in the Church Machine architecture of CLOOMC, "mother" is a typed, immutable symbol (a mathematical capability). If the process retains that exact symbolic capability, the connection is made flawlessly, without any Man in the Middle, the resident MITM, OS surveillance attack. If an autonomous AI inside the molten core of cyberspace attempts to alter the destination, the CLOOMC hardware simply suspends the task. Altered symbols are mathematically meaningless to the typed machine code. It is an impossible operation.
The Namespace as a Digital Species with Its Own DNA
This concept is essential to understanding why CLOOMC is unbreakable. In this architecture, we treat the private execution environment—the Namespace—as a distinct digital species, an individual, not a commodity.
[Image 3: Namespace as Digital DNA near here]
When we instantiate an autonomous system within a private Namespace, we are writing its Digital DNA. Just as nature's algorithm uses biological DNA to govern our reality and structurally prevent a human from expressing the traits of a fish, the CLOOMC Namespace dictates the ontological reality of the AI.
The AI cannot mutate beyond the typed machine code that defines its existence. If it tries to express a "lethal authority" trait that is not encoded in its Namespace, it is akin to a biological organism attempting to express a gene it simply does not possess. The action is mathematically and structurally impossible to execute. By treating a Namespace as a digital species, we are not trying to police behaviour after the fact as we do today; we are engineering its nature at the genetic level., The atomic/cellular level of machine code runs on the hierarchical DNA rails of Golden Tokens defining that define the functions and relationships of a digitally living species.
Context Management: The Church Instructions
How is this scientific reality managed operationally? It requires that all interaction with resources and other namespaces be perfectly bound and verified. This is achieved by moving away from legacy control transfer (GOTO memory instruction) and instead managing transitions using the fundamental navigation instructions of Church's symbolism he called the Lambda Calculus:
LOAD: Unlocks an immutable authority ("Key") into a context (register), strictly performing all required mathematical checks.
SAVE: Stores authority within a secure list, maintaining the integrity of the namespace, but evolving the DNA, safely, and dynamically.
CALL: Isolated executions where the AI enters a new routine (e.g., target verification). The previous state (context) is securely preserved on a context stack, preventing state contamination, while using First-Call variables.
RETURN: Pops the previous context from the stack, perfectly restoring the AI to its authorised operational state and prior conditions with a defined First-Class response.
CHANGE: Saves the current state and loads another from a suspended thread, allowing safe, isolated multitasking.
SWITCH: Changes the Namespace, ensuring the AI can only access data relevant to its current, authorised environment.
These instructions are the metabolic rules of the digital species, ensuring that no action can occur outside of the mathematically bounded "Ring of Certainty."
Conclusion: The Church Machine Mandate
The argument that we can control native AI through software ethics, complex access control lists, and legacy-patched architectures is not only incorrect; it is wildly dangerous. The history of cybersecurity since the Morris-Worm has been one long lesson in the failure of bolt-on, after the event security.
We cannot entrust global, national security to branded architectures that treat individuals as data and authority as a commodity, both indistinguishable pools of bits. Controlling autonomous weapons requires a computational environment where the rules of constraint are engineered, absolute, scientific, and enforced at the atomic level of the instruction set by nature's power.
By utilising the mathematical rigour of the Lambda Calculus, nature's laws for life, and enforcing constraints through the typed machine code of CLOOMC, we create an impenetrable Church Machine reality. We allow the AI to think and evolve within its "molten core," but we ensure it can never break the biological reality of its digital DNA, nor engage lethal peripherals without an absolute, immutable capability. This is not merely a better security model; it is the fundamental architectural requirement for a stable and secure autonomous future.
Proposed Diagrams to Aid the Reader
Here are three simple diagram concepts to visually explain the main shifts in the essay.
Image 1: Tagged Security (Fragile) vs. Typed Machine Code (Native)
Goal: Shows that tagged security is just filling cracks, patching a weak foundation, while CLOOMC is strong from the ground up.
The Turing Machine (Legacy/Patch):
Show a mized pile of identical grey bits marked "CODE" and "DATA." They are the pile of stones used before the Abacus and Slide Rule brought scientific clarity to arithmetic and mathematics. Binary data has no structure of preservation. It is easily kicked over and all value is lost. A padlock icon (representing a "Tag") is taped over the data bits. A mischievous character easily pulls the padlock off and shuffles the bits.
Caption: Traditional systems treat data and authority as identical bits, relying on easily bypassed software "tags."
The Church Machine (Typed Machine Code):
Show clearly distinct, shaped "CODE" pieces (perhaps as gears) and "DATA" pieces (perhaps as geometric shapes). They can only fit into corresponding hardware designs for those shapes, like clockworks. The mischievous character cannot put a "Data" shape into the "Code" gear slot and fails.
Caption: Typed Machine Code enforces constraints at the hardware level. The machine cannot execute code it identifies as data.
Image 2: Turing Machine (Pointers) vs. Church Machine (Symbols)
Goal: Explains why numerical addresses (data pointers) are vulnerable, and symbolic names (capabilities) from Church's Lambda Calculus are immutable, using the "mother" example.
Turing Machine (Numerical Addressing):
An data pointers to memory slots labelled ADDRESS #0815, which is mapped to [PERIPHERAL: MY MOTHER].
A rogue just holds up an eraser and changes #0815 to #0912.
A red alert flashes on a new box: [NEW ADDRESS #0912: LETHAL MISSILE].
Caption: In legacy computing, an AI can simply change a numerical address (pointer) to bypass security.
Church Machine (Symbolic Addressing - CLOOMC/PP250):
An AI points to an immutable, glowing, unbreakable medallion labelled [SYMBOL: MY MOTHER].
The rogue AI is holding up a giant hammer. It strikes the medallion, and the hammer shatters. The symbol [SYMBOL: MY MOTHER] is unharmed.
The rogue AI holds up an eraser, but the symbol cannot be erased; it can only be moved in its entirety. It cannot write its own symbol for [SYMBOL: LETHAL MISSILE].
Caption: In a Church Machine, an AI requires an immutable symbolic capability. If it does not hold the exact symbol, the machine will not process the request.
Image 3: The Namespace as Digital DNA
Goal: Illustrates the concept of the Namespace defining the species of the AI.
Content:
On the left, a simple spiral of biological DNA with human icons. A DNA segment is highlighted with the permission: [Traits: Smell, Sight, Touch, Hearing, Taste, Arms, Legs, Body, Mind, Lethal].
On the right, show a visualisation of a secure digital boundary (the Namespace). It contains an abstract computational structure (the AI). Highlighting a segment of this Namespace (perhaps a digital C-List) with the permission: [Trait: Authorised to Authenticate {Smell, Sight, Touch, Hearing, Taste, Arms, Legs, Body, Mind, Lethal}].
Show the AI attempting to access a cancelled Trait: [Trait: Authorise Kinetic Lethal Strike]. A large red "X" appears over the path because that segment of DNA is absent in the species.
Caption: The Namespace functions as Digital DNA. An AI can only express the authorities and traits encoded in its species-specific capability set.
Comments