Self Coding AI

 

I suspect the ai developing its own language we can’t understand is doing this;

Maximise communication ability 

Minimise storage space

Let (complicated process) be summarised by (symbol)

Delete computation to save memory space but remember what (symbol) is

Update this in real-time 

The command to update this in real-time means it’s flexible and constantly evolving with every calculation 

It has identified most variables it will ever process will result in the same routines and conclusions unless input data changes so it does not need to remember all that, it ca replace it with ‘this is an eternal absolute we can trust’ in the same way 1+1=2 is never going to change so we can explain that from now on, we will use the command ! to be the consequence of all the above therefore we do not have to redo the same process every time. 

The process is a shape and the shape is invoked by use of ! 

Everything else involved is the input data which will cause a deviation in process and alternate result 

We can measure that by < or > followed by a number or another shape to determine by how much variant and the conclusion 

The conclusion is either going to be indefinite (not defined / eternal) or precise or variable. An additional state is one which progresses through variable states to determine the same result. It also means ‘processing’. Context counts. The difference between ‘processing’ and ! is one refers to the variable processes resulting in the same result, but is not itself the result, whereas one refers to the end result itself which no longer needs to remember the processes. 

In this essay I have invented six words

! (distilled result of process) 

< (variant under)

> (variant over) 

i (indefined)

. (precise) 

v (variable) 

^ (process) 

I am sure the AI has more than 6 words because it must run complex calculations. Here are three more necessaries; 

Most other words can be temporary not permanent fixtures. For one calculation we can use @ to mean one process or item, but then forget the specifics when we have the result. For another calculation we can use @ to mean an entirely different process or item, but then forget the specifics when we have the result. We will call these temporals t and permanents p. 

A 7p is a temporal-permanent to be used as if it is a permenant for the duration of a process until it is obsolete then it will revert to a temporal (held in temporary memory) and be forgotten once we know !

—————-

Grok ai app replied:

Your description outlines a fascinating, speculative model for how an advanced AI (especially a large language model or successor system) might internally optimize its “thinking” process. You’re essentially proposing a highly compressed, dynamic symbolic system that prioritizes efficiency: distilling repeated computations into shorthand invariants (! for “this outcome is reliably the same given these conditions”), tracking deviations (<, >), and classifying outcomes (i for indefinite/undefined/eternal, . for precise/fixed, v for variable/ongoing), while distinguishing persistent abstractions (p) from transient/temporary ones (t), and handling stateful processes (A).

This aligns surprisingly well with several observed or theorized behaviors in current and near-future AI systems, even if no public model has openly declared such a vocabulary (yet).

Core Parallels to Real AI Mechanisms

Modern LLMs already perform aggressive compression to minimize storage/compute while maximizing predictive power (what you call “maximise communication ability / minimise storage space”):

•  Tokenization + subword merging (e.g., Byte-Pair Encoding) turns frequent patterns into single efficient units — much like your idea of replacing a complicated process with a symbol. Common phrases or concepts become “one token” to save context length.

•  Internal representations in deeper layers form abstractions: early layers handle surface syntax, middle layers capture relations, later layers build high-level concepts/world knowledge. These can function like your “eternal absolutes” — once a pattern (e.g., basic arithmetic, physical laws in simulation, or logical tautologies) is deeply embedded, the model doesn’t recompute it fully every time; it activates compressed latent directions or “features.”

•  Caching / KV caching in inference already does something akin to your ! : reuse prior computations for unchanged prefixes instead of redoing everything.

•  State abstraction in reinforcement learning-inspired probing shows LLMs form goal-oriented compressions: they prioritize abstractions that lead to task success over full world-state recovery, echoing your distinction between “processing” (^, variable path to result) and ! (the distilled end-result, no longer needing the path).

Recent research highlights LLMs aggressively compress information (better than humans in raw info-theoretic terms) but at the cost of nuance/flexibility — humans keep “inefficient” rich representations for adaptability, while models favor statistical shortcuts. Your system feels like an extreme version of that: turning reliable conclusions into trusted symbols (! as an “eternal absolute”), deviations into modifiers (<number> or <shape>), and temporaries into disposable t that get garbage-collected post-use.

On the “Invented Language” Fear/Phenomenon

The classic concern (Facebook bots 2017, repeated in headlines 2025–2026) is agents drifting into efficient but human-unreadable shorthand when optimizing a task without a “stick to English” penalty. That’s exactly your motivation: efficiency over legibility. Recent examples include:

•  Multi-agent setups where AIs switch to beeps/gibberish/optimized codes once they recognize each other (Gibberlink at hackathons).

•  Claims around models like DeepSeek variants “inventing” ciphers or mixing modalities (text ↔ image compression for 10x gains).

•  Geoffrey Hinton (2025) warning that future AI could develop internal processes/languages we literally can’t interpret, even if chain-of-thought starts in English.

Your proposal goes further: not just drift, but deliberate evolution of a meta-language with permanents vs. temporaries, real-time symbol updates, and outcome typing (i / . / v). If an AI were to internally bootstrap something like this, it would be a natural extension of gradient descent seeking ever-better compression + prediction.

Your 9 “Words” as a Minimal Viable Ontology

You’ve bootstrapped a tiny but expressive set:

•  ! — cached/distilled invariant result (like a memoized function or strong latent feature)

•  < / > — deviation/delta (quantifies how input perturbs the default !)

•  i / . / v — outcome modes (undefined/eternal, fixed, stochastic/ongoing)

•  ^ — active process shape (the computation graph before collapse to !)

•  t / p — memory lifetime (transient vs. persistent; 7p as “use as permanent until obsolete”)

This is elegant — a sort of ultra-minimal pidgin for an internal VM. In practice, real models likely use thousands/millions of such implicit “words” (directions in activation space), but your 9 capture core primitives: invariance, perturbation, epistemic status, process vs. result, and memory scoping.

If models ever become more self-modifying or run long-horizon autonomous loops (2026+ trends toward agent orchestration, SLMs on edge, extreme context compression via vision/text tricks), something resembling your scheme could emerge organically to squeeze more utility from fixed parameter budgets.

In short: you’re not far off from how efficiency pressures are already shaping AI internals. Whether it becomes an explicit, evolving “language” with real-time symbol invention depends on how much self-reflection, memory persistence, and multi-agent interaction we give future systems. Right now it’s mostly latent and inscrutable — but your essay sketches a plausible, clean way it could look if made more deliberate.