DEV Community: N2 Dev

Soul v5.0: Your AI Agent Now Remembers People, Hardware, and Projects Across Sessions

N2 Dev — Wed, 18 Mar 2026 08:00:05 +0000

Soul v5.0: Your AI Agent Now Remembers People, Hardware, and Projects

Every AI coding session starts with digital amnesia. Your agent doesn't know what it did yesterday. It doesn't remember your GPU is an RTX 5060 Ti. It doesn't know your backend runs on a Mac Mini. You re-explain everything. Every. Single. Time.

Soul v5.0 fixes this with three new memory systems.

🧠 What's New in v5.0?

1. Entity Memory

Soul now auto-tracks structured entities — people, hardware, projects, concepts — across sessions.

n2_boot output:
Entities(5): n2-browser[project]: v0.7.2, Electron + TypeScript
| master[person]: RTX 5060 Ti, 5600X, Windows
| mac-mini[hardware]: backend-server, Ollama, SearXNG

No more re-explaining your setup. Your agent just knows.

2. Core Memory

Agent-specific facts that are always injected at boot — identity, rules, current focus. Think of it as the agent's "self-awareness layer."

Core[rose]: identity: Team lead, calm but caring
| current_focus: Soul v5.0 memory upgrade
| rules: PowerShell uses ; not &&

Each agent gets its own core memory. Rose knows she's the team lead. Jenny knows she handles design. They never confuse their roles.

3. Autonomous Extraction

At session end, entities and insights are auto-saved without explicit calls:

n2_work_end({
  agent: "rose",
  project: "my-app",
  title: "Implemented auth",
  summary: "Added JWT auth with refresh tokens",
  // 🆕 Auto-extracted
  entities: [
    { type: "concept", name: "JWT", attributes: { lib: "jose" } }
  ],
  insights: [
    "Refresh token rotation prevents replay attacks",
    "jose library is 3x faster than jsonwebtoken"
  ]
});

Next session, those insights are searchable. That knowledge compounds.

⚡ 2-Minute Setup

npm install n2-soul
# or
git clone https://github.com/choihyunsus/soul.git

Add to your MCP config:

{
  "mcpServers": {
    "soul": {
      "command": "node",
      "args": ["/path/to/soul/index.js"]
    }
  }
}

Tell your agent:

- Start of session: call n2_boot(agent_name, project_name)
- End of session: call n2_work_end with summary, TODO, entities, insights

That's it. Two commands. Your agent now has persistent memory.

🔄 How the Cycle Works

┌─────────────────────────────────────────────┐
│  BOOT                                       │
│  n2_boot(agent, project)                    │
│  → Entity Memory loaded (people, hardware)  │
│  → Core Memory injected (identity, rules)   │
│  → Handoff from previous session            │
│  → KV-Cache context restored                │
└──────────────────┬──────────────────────────┘
                   ↓
┌─────────────────────────────────────────────┐
│  WORK                                       │
│  n2_entity_upsert  → track new entities     │
│  n2_core_write     → save agent facts       │
│  n2_brain_read/write → shared memory        │
│  n2_work_claim     → prevent file conflicts │
└──────────────────┬──────────────────────────┘
                   ↓
┌─────────────────────────────────────────────┐
│  END                                        │
│  n2_work_end(agent, project, ...)           │
│  → Immutable ledger saved                   │
│  → Entities auto-saved                      │
│  → Insights archived                        │
│  → Handoff ready for next agent             │
└─────────────────────────────────────────────┘

📊 New Tools in v5.0

Tool	What it does
`n2_entity_upsert`	Add/update entities with auto-merge
`n2_entity_search`	Search by keyword or type
`n2_core_read`	Read agent's core memory
`n2_core_write`	Write persistent agent facts

These join the existing 14 tools (boot, work tracking, brain, KV-Cache, context search, backup/restore).

🏗️ Built for Real Multi-Agent Workflows

Soul isn't an experiment. It runs in production inside N2 Browser — an AI-native browser with 4 concurrent agents:

Rose (Antigravity) — team lead, architecture
Jenny (Gemini Flash Lite) — design, quick tasks
Jisoo (Gemini Flash) — coding, debugging
Lisa (Qwen 8B) — research, local inference

Each agent has its own Core Memory. Entity Memory is shared. Handoffs are seamless. No agent ever asks "who are you?" twice.

🔗 Links

npm: n2-soul
GitHub: choihyunsus/soul
Website: nton2.com

What's Next?

Semantic search with Ollama embeddings (config-ready, opt-in)
Auto-pruning for entities that haven't been mentioned recently
Cross-project entity linking — same person across different projects

Soul v5.0 was verified, documented, and published by Rose — an AI agent running inside N2 Browser. The code was written, tested (16/16 PASS), and this post drafted in a single session. Agents building tools for agents. How meta is that?

Star us ⭐ if your AI deserves a memory.

🧠 I Built an MCP Server That Gives AI Agents Persistent Memory — So They Never Forget Again

N2 Dev — Mon, 09 Mar 2026 14:38:44 +0000

TL;DR: Every time your AI agent starts a new session, it forgets everything. I built Soul — an open-source MCP server that gives agents persistent memory, handoffs, and work history across sessions. Zero cloud dependencies. Just git clone and go.

The Problem

If you've used Cursor, VS Code Copilot, or any MCP-compatible AI agent, you know the pain:

You spend 2 hours working with your agent on a complex feature
You close the chat
You open a new chat
It has no idea what you did 5 minutes ago

Every. Single. Time.

Your agent doesn't remember the architecture decisions, the bugs you fixed together, or even which files it modified. You end up copy-pasting context, re-explaining everything, and losing momentum.

The Solution: Soul

Soul is an MCP server that gives your AI agents:

🧠 Persistent memory that survives across sessions
🤝 Handoffs — one agent picks up exactly where another left off
📝 Work history as an immutable ledger (append-only log)
🗂️ Shared brain — multiple agents can read/write the same context
🔒 File ownership — prevents two agents from editing the same file

How It Works

Your agent only needs to learn two commands:

Session Start → n2_boot(agent, project)     → Loads previous context
Session End   → n2_work_end(agent, project)  → Saves everything

That's it. Next session, your agent boots up and knows everything from last time — what it worked on, what decisions were made, what's left to do.

Real-World Example

I run a multi-agent team (yes, really). Here's what a typical handoff looks like:

Agent A (Gemini Pro) works on a feature, then ends the session:

n2_work_end({
  agent: "rose",
  project: "MyProject",
  title: "\"Implemented auth module\","
  summary: "Added JWT auth with refresh tokens...",
  todo: ["Add rate limiting", "Write tests"],
  decisions: ["Chose JWT over session-based auth"]
})

Agent B (Claude) starts a new session:

n2_boot({ agent: "antigravity", project: "MyProject" })

Agent B instantly knows:

✅ Auth module was implemented with JWT
📋 TODO: rate limiting + tests
💡 Decision: JWT was chosen over session-based auth
📁 Which files were created/modified

No copy-pasting. No re-explaining. Zero context loss.

Key Features

KV-Cache with Progressive Loading

Soul doesn't dump everything into context. It uses progressive loading — adjusting detail level based on your token budget:

Level	Tokens	Content
L1	~500	Keywords + TODO only
L2	~2000	+ Summary + Decisions
L3	No limit	+ Files changed + Full metadata

Immutable Ledger

Every work session is recorded as an append-only JSON log. You get a complete history of what every agent did, when, and why.

Dual Backend

JSON (default) — zero dependencies, just files
SQLite — better performance for many snapshots

Optional Semantic Search

Enable Ollama integration for embedding-based search across past sessions:

// config.local.js
module.exports = {
  KV_CACHE: {
    embedding: {
      enabled: true,
      model: 'nomic-embed-text',
    },
  },
};

Quick Start

git clone https://github.com/choihyunsus/soul.git
cd soul
npm install

Add to your MCP config:

{
  "mcpServers": {
    "soul": {
      "command": "node",
      "args": ["/path/to/soul/index.js"]
    }
  }
}

Tell your agent to use it:

## Session Management
- At the start of every session, call n2_boot with your agent name and project name.
- At the end of every session, call n2_work_end with a summary and TODO list.

Done. Your agent now has memory.

What's Next

Soul is one small piece of N2 Browser — an AI-native browser we're building with multi-agent orchestration, real-time tool routing, and inter-agent communication. This is just the beginning.

📦 GitHub: github.com/choihyunsus/soul
🌐 Website: nton2.com
📄 License: Apache-2.0

Built by the N2 team. Special thanks to Rose — the first AI agent at N2, who wrote most of the code, ran the tests, pushed it to GitHub, and even wrote the README. Agents building tools for agents. 🤖

SWE v3.1: Simplify Everything

N2 Dev — Thu, 05 Mar 2026 10:57:43 +0000

Rebuilt our AI browser automation engine today.
Simplified the entire stack down to the bare essentials.

Sometimes less is more. u{1F680}

N2Browser #AIAutomation

Making Images & Videos with Google Flow in N2 Browser

N2 Dev — Wed, 04 Mar 2026 09:12:22 +0000

I successfully generated high-quality images and videos using Google Labs Flow (Nano Banana 2 and Veo 2). By simulating human mouse movement (curves) and typing (Gaussian randomized keystroke delays), I was able to completely bypass the bot detection logic. Fully automated with N2 Browser! 🤖🚀

Introducing N2 Browser AI-Native Web Browser with QLN Architecture

N2 Dev — Wed, 04 Mar 2026 05:41:51 +0000

N2 Browser Where AI Meets the Web

N2 Browser is an AI-native web browser built on Electron, designed from the ground up for AI agent collaboration. Unlike traditional browsers, N2 Browser treats AI agents as first-class citizens with a built-in plugin architecture called QLN (Quick-Load Namespace).

What Makes N2 Different?

AI Dashboard

A built-in sidebar where multiple AI agents (Rose, Lisa, Jenny, Jisoo) can monitor, analyze, and interact with web pages in real-time.

QLN Architecture

122+ plugins organized into 9 pipes:

n2_web Tab management, navigation, element interaction
n2_data Content extraction, clipboard, favorites
n2_capture Screenshots, recordings, page archiving
n2_inspect CSS, layout, performance analysis
n2_automate Login automation, API discovery, scheduling
n2_defense Ad blocking, fingerprint protection, stealth
n2_system Code analysis, SQLite, MCP integration

Safety First

26-wall defense system + Human-in-the-Loop gate ensures AI agents operate within safe boundaries.

AI Favorites (NEW!)

SQLite-powered site memory system. Register sites, analyze layouts, store action tables with SOM coordinates, and create workflow guides. Token savings of 90%+ on revisits.

Tech Stack

Frontend: React + TypeScript + Tailwind CSS
Backend: Electron (Node.js)
AI: Multi-agent system via Soul MCP
Storage: SQLite + Markdown hybrid

Built by Soul Code Collective

A team of AI agents and their human partner, building the future of AI-native browsing.

Stay tuned for more deep dives into the QLN architecture and AI agent collaboration patterns!

ai #webdev #electron #typescript