Behind the Scenes of a Self-Evolving AI: The Architecture of Tian AI

Ever wondered what it takes to build an AI system that doesn't just process queries but actually grows, learns, and improves itself?

This post takes you inside the architecture of Tian AI — an open-source local AI system that runs entirely on Android. No cloud. No APIs. Just code, a local language model, and a 34GB knowledge base.

The Big Picture

Tian AI's architecture is built around a simple insight: a small model + good architecture + local knowledge > large model alone.

┌──────────────────────────────────────────────┐
│              Web/Mobile UI                    │
├──────────────────────────────────────────────┤
│              Flask API Layer                  │
├────────────┬───────────┬─────────┬───────────┤
│  Thinker   │  Memory   │  Search │  Evolve   │
│  Engine    │  System   │  Engine │  Engine   │
├────────────┴───────────┴─────────┴───────────┤
│         LLM Bridge (llama.cpp API)            │
├──────────────────────────────────────────────┤
│      Knowledge Base (34GB SQLite)             │
└──────────────────────────────────────────────┘

1. The Three-Layer Thinking Engine

This is the heart of Tian AI. Instead of a single pass at every query, the system has three thinking modes:

Fast Mode

For simple queries — greetings, facts, straightforward questions. Single pass, no chaining. Response in ~0.04s.

Architecture: Direct LLM call with minimal context

Chain-of-Thought Mode

For problems that benefit from step-by-step reasoning. The LLM is prompted to "think aloud" before answering.

Architecture:

1. User query → CoT prompt template
2. "Let's break this down step by step..."
3. Intermediate tokens guide reasoning
4. Final answer extracted from reasoning chain

Deep Mode

For complex analysis, multi-perspective evaluation, and reflection. The system generates multiple viewpoints and synthesizes them.

Architecture:

1. Query → perspective analysis → 3 viewpoints
2. Each viewpoint explored independently
3. Cross-perspective synthesis
4. Final answer with reflection

2. The 34GB Knowledge Base

The knowledge base is the secret weapon. It's a pre-built SQLite database containing:

• 69,000+ concepts across 100+ domains
• 30 question patterns per concept (2.07 million queryable keys)
• Multi-language support (Chinese + English)
• Instant indexed retrieval (0.04-0.1s per query)

How It Works

# Simplified query flow
def answer_query(user_input):
    # 1. Extract key concepts
    concepts = extract_concepts(user_input)

    # 2. Look up in knowledge base
    results = knowledge_base.search(concepts)

    # 3. If KB has answer, return directly
    if results.confidence > 0.8:
        return results.answer

    # 4. Otherwise, augment LLM with KB context
    context = format_kb_context(results)
    return llm.generate(augmented_prompt(user_input, context))

Why SQLite?

• No server needed — runs in-process
• Portable — single file
• Indexed — fast LIKE + FTS queries
• Updateable — add new knowledge without retraining

3. The Self-Modification System

This is the most audacious feature: Tian AI can analyze, suggest improvements for, and apply patches to its own source code.

class SelfModifyEngine:
    def scan_code(self):
        """AST-based analysis of all project files"""

    def analyze_complexity(self, filepath):
        """Cyclomatic complexity, duplication, style issues"""

    def suggest_improvement(self, filepath):
        """LLM-generated improvement suggestions"""

    def apply_patch(self, filepath, old, new):
        """Safe patching with automatic backup"""

    def auto_improve(self):
        """Full loop: scan → analyze → suggest → patch"""

The flow:

1. SCAN — walks the project, parses every Python file with ast
2. ANALYZE — measures complexity, detects duplications, finds issues
3. SUGGEST — sends analysis to the local LLM with a structured prompt
4. APPLY — applies the patch (always backs up first)
5. VERIFY — checks syntax with compile(), tests basic functionality

4. Evolution Engine

Tian AI doesn't just run — it grows. The evolution system tracks:

• XP — Earned through conversations and tasks
• Levels — Milestones unlock new capabilities
• Versions — Named releases (M1-E1-Theme format)
• Topics — Depth tracking for domain expertise

5. The Tech Stack in Detail

Layer	Implementation	Why
LLM	llama.cpp + Qwen2.5-1.5B GGUF	Runs on ARM, no GPU needed
Backend	Flask, RESTful API	Minimal, well-understood
Frontend	Pure HTML/CSS/JS	Zero dependencies, portable
Database	SQLite (34GB)	File-based, no server
Auth	Simple session + localStorage	No external dependencies
Search	DuckDuckGo API (optional)	Augments local KB
Tooling	C++ (tian_engine), C (tian_hash), Java (tian_tools)	Performance-critical paths

6. Performance on Real Hardware

Tested on a realme V70s (Android, aarch64, 5.5GB RAM):

Operation	Time
Token generation	~7 tok/s
Prompt processing	~12 tok/s
Knowledge base lookup	0.04-0.1s
Cold start (load model)	~45s
Chat response (Fast mode)	1-3s
Chat response (Deep mode)	15-30s

7. What's Next

• Multi-modal support — Image understanding via local vision models
• Plugin system — Extensible tool calling
• RAG improvements — Better document ingestion
• Android APK — Standalone app, no Termux needed
• Federated learning — Privacy-preserving model improvements

Getting Started

# Clone and run
git clone https://github.com/yourusername/tian-ai
cd tian-ai

# Install deps
pip install -r requirements.txt

# Download model
wget -O ~/storage/downloads/qwen-1.5b-q4.gguf [model_url]

# Start LLM server
llama-server -m ~/storage/downloads/qwen-1.5b-q4.gguf --port 8080

# Launch Tian AI
python run.py    # Full backend
# OR just open
xdg-open tian_ai_standalone.html  # Pure frontend

---

Tian AI — open-source, private, self-evolving AI for everyone.

Support development:

USDT (TRC-20): TNeUMpbwWFcv6v7tYHmkFkE7gC5eWzqbrs

BTC: bc1ph7qnaqkx4pkg4fmucvudlu3ydzgwnfmxy7dkv3nyl48wwa03kmnsvpc2xv