Current software development using AI coding agents rests on a technological paradox. We use coding agents based on transformer architectures with billions of parameters to write code in languages like Python, Java, or C++. These languages emerged decades in the past to compensate for the cognitive limits of the human brain. They have a visual structure, use natural language terms, and rely on a syntax that places readability above machine efficiency. For a large language model, this ballast is noise. Processing brackets, indentations, and redundant definitions consumes space in the context window and limits the amount of logic a model can grasp in a single instance.
The next step for coding agents lies in the decoupling from human syntax. We face the transition to software generation without human witnesses.
Human code is fragile. Changing a line in a project with ten thousand lines of code risks unpredictable errors in distant places. This effect results from the entanglement of states in imperative or object-oriented languages. LLMs fail at large projects to track these dependencies. A model sees the code as a text desert while the actual logic lies hidden under layers of abstractions.
The solution requires the renunciation of text files as a storage medium for logic. Classic automata theory moves into the center. If programming is a system of provable states, side effects disappear. Every function becomes a mathematical graph. The machine writes no texts; it constructs verifiable logic structures.
From Self-Replication to the Interaction Graph
The idea to grasp logic as space leads to John von Neumann. He, together with Stanisław Ulam, developed cellular automata in the 1940s [1]. His goal was the mathematical description of machines with the capacity for self-replication. He proved that a grid of simple cells, which change state based on neighbors, can map a universal computing machine. Von Neumann’s vision was a logic fabric in which hardware and software merge into a unit. He laid the foundation for programming with more robustness than current approaches.
In 1990, Yves Lafont evolved this concept by introducing Interaction Nets [2]. While von Neumann’s automata were tied to a rigid, static grid, Lafont dissolved the logic into flexible, dynamic graphs. Interaction Nets rest on Linear Logic, a refinement of proof theory introduced by Jean-Yves Girard in 1987 [3]. Linear logic treats hypotheses as resources that are consumed, making it ideal for modeling computer memory and state.
Interaction Nets represent a visual form of the Lambda Calculus but with a critical difference: they are inherently parallel. When two nodes (logic nodes) meet at their principal ports, they interact according to a fixed rule and rewrite themselves into a new part of the graph. The advantage for AI is clear: Interaction Nets are Confluent. This means that regardless of the order in which you apply the rules, the system always converges to the same result. Because every interaction is local and atomic, they are free of side effects; no global state exists for the model to monitor.
Nela: The Implementation of an LLM-Native Architecture
This theoretical line finds a practical demonstration in the implementation of nela-lang. Nela stands for Net-based Executable Logic Automaton. It serves as an exemplary model to show how these concepts translate into a target architecture for coding agents. Code in this framework exists as a field of logic cells and interaction points. Since the system rests on the principles of Interaction Nets, every change remains local and isolated. An LLM modifies configurations within the graph. Unforeseen errors in distant system parts are systemically mitigated. The structure of the system forces formal correctness.
An authentication module in Nela exists as an interaction within the graph rather than lines of text. A data node meets a reference node at an interaction point. If their patterns match according to the transformation rules, they rewrite into a status node that grants access. This implementation demonstrates a fundamental shift: the AI does not author instructions; it configures the initial state and rule-set of the logic automaton.
The Migration of the Global Knowledge Base
The transition to an architecture like Nela requires no manual recoding of existing software. The process provides for a massive, automated migration. Specialized AI agents capture the semantic content of repositories on GitHub and extract the intention behind the code. An existing Python script is a decomposition into logical building blocks and not a word-for-word translation.
This process is a semantic reconstruction. The AI understands the purpose of an algorithm and rebuilds it in the formal Nela logic. Once this corpus exists, coder models train on this pure logic language. They learn logic in its purest form without the detour through human grammar. The model develops a deeper understanding of system architectures as ambiguities cease their distraction.
Architects and Constructors
The architecture of future systems provides for a separation of responsibilities.
The Translator (Architect): A model (agent) that acts as the interface. It communicates with humans in natural language. It clarifies requirements, handles edge cases, and creates a formal specification of the desired outcome. It speaks “Human” and understands “Intent.”
The Logic Processor (Constructor): A specialized model (agent) that operates within the machine-native language. It takes the specification from the Architect and builds the corresponding NELA graph.
This constructor requires no knowledge of human grammar. It is a logic engine. It constructs, optimizes, and performs formal verification of the code. Systemic prevention of hallucinations occurs because the constructor acts within a closed mathematical framework. Invalid code is impossible in this environment. The “logic nodes” of the graph either connect according to the rules, or they do not connect at all.
The Path to the Agentic Kernel
The convergence of these technologies leads to the end of the classic operating system. Current systems like Windows or Linux mediate between static software and hardware. In an AI-native environment, an Agentic Kernel replaces this layer. Resources are managed via dynamic logic agents based on automata in place of rigid drivers and APIs.
Applications disappear. If a user formulates a goal, the AI generates the necessary logic structure in real time, executes it, and dissolves it after completion of the task. The computer becomes an intelligence interface in which the barrier between programming and execution collapses. This realizes the vision of the ship computer from Star Trek. The complexity remains invisible to humans.
The transition to something like NELA and the Agentic Kernel does not grant immunity to the fundamental laws of computation. The Halting Problem, formulated by Alan Turing in 1936 [4], proves that no general algorithm exists to determine whether an arbitrary program will stop or run forever. In a future where AI agents construct and execute logic in real-time, this undecidability poses a systemic risk.
To address this, the design of the Constructor model must navigate the trade-off between expressive power and totality. If the NELA environment is Turing complete, it can compute any function, but it remains subject to the Halting Problem. However, many practical tasks do not require the full power of unrestricted recursion.
Research into Total Functional Programming [5] suggests a solution. By restricting the AI to specific fragments of logic—such as those defined in Gödel’s System T or the Calculus of Constructions—the system can ensure that every program is Strongly Normalizing. A system is Strongly Normalizing if every possible sequence of interaction rules leads to a final, reduced state. In this scenario, the Architect model acts as a formal gatekeeper. It refuses to pass specifications to the Constructor that cannot be proven to terminate. This shifts the Halting Problem from a runtime disaster to a compile-time constraint.
The use of Linear Logic within NELA provides an additional defense against the Halting Problem. In standard imperative programming, a program can leak resources by creating infinite loops that consume memory without bound. In the Interaction Net framework, nodes are treated as finite resources. Every interaction consumes the parent nodes to produce the child nodes.
While the NELA structure allows for formal verification, Rice’s Theorem [6] reminds us that all non-trivial semantic properties of a program are undecidable. The Architect cannot know everything about what the logic will do before it runs, still in this future scenario, the Halting Problem serves as the primary justification for the Architect-Constructor split. The Architect must use Heuristic Reasoning to predict the behavior of the logic, while the Constructor uses Formal Synthesis to ensure it follows the rules. The Halting Problem becomes a boundary for the Agentic Kernel. The machines of the future will not avoid the Halting Problem through superior intelligence; they might avoid it by operating within “Total Logic” zones where the risk of the infinite is potentially mathematically excluded.
The renunciation of human readability is the price for a software generation with a mathematical guarantee of stability. In a world in which AI systems control critical infrastructures, formal security is a necessity. In the end, the human understanding of the source code is irrelevant; the provable correctness of the machine logic is the only factor.
References and Technical Context
[Bibtex]
@book{VonNeumann1966,
author = {von Neumann, John},
title = {{Theory of Self-Reproducing Automata}},
editor = {Burks, Arthur W.},
publisher = {University of Illinois Press},
year = {1966}
}![[doi]](https://www.thebigdatablog.com/wp-content/plugins/papercite-master/img/external.png){kind=small}
Y. Lafont, “Interaction Nets,” in Proceedings of the 17th acm sigplan-sigact symposium on principles of programming languages, 1990, p. 95–108. [Bibtex]
@inproceedings{Lafont1990,
author = {Lafont, Yves},
title = {{Interaction Nets}},
booktitle = {Proceedings of the 17th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages},
year = {1990},
pages = {95--108},
publisher = {ACM},
doi = {10.1145/96709.96718}
}[Bibtex]
@article{Girard1987,
author = {Girard, Jean-Yves},
title = {{Linear Logic}},
journal = {Theoretical Computer Science},
year = {1987},
volume = {50},
number = {1},
pages = {1--101},
doi = {10.1016/0304-3975(87)90045-4}
}[Bibtex]
@article{Turing1936,
author = {Turing, Alan M.},
title = {{On Computable Numbers, with an Application to the Entscheidungsproblem}},
journal = {Proceedings of the London Mathematical Society},
year = {1936},
volume = {s2-42},
number = {1},
pages = {230--265},
doi = {10.1112/plms/s2-42.1.230}
}[Bibtex]
@article{Turner2004,
author = {Turner, David A.},
title = {{Total Functional Programming}},
journal = {Journal of Universal Computer Science},
year = {2004},
volume = {10},
number = {7},
pages = {751--768},
doi = {10.3217/jucs-010-07-0751}
}[Bibtex]
@article{Rice1953,
author = {Rice, Henry Gordon},
title = {{Classes of Recursively Enumerable Sets and Their Decision Problems}},
journal = {Transactions of the American Mathematical Society},
year = {1953},
volume = {74},
number = {2},
pages = {358--366},
doi = {10.2307/1990888}
}