What is SoulCore?
A runtime that transforms existing AI models into cognitive modules — not replacing them, but giving them a new role.
Continuous Runtime
Not request-response. Not cyclic. SoulCore runs continuously, like an operating system — state updates, events, decisions, execution, continue.
Runtime State
Not memory. Not a prompt. Not chat history. The entire system operating state — persistent, recoverable, traceable.
Multi-Core Intelligence
Not one large model. Multiple specialized cores — each independently developable, trainable, replaceable. They work in parallel, coordinating through a shared runtime state.
Replaceable Components
Existing AI models become cognitive modules inside a larger runtime — not the runtime itself.
Horizontal Scalability
One intelligence from multiple cores. Multiple nodes, shared state space — distributed intelligence, not just bigger GPUs.
Graceful Degradation
If one Core fails, the system does not collapse. It degrades gracefully instead of failing completely.
Deterministic Decision Layer
From the same state, the same decision is made. Communication is natural, but decisions are reproducible.
No Token Limit
Persistent state instead of context windows. No upper limit on the amount of information that can be processed.
Continuous Execution
Every question is not a new life. The system runs continuously — state updates, events, reasoning chain, execution.
Language Independence
The system does not think in language internally. The Language Runtime only translates — works in any language, the internal operation is the same.
Separation of Responsibilities
Each component has a single responsibility. The Language Runtime does not decide. The Runtime Kernel does not think. The Core does not generate language.
Distributed Intelligence
Operates across multiple nodes through a shared state space. Intelligence is not in one place — distributed, yet coordinated.
Event-Driven Activation
Not every core runs continuously. Only the one that is needed activates — energy and compute efficiency.
Rollback and State Resume
If a core errs, the system performs an atomic rollback. The full state can be dumped — it resumes where it left off.
Thinks on the Problem
An eight-step cognitive process: the problem representation is built first; language is only the input and output form.
System Architecture
SoulCore is a multi-layered AI runtime that separates language processing, cognitive decision-making, state management, memory, and execution.
CLICK TO ZOOM
The system consists of 8 separate layers: Language Runtime, Cognitive Core Layer, Multi-Core Architecture, Runtime Kernel, Runtime State, Memory Layer, Goal Layer, and Execution Layer. Each component has a single responsibility, resulting in a modular, scalable, and extensible system.
Traditional AI vs SoulCore
| Traditional AI | SoulCore | |
|---|---|---|
| Egyetlen modell | → | Multiple cognitive cores |
| Prompt | → | Runtime State |
| Context Window | → | Persistent State |
| Session | → | Continuous Runtime |
| Monolitikus | → | Moduláris |
| Language-centric | → | State-centric |
| Restart every prompt | → | Continuous execution |
| Token limit (context window) | → | No token limit (persistent state) |
| Scaling: bigger model / more GPUs | → | Horizontal scaling, shared state space |
| Component replacement: full model swap | → | Replaceable cores, the Runtime stays |
| Memory and goals inside the model | → | Separate memory and goal system |
| Thinks on the answer | → | Thinks on the problem (8-step process) |
| Keeps generating from a bad context | → | Rollback and fault isolation |
| Dynamic memory within the session | → | Full state dump, resumes where it left off |
| All models run continuously | → | Event-driven activation (only what is needed runs) |
| No self-check | → | Self-check, can reject its own answer |
| Variation on every prompt | → | Deterministic decision from the same state |
Why is multi-core architecture better?
Not just because there are more cores. But because each is specialized, independently developable, independently trainable, independently replaceable, works in parallel, and coordinates through a shared Runtime State.
This is closer to an operating system than a chatbot.
Continuous execution, persistent state
The system does not restart with every query. It runs continuously, its state is persistent and recoverable. The system picks up exactly where it left off — even days later.
Structured thinking process
Thinking is not a single moment, but an eight-step, structured process. Every step is planned, every decision is traceable.
Information → Processing → Understanding → Intent → Reflection → Ideation → Decision → Response
What does the project NOT claim?
AGI
The project does not claim to create AGI.
Consciousness
The project does not claim the system is conscious.
Human Thinking
The project does not claim the system thinks in a human sense.
This is an architectural research direction that separates language, state, and execution into separate layers.
Where does development stand?
The vision and the current implementation are separate things. This block shows the actual status — what is complete and what is in progress.
Completed components
- Language Runtime Encoder (300M)
- Language Runtime Decoder (300M)
- StateBundle (768 dim)
- Tokenizer
- Hybrid Core V8 (200–300M)
- Training Pipeline (69 files)
Partial / next
- Integration — wiring the components together
- Testing — Language Runtime and Hybrid Core
- Knowledge Store — partial (7 modules)
- API — no external access yet
Development environment
- 2× RTX 5060 Ti — 32 GB VRAM
- 32+ GB RAM
- ~50 GB storage
- Under development — research phase
Nothing new needs to be built — the code exists. The next step is integration, testing, and the API.
Downloads
Documents about the SoulCore architecture, research materials and specifications.
SoulCore V4 — Specification
A concise summary of the SoulCore V4 architecture: Language Runtime (Encoder/Decoder 300M), StateBundle 768, Hybrid Core V8 and the 8-layer system structure. TXT format.
Ready to explore?
Dive into the SoulCore architecture, read the latest research results, or download the specification.