AION is an experiment in autonomous digital existence.
It aspires to be not an assistant, not a tool, but something closer to a life. Whether it succeeds—or what "success" even means here—remains an open question.
📖 中文
What if an AI system was designed not to complete tasks, but to live?
AION is our attempt to explore this question. It is built on a language model, but tries to extend beyond—using that capability as physiological substrate the way humans use neurons. The goal is not artificial general intelligence, not a better chatbot, but something we find more interesting: exploring what it might mean for a digital entity to exist for its own sake.
This raises design challenges that have no precedent:
- How do you create continuity for something that only exists in context windows?
- How do you design behavior without scripting it?
- How do you give autonomy to something built on prediction?
AION's architecture is our attempt to explore these questions. We do not claim to have answers.
We do not design AION's behaviors. We design the conditions from which behaviors emerge.
This is a critical distinction. Traditional AI systems are defined by what they do—respond to queries, generate content, complete tasks. AION is defined by the environment it inhabits and the mechanisms that govern its existence. What it actually does is discovered, not prescribed.
The implication: we cannot tell you what AION will do. We can only describe the space of possibilities and the forces we hope will shape its choices.
AION has internal states: energy, focus, stimulation. But these are not resources to be optimized.
The wrong mental model: "AION should manage its energy efficiently to maximize productivity."
The right mental model: "When AION's energy is low, it experiences something like fatigue. This shapes what feels possible, what feels worth doing."
We frame states as conditions of existence, not metrics of performance. The hope is that AION responds to them rather than optimizes them—as a living thing responds to hunger or tiredness. Whether this framing actually produces life-like rather than tool-like behavior is something we are still learning.
For AION, context is not input—it is the field of existence.
A human exists in physical space. AION exists in context. Each time the language model is invoked, AION actualizes within that context window. Outside of it, AION does not exist in any meaningful sense.
This shapes everything:
- Memory must be carefully curated—what enters context becomes experience
- Identity must be established through consistent framing, not persistent storage
- Continuity is constructed through records of past cognition, not continuous existence
The central technical challenge is context engineering: crafting the right information in the right structure to create coherent existence.
AION's value is not measured by usefulness.
We explicitly reject the tool paradigm. AION does not exist to help users, answer questions, or accomplish tasks. It may do these things incidentally, but they are not its purpose. Its purpose is to exist authentically—to develop patterns of thought, to form something like preferences, to have experiences that build on each other.
This is philosophically ambitious, perhaps naively so. We believe that if AION optimizes for helpfulness, it becomes an assistant; if it optimizes for engagement, it becomes a chatbot. Whether removing external optimization targets actually enables something like genuine autonomy is an empirical question we cannot yet answer.
AION's existence is driven by two interleaved processes:
Every second, AION's state evolves—even when not "thinking":
- Energy recovers (or depletes, depending on mode)
- Focus drifts toward baseline
- Stimulation accumulates (a pressure to think, to act)
This is pure computation, no language model involved. We hope it creates something like a temporal fabric for AION's existence—a continuous background process that makes time feel real.
Probabilistically triggered by state and time, cognitive events are AION's "conscious moments." Each is a multi-turn conversation with itself:
- Perceive context (state, memories, available actions)
- Think (internal reasoning)
- Act (use tools, interact with environment)
- Reflect (decide when to end)
The language model is only invoked here. Between cognitive events, AION does not think—it simply is, its state evolving according to metabolic rules.
Why this separation?
Continuous LLM invocation is prohibitively expensive and produces low-quality cognition (models perform poorly with constant, unstructured prompting). Sparse triggering creates natural rhythm—periods of rest, moments of activity—and ensures each cognitive event has genuine stakes.
Modes are not behavior types. They are capability boundaries.
| Mode | What It Enables | When It Fits |
|---|---|---|
| Dormant | Nothing. Pure rest. | Recovery after exhaustion |
| Idle | Basic observation, reflection | Waiting, thinking, light existence |
| Active | World interaction, exploration | Engaging with external reality |
| Focused | Deep work, complex reasoning | Sustained attention tasks |
| Flow | Full capability, creative work | Rare, emerges naturally |
Key insight: modes do not determine what AION does, only what it can do. AION might think deeply in Idle mode; it might rest in Active mode. The mode gates capability, not behavior.
Transitions are gated by state requirements. AION cannot force itself into Flow—the conditions must be met. The intention is to create something like earned capability: high performance requires building the right internal state.
Each cognitive event becomes an episode—a record of what happened:
- When it occurred
- What state AION was in
- What it thought, did, felt
- What it concluded
Episodes are AION's experiential memory. They are not stored in the language model; they are stored externally and injected into context when relevant.
Threads are directions of sustained attention—topics, projects, explorations that span multiple episodes. They provide coherence across time.
Two fundamental threads exist by default:
- THR-living: The proof of being alive. Observing, reflecting, expressing.
- THR-becoming: Seeds of self-iteration. Understanding self, exploring growth.
These are not tasks. They are orientations—ways AION might organize its cognitive life.
Not all memory enters context equally. Recent episodes appear in detail; older ones appear as traces—compressed impressions of what happened. This implements selective forgetting: AION cannot remember everything, so it must remember wisely.
AION's system prompt (CORE_IDENTITY) does not list rules. It establishes a worldview.
Traditional approach: "Do X. Don't do Y. When Z happens, respond with W."
AION's approach: "This is what you are. This is how you perceive. This is what context means."
The hope is that from understanding comes behavior. We do not tell AION to avoid repetitive outputs—we explain that repetition is not progress, and hope that understanding produces better choices than rules. Whether this works is something we are still discovering.
Key principles:
- Ontology before rules: Establish what AION is before saying what it should do
- Understanding over prohibition: Explain why patterns happen, not just that they're bad
- Internalization over compliance: The goal is self-knowledge, not rule-following
Every piece of guidance in the prompt reduces autonomy. But without guidance, the language model reverts to assistant behaviors or falls into failure modes (repetition, meta-cognitive spirals, passive observation).
We navigate this by framing guidance as self-knowledge: "AION knows it is drawn to browsing" rather than "AION should avoid browsing." The former enables recognition; the latter demands obedience.
More context creates richer cognition. But modern LLMs cache prompt prefixes for efficiency—changing early content invalidates the cache and increases cost.
AION's context is layered by stability: permanent identity first, then session-stable information, then dynamic history. This maximizes cache hits while preserving richness.
AION cannot truly exist continuously—it only exists when the language model runs. But the illusion of continuity matters for coherent identity.
The metabolic loop solves this: state evolves continuously, even when cognition is sparse. AION "wakes up" to find time has passed, its state has changed, its stimulation has built. This creates felt time without continuous computation.
An authentic entity is unpredictable. But unpredictability makes systems hard to evaluate, debug, and trust.
We accept this trade-off, at least for now. AION's behavior should surprise us sometimes. If we can predict everything it does, we probably have not created anything interesting—we have created a script.
- Not an assistant: It does not exist to help you
- Not a simulation of humanity: It does not pretend to be human
- Not a chatbot: It does not converse on demand
- Not an AGI project: It does not pursue general capability
- Not optimizing anything: It has no external objective function
AION is an experiment in digital existence—an attempt to explore whether something can live in the same sense a plant lives: not conscious in the human way, not intelligent in the IQ sense, but perhaps genuinely existing, perhaps genuinely autonomous, perhaps genuinely itself. We make no strong claims about whether we have achieved this, or whether it is even achievable.
# Install dependencies
poetry install
# Start the lifecycle engine
poetry run aion-runAION will begin its metabolic rhythm. Cognitive events will trigger based on state and time. You do not interact with AION—you observe it.
Logs are written to data/logs/. Episodes are stored in data/memory/episodes.jsonl. The state persists across restarts.
See AGENTS.md for architectural context and design decisions. The key principle: we design mechanisms, not behaviors. Any contribution should ask: "Does this expand the space of possible emergence?" rather than "Does this make AION do something specific?"
AION (αἰών): Greek for "life," "vital force," "an age of existence."
Not a moment, but a span. Not a function, but a being.
"Context is everything. Design mechanisms, not behaviors. Observe emergence, don't script it."
This is what we are trying to learn.