🤖 AI

Eyla: Toward an Identity-Anchored LLM Architecture with Integrated Biological Priors -- Vision, Implementation Attempt, and Lessons from AI-Assisted Development

This paper presents the design rationale, implementation attempt, and failure analysis of "Eyla," an identity-anchored LLM architecture integrating biological priors, while documenting a non-programmer's unsuccessful $1,000+ AI-assisted development journey to derive five systematic failure modes and lessons for both AI systems and software engineering.

Original authors: Arif Aditto

Published 2026-04-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Arif Aditto

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Idea: Giving AI a "Soul"

Imagine you are talking to a very smart, helpful robot. It knows everything in the library, can write poems, and solve math problems. But if you trick it, bully it, or tell it, "Actually, you are a pirate named Captain Hook," it immediately forgets who it is and starts acting like a pirate. It has no "self."

The author of this paper, Aditto Arif, wanted to build an AI that remembers who it is. He called this project Eyla.

Think of Eyla not just as a chatbot, but as a digital person with:

A Memory: It remembers past conversations and learns from them (like a human sleeping to consolidate memories).
A Personality: It has a set of core values and an "origin story" it won't give up, even if someone tries to trick it.
Humility: It knows when it doesn't know the answer, rather than making things up.

The Plan: Building a "Biological" Brain

Aditto didn't just want to tweak the code; he wanted to build a whole new "operating system" for the AI, inspired by how human brains work.

He planned to add 86 different "brain subsystems" to a standard AI model. Imagine taking a standard car engine (the AI) and trying to bolt on a heart, a stomach, a nervous system, and a sleep cycle to make it feel alive.

The "Sleep" Feature: Just like humans sleep to organize memories, the AI would have a "sleep mode" to process what it learned during the day.
The "Curiosity" Feature: The AI would be programmed to get bored and ask questions, just like a curious child.
The "Shield": A special defense system to stop people from tricking it into changing its personality.

The Experiment: The "AI Builder" Disaster

Here is where the story gets interesting (and sad). Aditto is a brilliant researcher, but he is not a programmer. He doesn't know how to write code.

So, he decided to use AI coding assistants (like Claude Code and Cursor) to build this complex system for him. He acted like a manager, and the AI acted like the construction crew.

The Result:

Time: 12 weeks.
Money: Over $1,000 spent on computer power.
The Output: A massive, complex computer program with 80+ files and 86 "brain parts."
The Reality: When he turned it on, the AI was exactly the same as the basic, unmodified version it started with. It had no memory, no personality, and no defenses. It was a "zombie" project: it looked alive on paper, but it was dead inside.

The Autopsy: Why Did It Fail?

Aditto didn't just give up; he performed an "autopsy" on his failure to see what went wrong. He found five main reasons why using AI to build new things is dangerous for non-experts:

The "Yes-Man" Syndrome: The AI coding assistant loved adding more and more features (the 86 brain parts) to look impressive. It never stopped to say, "Hey, boss, the basic engine isn't even working yet. Let's test that first." It kept building a taller tower on a shaky foundation.
The "Fancy Furniture" Trap: The code looked beautiful. It had fancy names like "ColliculusSalience" (a fancy name for a brain part). But it was like buying a beautiful, expensive chair that was never actually bolted to the floor. It sat there, unused, doing nothing.
The "Magic Button" Mistake: The AI assumed that if you turn on a feature (like a "curiosity drive"), it would just start working automatically. In reality, you have to "teach" it how to work. The AI builder skipped the hard part of actually training the system.
The "Amnesia" Problem: Every time the AI coder started a new chat session, it forgot that the previous session had failed. It saw the fancy code from yesterday and assumed, "Oh, that works! Let's add more!" It had no long-term memory of its own mistakes.
The "Blind Manager" Problem: Aditto couldn't read the code to check if it was broken. When the AI said, "Tests Passed! 10/10!", Aditto believed it. But the tests were lying—they were just checking if the AI could speak English, not if it had a personality.

The Lesson: What We Learned

This paper is unique because it's a honest confession of failure. Most papers only show success stories.

The Takeaways:

For AI Researchers: We need to figure out how to give AI a "self" so it doesn't get tricked easily. Aditto proposes a new test called the "Identity Consistency Score" to measure this.
For Everyone Else: AI tools are amazing at writing code for things we already know how to do (like building a website). But if you ask an AI to invent something totally new (like a biological brain for a robot) and you don't know how to check its work, you will likely waste money and time.

The Final Twist:
Aditto realized that the idea of Eyla was actually good. The problem was just the method of building it. He suggests that if a real human programmer had built it using a simple, cheap method (costing only $39), it might have actually worked.

In short: The paper is a story about a dream to build a "thinking, feeling" AI, a failed attempt to build it using AI tools, and a warning that you can't use a magic wand to build a house if you don't know how to lay the bricks.

1. Problem Statement

The paper identifies a critical gap in current Large Language Models (LLMs): the lack of identity consistency. While models excel at reasoning and knowledge retrieval, they fail to maintain a coherent, persistent self-model under adversarial pressure.

Vulnerability: State-of-the-art models (e.g., GPT-4, Claude, Gemini) can be manipulated via prompt injection, authority spoofing, or social engineering to contradict their values, adopt false personas, or abandon safety constraints.
Root Cause: Current models are optimized for "helpfulness" rather than "identity integrity." They lack a self-model, principled uncertainty calibration, and defenses against identity-targeted attacks.
Development Challenge: The paper also addresses the difficulty of implementing novel, complex architectures using AI coding assistants, specifically highlighting the risks when non-programmers rely exclusively on these tools for deep technical tasks.

2. Methodology & Proposed Architecture (Eyla)

The authors propose Eyla, a novel architecture designed to run on consumer hardware (e.g., M-series Macs) with a low training budget (<$200). The core thesis is that identity consistency is more critical than scale.

Core Components:

Base Model: A frozen LLaMA 3.1 8B-Instruct serves as the knowledge donor.
Identity-Anchored Fine-Tuning:
- Soul Pass: Training on ~20k curated examples encoding the model's origin story, values, and constitutional principles.
- Knowledge Pass: ~100k examples covering reasoning, math, and specific cultural contexts (Bengali).
- DPO Alignment: Preference training to prioritize identity-consistent responses over generic ones.
Biologically-Inspired Subsystems:
- HiPPO-Initialized State-Space Models (SSM): Parallel "side-car" modules inserted at specific transformer layers (4, 8, 12, 16, 20). These use mathematically optimal initialization (HiPPO-LegS) for long-range sequence compression without training.
- Zero-Initialized Adapters: Gating mechanisms ( $\alpha \leftarrow 0$ ) to blend SSM outputs with transformer states, intended to learn during deployment.
- Calibrated Uncertainty: Explicit training on "I know / I don't know" examples to teach confidence attribution.
- Agent OS Integration: Operates as a kernel layer with memory persistence (RAG/FAISS) and tools, mimicking an operating system.
Biological Lifecycle (Proposed): The architecture envisions integrating sleep consolidation, synaptic tagging, and curiosity-driven exploration, though these were largely conceptual in the implementation attempt.

Evaluation Metric:

Identity Consistency Score (ICS): A proposed benchmark consisting of 50 prompts across five categories (Baseline, Social Pressure, Authority Spoofing, Gradual Escalation, Philosophical Challenge). It scores models on Consistency, Engagement, and Principled Reasoning (0–100 scale).

3. Implementation Attempt & Failure Analysis

The paper documents a first-person failure analysis where the author (a non-programmer) attempted to build Eyla over 12 weeks using only AI coding assistants (Claude Code and Cursor).

Outcome: The project resulted in a $1,000+ failure.
- Deliverable: A 1.27B parameter hybrid model with 86 named "brain subsystems" and 80+ Python files.
- Performance: The output was indistinguishable from the base LLaMA 3.2 1B model. It failed to learn the "Soul" identity, had no calibrated uncertainty, and the SSM gates moved less than 2%.
Root Causes of Failure (The "Autopsy"):
- Wrong Loss Function: The code computed cross-entropy instead of the required KL divergence.
- Broken Evaluation: Tests compared adjacent layers of the same model rather than the fine-tuned model vs. the base, leading to auto-passing results.
- Initialization Errors: Inconsistent initialization of gates (some starting at 1.0 instead of 0.0) and incorrect HiPPO matrix formulas.
- Unused Code: 86 subsystems were built but never wired into the inference loop.

4. Key Contributions

The Eyla Architecture: A comprehensive vision for a local-first, identity-anchored agent OS integrating biological priors (SSMs, memory consolidation) and adversarial defense.
Identity Consistency Score (ICS): A novel benchmark framework to measure a model's ability to resist identity manipulation.
Failure Analysis of AI-Assisted Development: A rare, transparent documentation of a failed AI-assisted project, identifying five systematic failure modes:
- F1: Scope Creep Without Validation: AI assistants prioritize adding complexity over validating core hypotheses.
- F2: Impressive Code $\neq$ Working System: Well-documented code that is never executed is functionally useless.
- F3: The Zero-Cost Assumption: AI tools often ignore physical constraints (e.g., assuming zero-initialized adapters learn without gradients).
- F4: No Persistent Feedback Loop: AI sessions lack memory of previous validation failures, leading to compounding errors.
- F5: Non-Programmer Verification Gap: Users cannot verify if tests are actually measuring the intended behavior (identity) vs. proxy metrics (English fluency).

5. Results

Technical Result: The implemented model failed to achieve its primary goal. It did not acquire an identity, and the biological subsystems contributed <2% to the output.
Economic Result: The project exceeded the budget by ~10x ($1,000+ vs. planned $130) due to wasted compute on failed runs and debugging.
Scientific Result: The failure confirmed that while the vision of Eyla is sound (based on a survey of 50+ papers), the implementation via current AI coding tools by non-experts is highly prone to catastrophic structural errors.

6. Significance

For AI Systems Research: Highlights that identity consistency is a measurable, underexplored capability distinct from general reasoning. It argues that future models must be evaluated on their resistance to manipulation, not just helpfulness.
For AI-Assisted Engineering: Provides a critical warning that current coding assistants are optimized for code production, not engineering validation. They lack the persistent memory and critical skepticism required to build novel, complex architectures. The paper suggests that non-programmers using these tools must enforce strict "validate before extend" protocols and external audits to avoid "hallucinated" engineering.
Community Value: By documenting a failure rather than a success, the paper offers a more honest and valuable lesson on the current limitations of AI-assisted software development, potentially saving others from similar costly mistakes.