ALCOG

ALCOG is an experimental self-modifying cognitive runtime for Linux x86-64.

It is not a Transformer language model. Instead of separating executable code, learned state, memory, and language associations into independent components, ALCOG represents them through a shared mutable relational structure.

The current release is intended as a research prototype.

Overview

ALCOG uses a homogeneous stream of relational cells as its main cognitive substrate.

The same structure can participate in several roles depending on how it is interpreted:

• associative memory
• learned language structure
• executable behavior
• activation state
• evidence and reliability
• persistent learned state

Learning changes this structure directly.

There is no separate memory database or model-weight file.

The current executable is approximately 251 KiB and includes the native runtime and persistent cognitive structure in a single file.

Current capabilities

The current version experimentally supports:

• Korean and English input
• basic conversational expressions
• colloquial and abbreviated expressions
• some slang and informal language
• context-dependent interpretation
• ambiguous word senses
• omitted arguments and conversational continuation
• persistent online learning
• associative pattern completion
• basic file-related computer operations
• direct interaction with Linux through system calls

Examples of currently supported conversational patterns include:

이 파일 단어 몇 개야
그럼 줄 수는?
그거 해시는?
아까 거 다시
그거 잘 됐어?

count the words in this file
what about the line count?
what about the hash?
do that again
did that work?

The system also contains experimental grounding for informal expressions such as Korean abbreviations and colloquial forms, as well as common informal English expressions.

These capabilities are limited and should not be interpreted as general human-level language competence.

Architecture

ALCOG does not maintain conventional boundaries such as:

program
model weights
memory database
language database
bytecode

as separate canonical representations.

Its cognitive state is stored as a single relational cell stream.

A cell may participate simultaneously in several interpretations, including:

relation
memory
activation path
procedure
language association
reliability
learning state

Recent contextual activity can remain as a decaying activation trace. New input interacts with this trace through associative propagation and competition, allowing incomplete expressions or contextual references to recover previously active structures.

The architecture is influenced by the design principles of ALMANAL, particularly reuse of existing relations, shared identity, reduction of duplicated representations, and structural refactoring.

Language learning

ALCOG currently focuses on Korean and English.

Language is not represented as a fixed one-to-one dictionary.

For example, one expression may activate multiple candidate meanings:

memory
├─ computer memory
└─ remembered experience

and multiple expressions may converge on related structures:

file
파일

Context and surrounding activation are used to select among competing interpretations.

The long-term design goal is for linguistic forms to acquire meaning through repeated association with non-linguistic structures, actions, observations, and other contextual evidence.

Training and teacher data

The current Korean and English language structure was primarily developed through direct interactive teaching by GPT-5.6 Sol Chat during the development of ALCOG.

This teaching included:

• Korean and English vocabulary and expressions
• conversational variations
• colloquial speech
• abbreviations
• slang and informal expressions
• ambiguous and polysemous expressions
• contrasting examples
• contextual references and omission
• paraphrases
• positive and negative examples
• semantic distinctions
• computer-related language grounded in actual actions and outcomes

The teaching process was iterative. ALCOG was tested on previously unseen variations, observed failures were analyzed, and additional contrasting experiences were provided where necessary.

The goal was not to copy the teacher's output verbatim, but to use generated linguistic experiences to modify ALCOG's own relational structure.

A smaller amount of language information derived from Qwen 3.0 was also used during development as auxiliary training material and weak candidate priors.

Qwen-derived associations were not treated as authoritative semantic ground truth. Low-quality or ambiguous candidates were discarded, and candidate relations could be weakened, replaced, or overridden by direct grounding and later evidence.

In simplified form:

GPT-5.6 Sol Chat
→ primary interactive language teacher

Qwen 3.0 data
→ auxiliary candidate priors

computer environment and observed outcomes
→ grounding and verification

ALCOG
→ persistent relational learning

Neither GPT-5.6 Sol Chat nor Qwen is required at runtime.

The released ALCOG executable operates independently and does not require access to either model or their runtimes.

Online learning

ALCOG can modify its own persistent relational structure while running.

Successful experiences may strengthen relevant connections, while newly grounded expressions may create new relations.

The modified state is stored back into the ALCOG executable itself rather than into a separate memory database.

Conceptually:

experience
→ activation
→ interpretation/action
→ outcome
→ structural update
→ persistent ALCOG state

This mechanism is experimental.

Runtime dependencies

The current release targets:

Linux
x86-64

The executable is statically linked and does not require:

Python
PyTorch
llama.cpp
libstdc++
SQLite
a separate model runtime
a separate memory database

The remaining platform boundary is the x86-64 CPU and Linux system-call ABI.

Integrity

The executable includes internal structural integrity checks.

Run:

chmod +x ALCOG
./ALCOG check

A valid current image should report checks including:

SELF=PASS
ONE_CELL_STREAM=PASS
SECTIONS=0
SOURCE_COPY=0
BYTECODE_COPY=0
MEMORY_DB=0
RUNTIME_DEPS=0

Status

ALCOG is an experimental research prototype.

It is currently much less capable at general language generation and broad world knowledge than modern general-purpose language models.

Its purpose is not to claim better general language performance than Transformer-based systems.

The project instead explores questions such as:

• Can executable behavior and learned memory share the same representation?
• Can persistent learning occur directly inside a small executable cognitive structure?
• Can language grounding, context recovery, and action selection emerge from the same relational mechanisms?
• How much learned behavior can be represented while minimizing duplicated structure?
• Can increasing experience lead to structural reuse rather than proportional storage growth?

These questions remain experimental.

Limitations

Current limitations include:

• limited vocabulary and general knowledge
• limited free-form language generation
• incomplete grammatical coverage
• incomplete handling of long conversations
• limited non-computer world grounding
• no claim of compatibility with standard LLM benchmarks
• Linux x86-64 only
• experimental self-modification behavior

Do not use the current version for safety-critical applications.

License

ALCOG is released under the Apache License 2.0.

See LICENSE for the full license text.

My github link : https://github.com/aguun1998/Almanal