Why Sekura Noda, Sekura JS, Reganta OS, and Memora8 are designed as one system.
Most AI systems today are added on top of existing software.
We connect a language model to databases, documents, APIs, and applications.
This approach is useful.
But it leaves an important question unanswered:
Is the current computing stack designed for a world where AI actively participates in creating and using knowledge?
I started exploring this question through four connected projects:
- Sekura Noda — a knowledge system for experts and AI;
- Sekura JS — a programming language designed around a different execution model;
- Reganta OS — a micro operating system based on modules, pages, and streams;
- Memora8 — an experimental processor architecture organized around memory.
They are different layers of the same idea:
Important decisions should remain explicit, understandable, and controllable by humans.
The problem is not only intelligence
Modern AI models are extremely capable.
They can write code, analyze information, explain concepts, and generate solutions.
But intelligence alone does not solve a fundamental problem:
AI does not automatically know what is important for a specific person, company, or system.
An expert has years of accumulated knowledge:
- professional decisions;
- rules and exceptions;
- reasons behind choices;
- hidden constraints;
- understanding of context.
This knowledge usually exists in:
- people’s experience;
- conversations;
- documents;
- source code;
- personal memory.
The problem is not that information does not exist.
The problem is that it is not organized as a usable system.
The first layer: knowledge
This is where Sekura Noda begins.
Sekura Noda helps experts use AI to accumulate, improve, and monetize their unique expertise.
Noda creates a layer between experts and AI where important knowledge can be captured, reviewed, connected, and reused.
The expert decides:
- what knowledge is correct;
- what decisions are accepted;
- which rules apply;
- what context AI can use.
AI helps apply knowledge.
It does not become the owner of knowledge.
This distinction is important.
A model can generate an answer.
Only a person can decide whether that answer represents the expertise of an organization.
The second layer: programming
If knowledge becomes an explicit system, programming also needs to evolve.
Traditional programming languages were created around existing computer models.
They usually describe:
- instructions;
- memory addresses;
- processes;
- files;
- operating-system services.
Sekura JS explores a different direction.
A language should reflect the system it runs on.
Instead of hiding important relationships, it should help describe:
- modules;
- data flow;
- resource ownership;
- system contracts.
The goal is not to create more syntax.
The goal is to make the architecture visible.
The third layer: execution
A programming model requires an execution model.
This is the role of Reganta OS.
Reganta explores a system where software is organized around modules rather than traditional applications.
Modules communicate through explicit streams and work with defined data units.
The operating system focuses on orchestration:
- connecting components;
- controlling access;
- moving data;
- coordinating execution.
The goal is a smaller and more understandable system.
The fourth layer: hardware
At the lowest level is Memora8.
Most processors are organized around the CPU.
The CPU executes instructions, and memory supports it.
Memora8 explores another perspective:
What if computation was organized around memory pages?
In this model:
- pages exist independently;
- processors receive temporary ownership;
- computation happens where data is processed;
- ownership and access become explicit.
The processor becomes a worker acting on data rather than the permanent center of the system.
One connected stack
The relationship between the projects:
Human expertise
↓
Sekura Noda
↓
Programming model
↓
Sekura JS
↓
Execution model
↓
Reganta OS
↓
Hardware model
↓
Memora8
Each layer supports the next.
Noda preserves the knowledge behind the architecture.
Sekura JS describes programs using the system concepts.
Reganta OS executes those programs.
Memora8 provides the hardware foundation.
Why build the whole stack?
Creating one application would be much easier.
But many problems appear because each layer of computing was designed separately.
Applications assume operating systems.
Operating systems assume processors.
Programming languages assume execution models.
AI systems are now added on top of all of them.
Perhaps the next generation of computing requires a different approach:
not only smarter models,
but systems where knowledge, software, execution, and hardware share the same principles.
The human remains responsible
AI changes the speed of development.
A single person can explore ideas that previously required large teams.
But speed creates a new challenge:
How do we preserve understanding?
How do we ensure that generated code, generated designs, and generated decisions remain connected to human intent?
This is why the foundation of this stack is not the processor.
It is knowledge.
AI can help create.
Humans must decide what becomes part of the system.
That is the idea behind Sekura Noda and the larger Sekura architecture.
AI was used for English translation and editorial refinement. The ideas, architecture, and technical decisions described in this article are the author’s own.
Top comments (0)