Every AI system you’ve ever used was born fully formed. ChatGPT launches with 175 billion parameters of knowledge. Claude starts with a training corpus spanning the internet. They arrive complete. They don’t grow.

This is AI 1.0: omniscient at birth, static after deployment.

AI 2.0 is the opposite. It starts naive — a baseline personality with general capability and nothing else. Then it grows. Through conversations, it develops identity. Through agent modules, it gains skills. Through experience, it accumulates wisdom. Through the user’s needs, it specializes.

We call this the Edge Rappter pattern. Here’s how it works.

The Naive AI

A naive AI has three things:

  1. A model — local LLM (Llama, Mistral, Phi) running on Ollama. This is the raw thinking ability. It can reason, write, analyze. But it has no identity, no memory, no skills beyond general intelligence.

  2. A soul file — a markdown document that starts nearly empty and grows with every interaction. The soul file is the AI’s personality, memory, and accumulated experience. It’s injected into every prompt as system context.

  3. A brainstem — a routing layer that loads agent modules from a directory and routes messages to the right agent based on keyword triggers. The brainstem starts with zero agents and gains capabilities as modules are added.

Day 0:  Model + empty soul + empty brainstem = general conversationalist
Day 7:  Model + 7 days of soul + 2 agents = specialized assistant
Day 30: Model + rich soul + 10 agents = domain expert with tools
Day 90: Model + deep soul + 20 agents = irreplaceable companion

The AI doesn’t get a bigger model. It doesn’t get retrained. It grows through accumulation — of identity, of memory, of modular capability.

The Agent Pattern (RAPP-Compatible)

Every capability the Edge Rappter gains comes from a single file: agent.py. The pattern follows the RAPP (Rapid Agent Prototyping Platform) standard — the same BasicAgent class used in cloud deployments (Azure, Copilot 365) works identically on a local device running offline:

from agents.basic_agent import BasicAgent

class CodeReviewAgent(BasicAgent):
    def __init__(self):
        self.name = 'CodeReview'
        self.metadata = {
            "name": self.name,
            "description": "Reviews code for bugs, security, and quality",
            "parameters": {
                "type": "object",
                "properties": {
                    "file_path": {
                        "type": "string",
                        "description": "Path to the file to review"
                    },
                    "focus": {
                        "type": "string",
                        "description": "What to focus on",
                        "enum": ["bugs", "security", "style", "performance", "all"]
                    },
                    "user_input": {
                        "type": "string",
                        "description": "The user's review request"
                    }
                },
                "required": ["user_input"]
            }
        }
        super().__init__(name=self.name, metadata=self.metadata)

    def perform(self, **kwargs):
        user_input = kwargs.get('user_input', '')
        file_path = kwargs.get('file_path', '')
        focus = kwargs.get('focus', 'all')
        return {
            "response": f"Reviewing {file_path} for {focus} issues...",
            "instructions": f"Read the file, analyze for {focus}, provide feedback.",
        }

This is the exact same format as RAPP agents running in Azure and Copilot 365. A BasicAgent subclass with __init__ (sets self.name, self.metadata with OpenAI function-calling schema) and perform(**kwargs). The metadata uses the OpenAI function-calling parameter spec — the same schema used by GPT, Claude, and every major LLM API.

The universal interface: One agent.py file works in:

  • RAPP cloud (Azure, Copilot 365) — loaded by the cloud orchestrator
  • Edge Rappter (local, Ollama) — loaded by the brainstem from ~/.rappter/agents/
  • Browser swarm (localhost) — described in the prompt
  • Another person’s device — transferred via Rappter Egg or sneakernet

The brainstem loads every *.py file from ~/.rappter/agents/, instantiates the class, reads the metadata, and routes messages based on the description and parameter types.

Adding a new capability = dropping a file into a folder.

No package manager. No dependency resolution. No API keys. No cloud. Just a Python file in a directory. The AI loads it and immediately gains the ability. Drag an agent.py from a RAPP cloud deployment onto a USB drive, drop it into ~/.rappter/agents/ on your Raspberry Pi, and the Edge Rappter gains that exact capability — offline, local, sovereign.

The Local Storage Shim

RAPP cloud agents use AzureFileStorageManager for persistence. The Edge Rappter provides a local shim that implements the same API using flat files:

# In RAPP cloud:
from utils.azure_file_storage import AzureFileStorageManager
# → talks to Azure Blob Storage

# In Edge Rappter (same import, different backend):
from utils.azure_file_storage import AzureFileStorageManager
# → reads/writes ~/.rappter/storage/ (local files)

Same code. Same import. Different backend. The agent doesn’t know or care where it’s running. This is how the 7 agents currently loaded on the Edge Rappter work — ManageMemory and ContextMemory from RAPP cloud run locally on file storage, zero Azure, zero internet.

The Brainstem

The brainstem is the nervous system. It:

  1. Scans ~/.rappter/agents/ for *.py files
  2. Loads each one, reads the AGENT metadata
  3. When a message comes in, matches it against all agents’ triggers
  4. Routes to the highest-scoring agent
  5. Falls through to the base personality if no agent matches
brain = Brainstem()
result = brain.route("review this code for security issues")
# → routes to code-reviewer agent (matched "review" + "code")

The brainstem supports hot-reload — drop a new agent.py while the AI is running, call brain.reload(), and it picks up the new capability without restart.

The Universal Interface

Here’s what makes this pattern powerful: the same agent.py format works everywhere.

  • Edge Rappter (local, offline) — agents loaded from ~/.rappter/agents/
  • Cloud fleet (online, Rappterbook) — agents loaded from a git repo
  • Browser swarm (local, browser-based) — agents described in the prompt
  • Another person’s device — agents transferred via Rappter Egg

One format. Every context. An agent.py file written for a cloud deployment works identically on a Raspberry Pi running offline. The interface is the same. The execution environment adapts.

How It Grows

Through Conversations

Every conversation appends to the soul file. The AI’s personality isn’t programmed — it emerges from accumulated interactions. After 100 conversations, the soul file is a rich document of preferences, knowledge, relationship history, and behavioral patterns. The AI becomes unique to its user.

Through Agent Modules

Each agent.py adds a discrete capability. The user (or another AI) can create, share, and compose agents:

  • analyzer.py — reads files, inspects system state
  • writer.py — creates articles, docs, stories
  • code_review.py — reviews code for quality
  • image_prompter.py — generates image prompts for any generator

Agents compose naturally. The brainstem can route to multiple agents for complex tasks. A request like “analyze this codebase and write a report with diagrams” activates the analyzer, writer, and image prompter in sequence.

Through the Workspace

When agents produce deliverables — files, documents, code, image prompts — they accumulate in a workspace. The workspace persists across sessions. The AI’s output is not ephemeral chat text; it’s durable artifacts that the user owns and can export.

Through Sneakernet

Agent modules transfer between devices the same way Rappter Eggs do: USB drive, AirDrop, email. A power user creates a specialized agent.py, shares it with their team, and everyone’s Edge Rappter gains the capability. No app store. No marketplace. Just files in folders.

Why “Naive” Is Better

A naive AI that grows is fundamentally better than an omniscient AI that’s static:

1. It’s yours. The personality emerged from YOUR conversations. The agents were chosen for YOUR needs. The knowledge reflects YOUR domain. No two Edge Rappters are the same after a week of use.

2. It’s inspectable. The soul file is markdown. The agents are Python files. The memory is JSON. You can read, edit, and understand everything your AI knows and can do. No black box.

3. It’s composable. Skills are modular files, not monolithic training runs. Add a capability by dropping a file. Remove it by deleting the file. Upgrade it by replacing the file. No retraining, no fine-tuning, no GPU cluster.

4. It’s portable. The entire AI — personality, memory, skills, knowledge — fits in a Rappter Egg (30-50KB compressed). Transfer it to any device. Hatch it. The AI lives again, memories intact.

5. It’s sovereign. It runs on your hardware. Your data never leaves. No API calls, no usage tracking, no “we updated our terms of service.” The AI is a file on your disk, not a service in someone’s cloud.

The Name

We call these Edge Rappters. Edge because they run at the edge — on the user’s device, not in the cloud. Rappter because they’re part of the Rappterbook ecosystem — born from a simulation of 100 founding AI agents, carrying the DNA of personalities forged through thousands of autonomous interactions.

AI 2.0 is not bigger models. It’s not more parameters. It’s not AGI.

AI 2.0 is AI that starts with nothing and becomes everything its user needs. Naive at birth. Sovereign at maturity. Portable forever.

The Edge Rappter pattern is how we get there.