Vi: An AI Organism Built Without a Rented LLM

Vi: An AI Organism Built Without a Rented LLM

Most systems we currently call "AI agents" still rent their intelligence.

We wrap a prompt, connect some tools, build an execution loop, and send everything to a GPT-class model through an API.

The vendor owns the weights.

The application owns the surrounding code.

And the agent's active state often exists only as long as the process and its persistence layer keep it alive.

Vi takes a very different architectural bet.

Instead of placing a rented LLM at the centre of the system, the project attempts to build an AI organism with its own neural weights, native learning, persistent memory, internal state, motivation, speech system, and sleep cycle. (hackernoon.com)

The author has documented the architecture publicly, including the neural components, memory systems, training pipeline, autonomy loops and speech subsystem.

The interesting question is not whether Vi is already "alive".

It isn't.

The interesting question is:

Can an AI system maintain learning, memory, internal state and behaviour beyond the lifetime of a single request?

That is the experiment.

---

Weights, not recipes

A simple version of "sovereign AI" can be little more than a collection of rules:

if query.startswith("what is"):
    speak()

if confidence >= 0.55:
    act()

There is nothing inherently wrong with rules.

But if the programmer decides every important behavioural boundary, the system's apparent intelligence is still largely encoded in those rules.

Vi tries to move more of that decision-making into learned or dynamically generated signals.

For example, its live gating logic compares competing measurements:

# vi/brain/cognition/live_gate.py
def louder(a, b):
    return float(a) >= float(b)

The important idea is not the function itself.

It is that the decision is based on the relative strength of signals rather than a single author-selected constant such as:

if curiosity >= 0.42:
    speak()

The system is therefore allowed to remain silent when the relevant signals do not win the competition.

That is a small implementation detail with a larger architectural implication:

silence can be an output of the system rather than a missing branch in the code.

---

Time outside the request

Most LLM applications operate on a very simple clock:

prompt
  ↓
model
  ↓
response
  ↓
request ends

Everything that needs to persist has to be explicitly stored somewhere else.

Vi is designed around several different timescales.

A moment

One cognitive_pass processes sensory input and produces a workspace representation.

A turn

The interaction can move through stages such as:

preamble
   ↓
recall
   ↓
compose
   ↓
polish
   ↓
credit

Hours

Motives can persist and grow when an unresolved pattern continues to recur.

A night

The sleep system performs hippocampal replay while new encoding is disabled.

This distinction matters.

If these mechanisms were simply another wrapper around a GPT API, they would not fundamentally change the ownership model.

The experiment instead asks whether the internal state itself can continue to evolve when there is no active request.

---

Two maps, not one

One of the more interesting architectural details is that the system separates the neural processing pass from the larger organism.

The main brain processing function contains components such as sensory encoding, hippocampal processing, attention, PFC processing and workspace formation:

# vi/brain/neural/brain_model.py
sensory = self._run_encode(
    input_vec,
    modality=modality,
    intensity=intensity
)

if formation_on:
    ca1_out = self.hippocampal_formation.process(
        sensory,
        encoding=not self._frozen_encoding
    )

    hippo_input = (
        self.hippocampal_formation
        .blend_with_recall(sensory, ca1_out)
    )

h_state = self.hippocampus.forward(
    hippo_input,
    self.memory_bank.hippocampus_hidden
)

# attention, PFC GRU, lateral competition,
# spikes → workspace

The larger organism then adds other systems around that pass:

Organism
│
├── biography
├── motive
├── affect
├── inner speech
├── Go/NoGo
├── cerebellum
├── glia
├── memory
├── autonomy
└── sleep

The package layout mirrors that split. The primary write-up maps it as vi/brain/ — neural tissue, cognition, memory, learning, autonomy, perception, sleep, and the regions/ mixins that assemble the organism — with the C++ LiveNet speech trainer living outside the Python brain in native/vi_train/. The earlier DEV version (Sept 3) describes the same tree: one package thinks, clients are doors rather than a second brain.

vi/brain/
├── neural/       tissue of a moment
├── cognition/    thought, speech, will, affect, motive
├── memory/       vectors, shelf, graph, biography, episodes
├── learning/     dialogue, books, dictionary, native SGD
├── autonomy/     background tick, goals
├── perception/   vision, audio, glyphs
├── sleep/        consolidation, replay
└── regions/      mixins that assemble the organism

native/vi_train/   C++ LiveNet speech

This distinction is important because some components have similar anatomical names without representing the same computational structure.

A GRU component called hippocampus is not automatically the same thing as the DG–CA3–CA1 hippocampal formation.

Likewise, a Cerebellum under one part of the codebase is not necessarily the same implementation as the cerebellar cortex represented elsewhere.

The lesson is simple:

Names are not architecture.

If two components are merged merely because they share an anatomical label, the resulting system may look more biologically inspired on paper while becoming less coherent in practice.

---

Anatomy from the ground up

The architecture is deliberately brain-shaped.

The neural stack includes components corresponding to association cortex, entorhinal grid cells, dentate gyrus, CA3, CA1, brainstem arousal, prefrontal processing and a global workspace.

The implementation includes details such as:

• 60° entorhinal grid structure
• √2 scale progression
• DG k-winner pattern selection
• CA3 pattern completion
• a bounded CA3 representation
• CA1 novelty signalling
• inverted-U arousal gain
• a dense workspace representation

The important question is not whether these names resemble biological neuroscience.

It is whether the components actually influence one another in a closed computational loop.

Two details are particularly interesting.

Novelty influences memory strength

The formation path runs Entorhinal → Dentate Gyrus → CA3 → CA1: DG separates patterns, CA3 completes them, and CA1 compares the completed memory against the current state to emit a novelty signal. The hippocampal memory write uses a signal conceptually represented as (primary):

store_strength = encode_w * novelty * emotional_gain

This means storage is influenced not only by whether something was encoded, but also by novelty and the organism's current affective state.

The same event can therefore produce different storage strength under different internal conditions.

That is conceptually richer than:

sentence
   ↓
embedding
   ↓
vector database

It also creates a testable hypothesis:

Does novelty actually change the resulting memory behaviour?

That is something the system has to demonstrate experimentally.

Echoes can receive zero learning rate

The plasticity system also attempts to prevent certain forms of self-reinforcement.

When provenance indicates an echo, word salad, or output that is not considered the organism's own voice, the learning rate can be reduced to zero. The primary shows the gate explicitly:

# vi/brain/neural/plasticity_gate.py
if provenance.is_echo or provenance.salad or not provenance.is_own_voice:
    return 0.0, report

Otherwise, learning can scale with firing discord.

Conceptually:

Own output
   ↓
discord
   ↓
learning signal

Echo / word salad
   ↓
lr = 0

This is an interesting idea for any autonomous learning system.

An agent that continuously trains on its own generated output can amplify its own mistakes.

Preventing some classes of self-generated material from reinforcing the model is one possible defence against that feedback loop.

---

Thought is not speech

Vi also separates thought from speech.

ThoughtEncoder is a GRU whose initial hidden state comes from the workspace representation.

That produces an internal thought representation which is then passed to the speech system.

The architecture therefore looks roughly like:

Brain
  │
  ├── brain context
  │
  └── thought context
           │
           ▼
         Broca
           │
           ▼
        Speech

The speech subsystem is implemented separately as a C++ LiveNet.

This separation is important.

Generating an internal representation of what the system wants to communicate is not necessarily the same task as converting that representation into output tokens.

The original write-up describes an interesting failure mode: interrupting the speech model's saved state can still produce token output, but those tokens may not form meaningful words.

That is actually a useful architectural demonstration.

The system distinguishes between:

what to say

and

how to say it.

That boundary is worth preserving in many agent architectures, even when the implementation has nothing to do with neuroscience.

---

Memory that is not a prompt

One of the biggest differences between Vi and a conventional LLM application is the treatment of memory.

Storage itself is split across organs rather than one store: a vector index, a SQLite shelf, a graph, a dictionary, a biography, and episodic records — the six stores described in the primary write-up.

Recall operates on whole utterances rather than simply treating them as bags of keywords.

The system also has a metacognitive distinction between:

know
partial
unknown

The intention is to avoid turning every successful retrieval into a claim of knowledge.

That distinction matters.

Suppose an agent searches a book and finds a relevant passage.

There are at least two different states:

"I found information about X."

and:

"I know X."

Those are not necessarily equivalent.

Vi explicitly tries to keep book and wiki locators from becoming automatic evidence that the organism "knows" something.

Again, this is an experimental mechanism rather than proof of machine metacognition.

But it is an interesting design question.

---

Will, affect, and motives that persist

Vi also attempts to model behaviour over longer timescales.

Action selection uses a basal-ganglia-inspired Go/NoGo loop.

Conceptually:

GPi
 ↓
inhibition

D1
 ↓
release selected action

D2
 ↓
stronger inhibition

Speech is also influenced by competing internal signals such as pain, hunger and frustration, together with curiosity or attraction.

More importantly, a motive can persist when a topic or objective remains unresolved.

A closed topic can trigger:

motive.resolve(...)

The idea is not that the system has human desires.

The experiment is asking whether an internal objective can persist beyond a single interaction.

That is a much more measurable claim.

---

Learning without a rented LLM

This is perhaps the most important distinction from the usual "local AI" conversation.

Running an open-weight LLM locally is still fundamentally:

local inference
+
someone else's pretrained weights

Vi goes further.

The project includes its own neural components and a native training pipeline.

The system uses native learning mechanisms, including SGD-based training, rather than relying on an external LLM as the central cognitive engine.

That does not mean the resulting intelligence is comparable to a frontier LLM.

It is not.

The point is different.

The experiment asks:

Can an AI system own its own learning machinery instead of renting its core intelligence through an API?

That is where Vi becomes relevant to the broader idea of AI sovereignty.

---

The problem of self-reinforcement

Once a system can learn continuously, another problem appears.

What happens when it learns from its own output?

Consider:

Model output
    ↓
Stored as experience
    ↓
Training data
    ↓
Model update
    ↓
New output
    ↓
Stored again

A system can end up reinforcing its own errors.

Vi's provenance-aware plasticity rules attempt to reduce this problem by refusing to reinforce certain categories of output, such as echoes and word salad.

This does not solve self-training collapse in general.

But it is a useful architectural direction:

learning should know something about the provenance of what it is learning from.

That idea is applicable well beyond this particular experiment — provenance-aware learning needs the same instinct as editorial review of machine output: trust nothing without knowing where it came from.

---

Night

Then there is the most unusual component:

sleep.

Fatigue is calculated from signals including error, novelty and body pressure.

During sleep, the hippocampal formation performs replay with:

encoding=False

The idea is consolidation without simultaneously writing new experience into memory.

Broca is also explicitly excluded from training on dream output.

This leads to one of the strongest ideas in the entire project:

If memory outside the prompt only means keeping a larger prompt, it is still just a bigger prompt.

For persistent intelligence, the interesting question is whether memory has its own lifecycle:

Experience
    ↓
Encoding
    ↓
Recall
    ↓
Replay
    ↓
Consolidation
    ↓
Future behaviour

That is fundamentally different from simply attaching a vector database to an LLM — memory here exists to serve continuity across requests, which is what persistent memory is actually for.

---

Is this the real thing?

Not yet.

And that is important.

The author does not claim that Vi has become a living organism or achieved AGI.

The word life remains deliberately qualified.

The real test is whether the components form a functioning closed loop.

For example:

• Does CA1 novelty actually change memory strength?
• Does Go/NoGo learn from actions that were genuinely executed?
• Can the system distinguish thought from speech?
• Can its "know / partial / unknown" state resist misleading retrieval?
• Can motives persist after the conversation ends?
• Does sleep replay produce meaningful consolidation?
• Can the system continue changing without an active LLM request?

These are testable engineering questions.

And they matter more than whether a directory happens to be called hippocampus.

---

Vi and AI sovereignty

AI sovereignty is usually discussed in terms of:

• data ownership
• infrastructure
• cloud dependency
• jurisdiction
• model weights
• inference

Vi adds another dimension:

continuity of the intelligence itself.

Consider the conventional API-based agent:

Your application
      │
      ▼
Vendor API
      │
      ▼
Vendor-owned weights
      │
      ▼
Response

Now compare it with the architectural goal of Vi:

Your application
      │
      ▼
Your weights
      │
      ▼
Your memory
      │
      ▼
Your learning
      │
      ▼
Your autonomy
      │
      ▼
Your persistent state

This does not automatically make the second system smarter.

It makes the ownership boundary different.

That distinction matters.

A local model can still be someone else's model.

A self-trained neural system is a much more radical interpretation of AI sovereignty — sovereignty as continuity, not just weights.

---

What Builders Can Steal Without the Neuroscience

Strip away the brain vocabulary and four portable patterns survive, all named in the sections above. Signal-competition gating instead of fixed thresholds: let candidate outputs compete and admit only winners, rather than tuning a cutoff. Provenance-tagged learning rates: weight an update by where the data came from, not just what it says. Know/partial/unknown retrieval states: return "I partially know this" instead of forcing a binary hit-or-miss. Replay-with-encoding-off consolidation: reprocess the day's experience while refusing new input. Each works as a design idea even with a rented LLM at the center — you do not need the organism to borrow its organs.

What Vi is really experimenting with

I would not describe Vi as:

"A replacement for GPT."

That misses the point.

It is better understood as an experiment in building an AI organism as a persistent computational system rather than treating intelligence as a request to an external model.

Its architecture attempts to combine:

Own weights
      +
Native learning
      +
Persistent memory
      +
Internal state
      +
Motives
      +
Speech
      +
Autonomy
      +
Sleep

The goal is not to win a benchmark against GPT.

The goal is to ask whether an alternative kind of AI architecture is possible.

One where the system does not disappear conceptually when the request ends.

---

Conclusion

Vi is not proof that we have solved AGI.

It is not proof that neuroscience-inspired architectures are superior to transformers.

And it is not proof that an AI system has become alive.

It is something more useful:

an experiment.

An experiment in what happens when we remove the rented LLM from the centre of the architecture and try to build the surrounding intelligence ourselves.

NumPy becomes part of the neural tissue.

C++ becomes the speech system.

Hippocampal formation handles part of memory and replay.

Motives operate across longer timescales.

Autonomy continues outside the immediate request.

Sleep provides another mechanism for processing experience.

And the system attempts to learn without continuously depending on a vendor's inference API.

That makes Vi interesting from both a neuroscience-inspired AI perspective and an AI sovereignty perspective.

Because the ultimate question is not:

"Can Vi answer questions as well as ChatGPT?"

The more interesting question is:

When the request ends, what remains?

If something resembling persistent intelligence eventually emerges from architectures like this, it will not be because a vendor made the context window long enough.

It will be because the system itself remained there after the request was over.

Sources

• HackerNoon: Inside Vi: An AI Organism Built Without a Rented LLM
• DEV Community: Can you grow 'life' outside the prompt — no GPT, no corporation, no rented mind?