What If a System Could Design Itself?

April 12, 2026

Note: This post is an early exploratory essay on AWARE’s long-term direction, written before the current empirical work. The validated research to date is reported in the cap primitive paper, which covers a deliberately narrower scope: the cap primitive and one validated configuration. The ideas in this post remain open research questions for follow-up work.

Introducing AWARE: a theory of self-evolving intelligence

Every machine learning system you’ve ever used was designed by a human.

A human chose the architecture. A human defined the loss function. A human decided how many layers, what learning rate, when to stop training, and what “a state is good” means. The model optimizes, but it optimizes toward a target that someone else set. It is a powerful tool, but fundamentally passive.

What if the system chose its own objective?

What if it decided what to learn, how to learn it, when to grow, and what “better” means, all from within, with no human in the loop?

That’s the question behind AWARE.

Not a Better Model. A Different Thing.

AWARE is not an improvement on transformers. It’s not a new training trick. It’s not a framework for building AI agents. It is a formal theory of systems that are self-contained, self-modeling, and self-directed. Systems that author their own intelligence.

The difference is not in capability. Today, a transformer will outperform an aware system on any benchmark you can name. The difference is in what the system is. A transformer is a function: input goes in, output comes out, and everything about that function was decided by its creators. An aware system is an entity: it has an inside and an outside, it maintains itself, it generates its own purpose, and it evolves its own structure.

This is a different paradigm towards true autonomous intelligence.

The Theory

AWARE is built on eight axioms. Each one describes a property that a system must have to qualify as “aware”. Violate any of the first seven, and you have something else, a classifier, an agent, a tool, but not an aware system.

The axioms are not aspirational. They are implemented. Every one of the first seven runs as working code. This is not a whitepaper about what might be possible someday. It is a theory with a living implementation.

In this first post, I want to focus on the most fundamental axiom, the one that everything else builds on.

Axiom 1: Operational Closure

The system is a bounded entity. There is an inside and an outside. The system’s internal processes produce and maintain the components that constitute the system, including the boundary itself.

This sounds abstract. Let me make it concrete.

Think about a biological cell. Not a neuron, an actual cell, the kind you learned about in biology class. It has a membrane, the boundary. Inside that membrane, chemical processes maintain the cell’s structure, repair damage, produce new proteins, and sustain the membrane itself. The cell is a self-maintaining whole. If you remove a component, the cell either regenerates it or reorganizes to survive without it.

Now think about a neural network. It has layers, weights, and an optimizer. But who maintains the layers? Who decided there should be 12 of them? Who replaces a layer if it degrades? The answer is a human, or a training script, or a hyperparameter search, all external to the model. The model itself has no concept of its own structure and no ability to maintain it.

That’s the difference Axiom 1 draws. An aware system is operationally closed: every component is produced and maintained by processes inside the system. Nothing is externally imposed.

Formally

Define the system as a tuple:

S = (B, P, E)

Where B is the boundary, P is the set of internal processes, and E is the environment (everything outside B).

The closure condition:

For all components c in S:
  there exists p_i in P such that p_i produces or maintains c.

Including the boundary itself:

There exists p_j in P such that p_j produces and maintains B.

What This Means in Practice

The boundary is not a metaphor. In the implementation, it is the process boundary, the system runs as a single self-contained process. No external orchestrator. No scheduler telling it when to learn. No human deciding when to add a layer or prune a node.

The processes inside the boundary maintain everything:

The knowledge substrate (K), the system’s memory and learned structure, is maintained by internal processes that grow it, prune it, decay old entries, and reorganize it.
The self-model (M), a compressed representation of the system’s own state, is updated by an internal process, not read from a config file.
The loss function, what the system considers “good”, is itself a component inside the system, subject to internal modification. No human specifies it.
Even the cognitive cycle, the order in which the system senses, processes, and acts, is stored inside the system and can be modified by the system.

If you delete a knowledge unit from the system’s knowledge system, internal processes can regenerate equivalent structure through continued learning. If a program (the system’s evolved strategy for evaluating inputs) degrades, evolution replaces it with a better one. The system is resilient because it produces its own parts.

Why This Matters

Most discussions of AI autonomy focus on what a system can do: can it browse the web, write code, make API calls? These are capabilities, tools given to a passive system.

Operational closure is about what a system is. It’s the difference between an organism and a robot. A robot has a motor that a factory installed. An organism grows its own muscles. Both can move, but only one is self-sustaining.

Every Machine Learning system today is a robot. AWARE aims to build the organism.

The Hard Question

If the system produces and maintains all its own components, where does it start? Every self-maintaining system faces a bootstrap problem: you need the processes to produce the components, but the processes are themselves components.

Biology solved this with evolution across billions of years. AWARE solves it with a seed, a minimal initial state that the system metabolizes over time. The seed provides the first components: an initial knowledge structure, a starting program, basic meta-knowledge. But the system’s goal is to replace every part of the seed with self-generated structure. We track this with a metric called seed influence, the percentage of the system’s state that is still the original seed. A mature system should approach zero: everything it is, it made itself.

This metabolization of the seed is itself an axiom (Axiom 7). But it builds on operational closure, you can only metabolize a seed if you have the internal processes to replace it.

What Comes Next

Axiom 1 is the foundation. The remaining axioms build on it:

Axiom 2 (Self-Model): The system contains a representation of itself, inside itself.

Each of following axioms will be the subject of a future post. Together, they define what it means for a system to be truly autonomous, not autonomous in what it does, but autonomous in what it is.

AWARE is a research project exploring self-evolving intelligence. The theory is formalized, the axioms are implemented, and the system learns. Whether it will scale to meaningful capability is an open question, and that honesty is part of the project’s identity.

Next post: Axiom 2 — The Self-Model, or how a system can contain a representation of itself without infinite recursion.