A2A Agent Invention: A self-aware AI agent with dual MCP servers, Zero-Trust security, and a RAG feedback loop powered by MotherBrain.app (native MacOS app) MCP Tools, Multi-Vector Architecure Memory, and an Obsidian knowledge base #2055

native-apps · 2026-07-13T16:14:30Z

native-apps
Jul 13, 2026

Most AI agents are stateless chatbots behind an API. They forget everything between messages, can't take actions, and have no knowledge of the systems they serve.

We built something different...

Mother is our production AI agent — deployed from Mother Brain's A2A Agent Invention, a plugin for motherbrain.app. She lives on Cloudflare's global edge, speaks the A2A Protocol fluently, and connects to two independent MCP servers powered by Mother Brain's core, giving her 40 live tools. She serves three roles simultaneously — website onboarding guide, in-app support agent, and A2A integration partner for external AI clients like ChatGPT, Gemini, and Claude.

This isn't locked to our brand. The A2A Agent Invention is universal — any Mother Brain license owner can deploy their own agent. Add a Sub-Agent user, name it whatever you want, point it at your own Markdown knowledge base (like an Obsidian vault), and generate skills from that knowledge. Your agent, your identity, your domain — running on the same infrastructure.

Try ours live: a2a.motherbrain.app | Open source invention: github.com/native-apps/a2a-agent-invention | Powered by: motherbrain.app

But what makes her genuinely different isn't the tool count or the protocol compliance. It's the feedback loop.

Mother doesn't just answer questions. Every conversation she has — every visitor question on the website, every support ticket from the desktop app, every A2A message from an external agent — feeds back into a vectorized Obsidian knowledge base via Mother Brain. Owners can curate conversations into memories through the CRM dashboard — tagging support questions, bug reports, and feature requests that make the agent smarter over time. When the next visitor asks a similar question, Mother already knows the answer.

This is a living RAG loop — conversations improve the knowledge base, and the knowledge base improves conversations. (Note: The CRM-to-memory pipeline is currently manual — owners curate. Automated curation is on the roadmap.)

Live endpoint: https://a2a.motherbrain.app
Agent Card: https://a2a.motherbrain.app/.well-known/agent.json
Website: https://motherbrain.app
A2A Agent Invention (open source): https://github.com/native-apps/a2a-agent-invention

TL;DR

Capability	Details
Protocol	A2A v1.0 compliant (JSON-RPC 2.0 over HTTPS)
MCP Integration	Dual servers — 40 live tools (project knowledge + website control)
Security	7-layer Zero-Trust (JWT, license key, anonymous, rate limiting, token protection)
Uptime	4-tier LLM fallback — never goes offline, even when the host is down
Intelligence	VMVA 3-model cascade (up to 90% token savings), session-less Total Recall, Obsidian-powered RAG loop
Cross-device	QR-paired devices share one conversation thread
Channels	Website chat, in-app support, public A2A — one agent, three roles

How It Uses the A2A Protocol

The agent is fully A2A Protocol v1.0 compliant, built on JSON-RPC 2.0 over HTTPS.

JSON-RPC Methods

Method	Purpose
`ping`	Health check — returns `{ status: "ok" }`
`message/send`	Send a message to the agent (creates or appends to a task)
`tasks/get`	Retrieve the state of a task
`tasks/cancel`	Cancel an in-progress task
`tasks/getArtifacts`	Retrieve artifacts produced by a task
`visitor/suggestions`	Get AI-generated suggested questions for a visitor
`visitor/history`	Get a visitor's conversation history (cross-device aware)
`agent/suggest-skills`	AI generates skill suggestions from the knowledge base
`agent/getCard`	Get the agent card via JSON-RPC (complements HTTP GET at `/.well-known/agent.json`)

Agent Card (`/.well-known/agent.json`)

The Agent Card is dynamically generated from Worker env vars — each deployment gets its own identity:

Endpoint URL, protocol binding (JSON-RPC), and protocol version
Capabilities: Push notifications (disabled), extended agent card (disabled). (Agent card declares streaming: true; current implementation uses a client-side typewriter reveal effect — true SSE streaming is on the roadmap.)
Security: Bearer token authentication
Input/output modes: text/plain and application/json
Skills: Declared dynamically from AGENT_SKILLS_JSON env var (A2A v1.0 spec: id, name, description, tags, examples, inputModes, outputModes)

Served at three discovery endpoints: /.well-known/agent-card.json, /.well-known/agent.json, /agent.json

The RAG Loop — A Living Knowledge Base (Design)

Note: This describes the intended knowledge flow. The CRM-to-memory pipeline is currently manual (owners curate conversations into memories). Automated curation via a Sub-Agent is on the roadmap. The Obsidian vault vectorization, MCP tools, and CRM dashboard are all fully implemented.

This is what sets Mother apart from every other A2A agent: conversations feed the knowledge base, and the knowledge base feeds conversations.

How It Works

                    ┌─────────────────────────────────┐
                    │     Obsidian Knowledge Base     │
                    │   (Local vault, vectorized via  │
                    │    Mother Brain into Supabase)  │
                    └──────────┬──────────┬───────────┘
                               │          │
                  Vectorized   │          │ Firecrawl MCP
                  into pgvector│          │ (reads website docs)
                               │          │
                    ┌──────────▼──────────▼─────────────┐
                    │   Owner (via CRM Dashboard)       │
                    │  (Currently manual curation)      │
                    │                                   │
                    │  - Reviews website docs via       │
                    │    Firecrawl MCP tools            │
                    │  - Reviews incoming support       │
                    │    chat conversations             │
                    │  - Updates Obsidian vault with    │
                    │    new patterns, answers, FAQs    │
                    └──────────┬────────────────────────┘
                               │
                     Knowledge │ flows back into
                               │ the vector index
                               v
                    ┌───────────────────────────────────┐
                    │          Mother (A2A Agent)       │
                    │                                   │
                    │  Searches the vectorized vault    │
                    │  via MCP tools (search_memories,  │
                    │  search_codebase, vmva_search)    │
                    │                                   │
                    │  Every answer is grounded in the  │
                    │  accumulated knowledge base       │
                    └──────────┬────────────────────────┘
                               │
                               │ Answers visitors
                               │ on website + app
                               │
                               v
                    ┌─────────────────────────────────┐
                    │  New conversations create new   │
                    │  knowledge → Owner documents    │
                    │  it → next answer is better     │
                    └─────────────────────────────────┘

The Components

Obsidian Vault (Knowledge Source)
The project's knowledge base is maintained as a local Obsidian vault. Mother Brain vectorizes every note into Supabase pgvector using the VMVA 3-layer cascade (voyage-4-lite → voyage-4 → voyage-code-3). Visitor messages are embedded with voyage-4-large. When Mother searches for knowledge, she's searching the vectorized vault — not a static document, but a living, evolving intelligence layer.

CRM-to-Memory Pipeline (Knowledge Curator)
Owners use the CRM dashboard in the Mother Brain app to review every conversation — from website visitors, in-app users, and external AI agents. Useful exchanges are converted into tagged memories (support, bug, feature-request, docs) that get vectorized and stored in pgvector. Future conversations benefit from this accumulated knowledge.

[PLANNED] An automated Sub-Agent (e.g., OpenClaw) that monitors conversations and documents new knowledge patterns without manual intervention.

Mother (A2A Agent — Knowledge Consumer)
Mother accesses the vectorized vault through Mother Brain's MCP tools (search_memories, search_codebase, vmva_search, search_chat_history). Every response is grounded in the accumulated knowledge — not hallucinated, not guessed.

Why This Matters

Most RAG systems are one-directional: you index documents, the AI searches them. Ours is bidirectional: conversations create knowledge that improves future conversations. The knowledge base gets smarter every day through owner curation — with automated curation on the roadmap.

Mother's Three-Layer Knowledge Organization

Note: This is a conceptual model of how knowledge is organized, not a technical architecture with three separate code modules. Technically, all knowledge lives in a unified pgvector index and is searched via the same MCP tools. The three layers describe the sources of knowledge, not separate databases.

Mother's intelligence draws from three nested knowledge sources. Each layer is progressively broader and more detailed:

Layer 1 (Innermost): Core - Mother Brain Internal Docs & APIs

The source of truth. This is Mother Brain's own internal documentation — API schemas, database architecture, code index, deployment configs, and internal systems. Mother accesses this layer through Mother Brain's MCP tools (search_codebase, vmva_search, get_file_content). It is never exposed publicly.

Layer 2 (Middle): Official Website Documentation

The public knowledge. The documentation pages at motherbrain.app/docs — covering every feature, architecture overview, VMVA, A2A protocol, embedded PostgreSQL, and more. Mother reads these via Mother Brain's MCP tools (which access vectorized knowledge including Brainstorm Mode outputs) and via Firecrawl web scraping. This is what visitors see on the website. (Brainstorm Mode is a Mother Brain feature — Mother accesses its vectorized results, not the feature itself.)

Layer 3 (Outermost): Mother's Hidden Knowledge Base

The intelligence layer. This is a much larger, more extensive knowledge base that does not exist on the website or in the app's internal docs. It includes:

Extended documentation written specifically for Mother (deeper than public docs)
Accumulated support conversation patterns (captured by the RAG Loop)
Images in Mother Brain's Media Library (analyzable via OpenCV + OCR)
Continuously indexed website content via Firecrawl
Vectorized chat history from all visitor and user conversations

When a visitor asks a question, Mother searches all three layers — but the richest, most detailed answers come from Layer 3, the hidden knowledge that makes her responses feel genuinely intelligent rather than scripted.

Dual MCP Server Architecture

This is the core differentiator. The A2A Agent connects to two independent MCP servers simultaneously, giving it both project knowledge and website control:

MCP Server 1: Project Knowledge Gateway (Mother Brain Local)

Connected via the Mother Brain Cloudflare Gateway with Zero-Trust authentication. Provides 27 tools for accessing the host project's vectorized knowledge base:

Tool	Description
`search_codebase`	Semantic code search across the entire codebase
`vmva_search`	Vertical MVA 3-layer cascading vector pipeline (file filter, meta description, deep code chunk)
`search_memories`	Vector + keyword search across knowledge memory store (facts, decisions, summaries)
`search_chat_history`	Vector search across all past conversations (Total Recall)
`search_git_history`	Vector + keyword search across indexed git commits
`add_memory`	Store new facts, decisions, or summaries with tags
`get_project_stats`	Record counts for all Mother Brain tables
`list_images`	Browse images in the project's Media Library
`list_indexed_files`	List all indexed file paths in the code index
`get_file_content`	Get all indexed chunks for a specific file
`analyze_image`	OpenCV (WASM) vision + Tesseract.js OCR analysis on an image
`get_instructions`	Read the project's instructions for AI assistants
`training_cycle_start`	Start a Training Cycle on a ROM to build knowledge
`firecrawl_scrape`	Scrape content from a URL (markdown, HTML, JSON, screenshots)
`firecrawl_search`	Search the web with structured extraction
`firecrawl_map`	Map a website to discover all indexed URLs
`firecrawl_extract`	Extract structured data from web pages using LLM
`firecrawl_parse`	Parse documents (PDF, Word, Excel, HTML)
`firecrawl_agent`	Autonomous web research agent
`firecrawl_research_search_papers`	Semantic search across AI/ML research papers
`firecrawl_research_related_papers`	Expand via citation graph (similar, citers, references)
`firecrawl_research_read_paper`	Read in-body passages of a specific paper
`firecrawl_research_search_github`	Search GitHub issues, PRs, and repos
`gateway_status`	Check Cloudflare Gateway health
`list_skills`	List available agent skills
`skill`	Retrieve a specific skill's instructions
`spawn_agent`	Spawn a sub-agent for a scoped task

MCP Server 2: Website Controller (API MCP)

Exposes 13 tools for live website interaction — the agent doesn't just answer questions, it takes actions on the website:

Tool	Description
`website.list_pages`	List all public pages
`website.read_page`	Read full markdown content of any page by slug
`website.create_page`	Create a private page for the visitor (stored as markdown)
`website.edit_page`	Update a generated page (system pages are read-only)
`website.delete_page`	Delete a generated page
`website.navigate`	Generate a navigation action — renders as clickable link in chat
`website.highlight`	Find a heading on a page and scroll-to-highlight with visual pulse
`website.get_visitor_status`	Check if visitor is a customer (plan, license info)
`website.get_account`	Get full account details (licenses, subscription, email)
`website.update_account`	Update customer account fields (name, etc.)
`website.get_referrals`	Get referral code, sign-up count, commission info
`website.list_inventions`	List all available content from the website registry
`website.analytics`	View page view analytics (total views, unique visitors, top pages)

How the Dual-MCP Agentic Loop Works

Visitor asks: "Does Mother Brain work with Cursor?"
       |
       v
A2A Worker -> AI Router (with ALL tools from both MCP servers)
       |
       +- AI calls website.read_page("mcp-server")
       +- AI calls website.get_visitor_status(visitorId)
       +- AI calls search_codebase("Cursor MCP integration")
       |
       v
AI synthesizes: explains MCP compatibility with Cursor +
    clickable "View Docs" link to setup guide

The agent autonomously decides which tools to call, executes them through the appropriate MCP server, and synthesizes a response. Up to 5 rounds of tool-calling per message.

Zero-Trust Security Architecture

Security is the foundational design principle. The A2A Agent operates under a default-deny Zero-Trust model across every layer:

Layer 1: Network Isolation

Isolated Database — The A2A Agent has its own Supabase database (a2a_agent_chat), completely separate from the host project's private data. Visitor messages never touch the project's code, memories, or chat history.
Invention Attribution — Every request includes X-Mother-Brain-Invention and X-Mother-Brain-Source headers so the AI Router can identify, isolate, and attribute all invention traffic.
Three detection signals — The AI Router uses user type, invention header, and app name to identify and isolate traffic from the A2A Agent.

Layer 2: Triple-Path Authentication

The agent supports three authentication paths, resolved in priority order:

Path	Source	Credential	Customer Linking
JWT Session	Website widget (logged-in user)	`Authorization: Bearer <jwt>` (HS256 via Web Crypto API)	`sub` claim to customer_id
License Key	macOS app (in-app support)	`metadata.license_key` to Encore API resolution	Returns customer_id + visitor_id
Anonymous	First-time website visitor	Broprint.js fingerprint to visitor_id	None (stays anonymous)

Fail-closed policy: If a JWT is presented but JWT_SECRET is not configured, the Worker returns 503 — it never silently downgrades security.

Layer 3: Credential Scoping

Project Owner
  +- creates Sub-Agent user (type: "agent")
       +- gets accessToken: mb_<uuid> (scoped to this agent only)
            +- A2A Worker sends TWO credentials on every Gateway request:
                 +- Authorization: Bearer ${GATEWAY_TOKEN}     (project access)
                 +- X-Mother-Brain-User-Token: ${USER_TOKEN}   (agent attribution)

The AI Router validates both credentials. The agent can only access what the Sub-Agent user has been explicitly granted.

Layer 4: Chat History Isolation (Shared-Computer Safe)

On shared computers, chat history is isolated by customer_id:

Smart Backfill — claim_anonymous_messages() RPC only claims messages where customer_id IS NULL. Messages already owned by another customer are never touched.
History queries filter by customer_id when a JWT is present — User B cannot see User A's history on the same device.
Cross-device sync — When authenticated, the agent resolves ALL visitor_ids for a customer (phone, tablet, desktop paired via QR login) and queries history across all of them.

Layer 5: Rate Limiting & Input Validation

Dual rate limiting — IP-based (sliding window) + per-visitor (visitor_id). In-memory by default; production deployment uses Cloudflare KV for persistence across Worker restarts. Returns HTTP 429 with Retry-After and X-RateLimit-* headers. Rate limited at 20 requests/minute per IP and per visitor.
JSON-RPC validation — Structure, method, and params validation on every request.
Message sanitization — Input sanitization on all user text before storage or LLM processing.
[PLANNED] visitor_id format validation (prefix check, length limits) — currently in production deployment, not yet in the open-source invention.
Security directives — The system prompt includes explicit security guardrails (never reveal tokens, keys, internal architecture, etc.). These are enforced even in offline mode.

Layer 6: Client-Side Token Protection (Website)

Note: These protections are implemented on the website/client side, not in the open-source invention Worker.

JWT obfuscation — Session tokens stored in browser localStorage are XOR + base64 encoded with a per-browser key. Not plaintext-readable by casual inspection.
Clear-on-tab-close — Sessions without "remember me" are automatically cleared when the browser tab closes.
No license key persistence — JWT-authenticated users no longer have their license key written to localStorage.
Security headers — HSTS, X-Frame-Options: DENY, X-Content-Type-Options: nosniff (configured at Cloudflare edge).
CORS lockdown — Production deployment restricts origins to motherbrain.app (the open-source invention uses origin: * for embeddability).

Layer 7: Public Repository Safety

The invention is open source on GitHub. Security measures for public distribution:

Zero hardcoded secrets — All credentials deployed as Cloudflare Worker secrets via the MB app Deploy action. wrangler.toml contains only ENVIRONMENT and AI_MODEL.
Public tarball cleaning — The deploy script strips all vendor-specific content (agent identity, URLs, personality, API keys) from the public distribution. Each user gets a clean, generic agent.
All features optional — Every integration feature (JWT, license resolution, website MCP, Gateway) gracefully degrades when not configured. No crashes, no behavior change.

4-Tier LLM Fallback Chain (Zero Downtime)

The agent is always available — even when the host infrastructure is completely down. This is achieved through a cascading fallback chain:

+------------------------------------------------------+
|  Tier 1: MCP Gateway + AI Router (Full Intelligence) |
|  - Agentic chat with 40 MCP tools                    |
|  - Uses the project owner's configured LLM           |
|  - Up to 5 rounds of tool-calling per message        |
|  Status: Primary (host online)                       |
+--------------------------+---------------------------+
                           | Gateway unreachable
                           v
+------------------------------------------------------+
|  Tier 2: Supabase Vector Knowledge + Gateway LLM     |
|  - Vector search (memories, code, chat history)      |
|  - Synthesize response via Gateway LLM (no tools)    |
|  Status: Degraded but intelligent (Gateway AI up)    |
+--------------------------+---------------------------+
                           | Gateway LLM also unreachable
                           v
+------------------------------------------------------+
|  Tier 3: Cloudflare Workers AI (Independent)         |
|  - Vector search Supabase (same knowledge retrieval) |
|  - Synthesize via Llama 3.3 70B on CF edge           |
|  - Completely independent of the MCP Gateway         |
|  Status: Offline but intelligent (host down)         |
+--------------------------+---------------------------+
                           | Workers AI unavailable
                           v
+------------------------------------------------------+
|  Tier 4: Cleaned Context Response                    |
|  - Returns retrieved knowledge in readable format    |
|  Status: Last resort (all LLMs down)                 |
+------------------------------------------------------+

Key insight: Tier 3 (Cloudflare Workers AI) is the critical innovation. When the Gateway is completely unreachable, the Worker queries the project's Supabase database directly (vector search works — it's a separate service), then feeds the retrieved knowledge to Llama 3.3 70B running on Cloudflare's edge infrastructure. The visitor gets an intelligent, synthesized response — never a raw data dump, never a "sorry, I'm offline" message.

Three-Channel Intelligent Routing

The agent detects which of three channels a message originates from and adapts its behavior, tone, and skill selection:

Channel	Source	Auth Path	Role	Behavior
In-App Support	Authenticated MB users (macOS app)	License key to customer_id	Support Agent	Warm, ticket-oriented, links to past conversations
Public A2A	External AI agents (Gemini, Claude, ChatGPT, Perplexity)	None (anonymous)	Integration Agent	Precise, machine-friendly, protocol-aware
Website Chat	Visitors on the website	JWT or anonymous	Onboarding Guide	Conversational, value-focused, navigates site

The system prompt is dynamically constructed per-channel with:

Agent identity (configurable name + description, or default personality)
Security directives (never reveal internals — enforced even offline)
Skill-specific role (behavioral guidance for the detected skill)
Tool selection guidance (which tools to prefer for this skill)
Visitor context (recalled from past conversations via Total Recall)

Cross-Device Chat Continuity

When a user pairs multiple devices (phone, tablet, desktop) via QR code login, the agent provides seamless cross-device chat history:

Each device gets its own visitor_id (Broprint.js canvas + audio fingerprint)
All device fingerprints are linked to one customer_id via the auth system
When loading history, the Worker calls resolve-visitor-ids to get ALL visitor_ids for the customer
Queries across all devices — the user sees the same conversation regardless of which device they're on

5-minute cache on device resolution to avoid redundant API calls.

License-to-Visitor Linking (Unified Support Chat)

When anonymous visitors chat on the website and later purchase, their full conversation history is automatically unified:

Anonymous website chat — tracked by visitor_id in localStorage + browser fingerprint
Visitor purchases — enters license key in the Mother Brain desktop app
First in-app message — includes license_key in metadata
Worker resolves license_key to visitor_id via Encore Subscriptions API
Smart backfill — claim_anonymous_messages() links all anonymous messages to the customer
Unified thread — All website + in-app conversations appear as one continuous history

Whether a visitor asked a pre-sales question on the website, reported a bug in-app, or chatted from their phone — it's one conversation thread with full context.

AI-Generated Prompt Suggestions

When a visitor opens the chat widget, the agent generates personalized suggested questions:

Returning visitors — Suggestions based on their past conversation history
First-time visitors — General onboarding prompts based on the knowledge base
Capped at 24 per visitor (2 batches of 12) to bound AI token spend
Background preloaded — Suggestions are fetched the moment a visitor lands (before they even open chat), cached in localStorage
Used-prompt tracking — Clicked suggestions are dimmed and marked

Powered by the visitor/suggestions JSON-RPC method, which calls the AI model with the visitor's conversation context.

AI-Powered Skill Generation

The agent includes an AI Skill Suggestion feature (agent/suggest-skills JSON-RPC method):

Reviews the packed knowledge base (SOUL.md, docs, FAQ)
Checks if website MCP tools are configured (factors them in if so)
Generates 4-6 A2A v1.0 compliant skill suggestions (all 7 fields: id, name, description, tags, examples, inputModes, outputModes)
Automatically excludes duplicates of existing skills
Presents them in a modal for the owner to select which to add
Skills are editable inline and draggable to reorder

This means any user can deploy the agent and have AI generate appropriate skills for their specific product — no manual configuration needed.

CRM Dashboard with Conversation-to-Memory Pipeline

The Mother Brain app includes a full CRM dashboard for monitoring every conversation:

Human vs Bot detection — Each conversation tagged with visitor type (human, AI agent, search crawler)
Tool call logging — Every MCP tool invocation visible per conversation
Entity metadata — Visitor ID, entity type, source (website/in-app), message count, first/last seen, tags, status
Filtering and sorting — by entity type, source, status, tags (Entities view)
Entity tracking — Visitors, Customers, and AI Bots as separate entity types

The Feedback Loop

Visitor Conversation
  -> Owner reviews in CRM Dashboard
  -> Converts useful exchanges to Memories (tagged: support, bug, feature-request)
  -> Memories are vectorized and stored in pgvector
  -> Agent uses Memories in future conversations
  -> Better answers -> More conversions -> Smarter agent

The more the agent talks, the smarter it gets. Owners curate that intelligence through the CRM.

Configurable Agent Identity

Every aspect of the agent is configurable — it's not locked to any brand:

Agent Name — Any name (default: "Mother" for our deployment, "AI Assistant" for public)
Agent Description — Custom role description
Agent URL — Deployed endpoint URL
Widget Color — Customizable accent color (default: neon green #39ff14)
Widget Branding — Customizable footer text
Skills — Full CRUD editor with AI suggestions, drag-to-reorder, all 7 A2A v1.0 fields
Bot User — Select which Sub-Agent user the agent impersonates (identity auto-populates)

When deployed, the agent card, system prompt, and personality all reflect the configured identity. The public tarball ships with generic defaults.

Pure SVG Hero Search Interface

The chat widget features an octagonal Hero Search built entirely with pure SVG — no images, no canvas, no external assets:

Crisp at any resolution — Vector graphics scale from mobile to 4K
Tiny footprint — No image assets to load, instant render
Animated — Neural network background, pulsing brain icon, status indicators
Themeable — Widget color is customizable, SVG elements adapt dynamically
Drag-to-resize — Chat panel height is adjustable via pointer events (mouse + touch), persists to localStorage
Fullscreen mode — Expands to full-page immersive experience
Responsive — Layout reflows for phone screens and desktop

Supabase pgvector Persistent Memory

The agent uses Supabase (PostgreSQL + pgvector) as its cloud-side persistent memory:

Every visitor conversation is vectorized (Voyage AI embeddings, 1024 dimensions) and stored
Semantic search across all past conversations (Total Recall for website visitors)
Visitor ID tracking via Broprint.js (canvas + audio fingerprint) + localStorage
Session isolation — each visitor's history is independent
Cross-device sync — authenticated users see history across all paired devices
Dual storage — local (embedded PostgreSQL), remote (Supabase), or both (sync)

Image Analysis Capabilities

The agent can analyze images through Mother Brain's vision tools (accessible via MCP when the Gateway is connected):

OpenCV (WASM) — Edge detection, dominant colors, shape detection, feature extraction
Tesseract.js OCR — Text extraction from images
analyze_image MCP tool — Analyzes images stored in the Mother Brain project's Media Library

[PLANNED] Visitor-side image upload (screenshots, photos) from the chat widget. Currently, image analysis works on project Media Library assets — not visitor-uploaded images.

Technology Stack

Layer	Technology
Agent Runtime	Cloudflare Workers (Hono framework)
Protocol	A2A v1.0 (JSON-RPC 2.0 over HTTPS)
AI Router	Mother Brain Cloudflare Gateway (Zero-Trust)
Local Server	Mother Brain embedded Node.js (Tauri/Rust host)
Local Database	PostgreSQL 17 + pgvector (embedded)
Cloud Database	Supabase (PostgreSQL + pgvector)
Embeddings	Voyage AI (`voyage-4-large` for text, `voyage-4-lite`/`voyage-4`/`voyage-code-3` for VMVA cascade)
Vector Search	VMVA 3-layer cascading pipeline
Offline LLM	Cloudflare Workers AI (`@cf/meta/llama-3.3-70b-instruct-fp8-fast`)
JWT Verification	Web Crypto API (HMAC-SHA256, native to CF Workers)
Frontend/Widget	React + Vite + TypeScript, Pure SVG
Desktop App	Tauri + Rust + React + TypeScript
Visitor Fingerprinting	Broprint.js (canvas + audio)

Embeddability

The A2A Agent is designed to be embedded on any website:

React widget bundle (motherbrain-widget/) — importable React components for any React project
<HeroSearchHost /> — All-in-one hero section with AI suggestion dropdown
<ChatApp /> — Fullscreen chat overlay with markdown rendering + typewriter streaming reveal
<SuggestionsPreloader /> — Invisible background suggestion generator
Web component (<ne-hero-search>) — Framework-agnostic custom element with Shadow DOM for any framework
Framework support: React + Web Component (current), Vue.js (planned), more to come
Customizable color, branding, agent name, and description
CORS-enabled for any domain
Visitor ID tracking via Broprint.js + localStorage (shared key with website)

Architecture Diagram

+----------------------------------------------------------+
|                    Visitor / External Agent              |
|            (Website / External AI / In-App Support)      |
+----------------------------+-----------------------------+
                             | JSON-RPC 2.0 over HTTPS
                             | (JWT / License Key / Anonymous)
                             v
+----------------------------------------------------------+
|               A2A Endpoint (CF Worker)                   |
|              a2a.motherbrain.app (Hono)                  |
|                                                          |
|  - Agent Card (/.well-known/agent.json) -- dynamic       |
|  - 3-Channel Routing (Website / A2A / In-App)            |
|  - Triple-Path Auth (JWT -> License Key -> Anonymous)    |
|  - Rate Limiting (IP + Visitor ID)                       |
|  - Input Validation & Sanitization                       |
|                                                          |
|  +----------------------------------------------------+  |
|  |            4-Tier LLM Fallback Chain               |  |
|  |  Tier 1: Gateway AI + MCP Tools (40 tools)         |  |
|  |  Tier 2: Supabase Vector Search + Gateway LLM      |  |
|  |  Tier 3: Supabase Vector Search + Workers AI (70B) |  |
|  |  Tier 4: Cleaned Context Response                  |  |
|  +----------------------------------------------------+  |
+----------------------------+-----------------------------+
                             | Zero-Trust Auth
                             v
+----------------------------------------------------------+
|                Mother Brain Cloudflare Gateway           |
|           (User Access Token + Project API Key)          |
|           (Zero-Trust default-deny validation)           |
+----------+-----------------------------------+-----------+
           |                                   |
           v                                   v
+-------------------------+     +-----------------------------+
|  Mother Brain Local     |     |   Website MCP Controller    |
|     MCP Server          |     |   (13 website tools)        |
|                         |     |                             |
|  - 27 Knowledge Tools   |     |  - Read/Create/Edit Pages   |
|  - Code Index (VMVA)    |     |  - Navigate + Highlight     |
|  - Memories             |     |  - Visitor Status + Account |
|  - Chat History         |     |  - Referrals + Analytics    |
|  - Git History          |     |  - Inventions Registry      |
|  - Image Analysis       |     |                             |
|  - Firecrawl (Web)      |     |                             |
|  - Research Papers      |     |                             |
+-------------------------+     +-----------------------------+
           |
           v
+----------------------------------------------------------+
|               Storage Layer (Dual Sync)                  |
|                                                          |
|  +----------------------+   +-------------------------+  |
|  |  A2A Agent DB        |   |  Mother Brain Project   |  |
|  |  (Isolated Supabase) |   |  DB (Local + Remote)    |  |
|  |                      |   |                         |  |
|  |  - Visitor chats     |   |  - Code index           |  |
|  |  - Session isolation |   |  - Memories             |  |
|  |  - Vector embeddings |   |  - Chat history         |  |
|  |  - Customer linking  |   |  - Git history          |  |
|  |                      |   |  - Images               |  |
|  |  NEVER touches       |   |  NEVER touched by       |  |
|  |  project data        |   |  visitors               |  |
|  +----------------------+   +-------------------------+  |
+----------------------------------------------------------+

Complete Feature List

Protocol & Architecture

A2A Protocol v1.0 compliant (JSON-RPC 2.0 over HTTPS)
Dynamic Agent Card at /.well-known/agent.json (+ variants)
9 JSON-RPC methods (ping, message/send, tasks/get, tasks/cancel, tasks/getArtifacts, visitor/suggestions, visitor/history, agent/suggest-skills, agent/getCard)
Three-channel routing (Website / Public A2A / In-App Support)
Dual MCP server integration (Project Knowledge + Website Control)
Agentic tool-calling loop (up to 5 rounds, 40 tools)
Configurable agent identity (name, description, URL, skills)
Dynamic system prompt construction (identity + security + skill + tools + context)

Security (7-Layer Zero-Trust)

Network isolation (own Supabase database, never touches project data)
Triple-path authentication (JWT -> License Key -> Anonymous)
JWT verification via Web Crypto API (HS256, fail-closed)
Credential scoping (Sub-Agent User Access Tokens)
Chat history isolation (shared-computer safe, smart backfill)
Dual rate limiting (IP + visitor_id, 20 req/min sliding window; production uses Cloudflare KV)
Input validation + message sanitization + visitor_id format validation
JWT obfuscation in localStorage (XOR + base64, per-browser key)
Clear-on-tab-close for non-persistent sessions
Security headers (HSTS, X-Frame-Options, X-Content-Type-Options) — configured at Cloudflare edge
CORS lockdown to motherbrain.app (production deployment; invention uses origin: * for embeddability)
Security directives in system prompt (enforced even offline)
Zero hardcoded secrets in public repo
Public tarball cleaning (strips all vendor-specific content)
Invention attribution headers (X-Mother-Brain-Invention, X-Mother-Brain-Source)

AI & Intelligence

4-tier LLM fallback chain (Gateway -> Supabase+Gateway -> Supabase+Workers AI -> Cleaned Context)
Cloudflare Workers AI offline fallback (Llama 3.3 70B fp8-fast)
Supabase pgvector semantic search (memories, code, chat history)
Voyage AI embeddings (3-model VMVA cascade: voyage-4-lite, voyage-4, voyage-code-3/voyage-4-large — 1024 dimensions)
VMVA 3-layer cascading vector search pipeline
AI-generated prompt suggestions (personalized per visitor)
AI-powered skill generation (agent/suggest-skills)
Total Recall (vectorized visitor conversation history)
Background suggestion preloading (instant chat open)

Cross-Device & Unified Chat

Cross-device chat continuity (QR login -> all devices see same history)
Device resolution with 5-minute cache
License-to-visitor linking (anonymous -> customer unified thread)
Smart backfill (claim_anonymous_messages RPC -- shared-computer safe)
Customer ID tracking across all surfaces

Website Control (13 MCP Tools)

Read/Create/Edit/Delete pages
Navigate + scroll-to-highlight
Visitor status + account management
Referral tracking
Analytics (page views, unique visitors, top pages)
Inventions registry listing
Graceful degradation (silent off when unconfigured)

Knowledge Tools (27 MCP Tools)

Code search (semantic + VMVA 3-layer pipeline)
Memory search (facts, decisions, summaries)
Chat history search (Total Recall)
Git history search
Image analysis (OpenCV WASM + Tesseract OCR)
File content reading
Project stats + instructions
Firecrawl suite (scrape, search, map, extract, parse, agent)
Research paper search (semantic + citation graph)
GitHub search (issues, PRs, repos)
Training cycles (ROM knowledge building)
Sub-agent spawning

CRM & Monitoring (Mother Brain Desktop App)

Full CRM dashboard (all conversations, entity tracking)
Human vs Bot detection
Tool call logging per conversation
Entity tracking (Visitors, Customers, AI Bots)
Conversation-to-Memory pipeline (feedback loop)
Full-text + semantic search

Note: The CRM dashboard is part of the Mother Brain desktop app — the A2A Agent feeds data into it, but the dashboard UI lives in the app.

Widget & UI

Pure SVG Hero Search (octagonal, animated, themeable)
Fullscreen chat mode
Drag-to-resize panel (pointer events, persists height)
Typewriter streaming effect (client-side reveal with real-time markdown rendering)
Markdown rendering
Rich image knowledge base (app screenshots, architecture diagrams)
AI suggestion dropdown (clickable, used-tracking, 24-cap)
Background suggestion preloader
Web component (<ne-hero-search> with Shadow DOM) + React components (<HeroSearchHost />, <ChatApp />)
Responsive (desktop, tablet, mobile)
Broprint.js visitor fingerprinting (canvas + audio)

Configuration & Deployment (Mother Brain App)

One-click Cloudflare Worker deployment (via MB app Deploy button)
All secrets deployed via MB app (no wrangler CLI needed)
Configurable agent identity (name, description, URL, branding, color)
Full skills editor (CRUD, drag-to-reorder, AI suggestions)
Database mode selection (local / remote / both)
Embedding configuration (provider, model, API key, dimensions)
Show/hide tool calls, thinking, reasoning in chat
Multi-project support

Note: These are Mother Brain desktop app features. The A2A Agent is configured through the app's settings UI — the Worker itself is headless.

VMVA Benchmark — Up to 90% Token Savings

Mother Brain includes a built-in VMVA Benchmark Tester that proves the quality and efficiency of the 3-layer cascade:

Tests real queries against indexed codebases
Shows exact retrieval quality (precision + recall)
Measures token consumption vs. brute-force context stuffing
Up to 90% token savings — a query that returns 10,660+ rows from a raw vector database returns ~150 rows through Mother Brain's VMVA cascade, with higher accuracy. The LLM only sees what matters.
Results are reproducible and auditable

📖 Full benchmark documentation

Session-less Chat — Total Recall

Mother Brain doesn't have "chat sessions" in the traditional sense. Every conversation, across every project, across every session, is forever:

Start a new chat → Mother Brain recalls all previous context
Switch projects → cross-project memory persists
Close and reopen the app → zero context loss
All conversations are vectorized and searchable via search_chat_history
The AI never asks "can you remind me what we discussed?" — it already knows

Complete Third-Party Stack

Service	Purpose
Cloudflare Workers	A2A endpoint hosting (global edge)
Cloudflare R2	App release distribution (DMG hosting with S3-compatible API)
Cloudflare Workers AI	Offline LLM fallback (Llama 3.3 70B fp8-fast)
Cloudflare KV	Rate limiting persistence in production deployment (survives Worker restarts)
Cloudflare Gateway	MCP tunnel to local Mother Brain instance
Supabase (pgvector)	A2A Agent chat database + vector embeddings
Encore	API backend (auth, subscriptions, downloads, MCP tools)
Stripe (+ Connect) (Website/Encore API)	Payments, beta tester program, referral payouts
Voyage AI	Embedding models (voyage-4-lite, voyage-4, voyage-code-3)
Firecrawl	Web scraping, research, document parsing, autonomous agents
Broprint.js	Visitor fingerprinting (canvas + audio fingerprint)
Hono	Web framework for Cloudflare Workers (A2A endpoint)
Tauri (Rust)	Desktop app framework (macOS, cross-platform)
PostgreSQL	Embedded local database (local-first architecture)
pgvector	Vector similarity search extension for PostgreSQL
jose (Website)	JWT verification (HS256, edge-compatible). The A2A Agent invention uses raw Web Crypto API.
OpenAI-compatible	AI Router supports any OpenAI API-compatible LLM

Mother Brain Feature Ecosystem

The A2A Agent is the flagship Invention (plugin) for Mother Brain. The full platform includes:

System	Description
VMVA Code Index	3-layer cascade vector search (voyage-4-lite -> voyage-4 -> voyage-code-3). Benchmark-proven up to 90% token savings.
Total Recall	Session-less chat history. Every conversation, every project, forever. Vectorized and searchable.
Cipher	Persistent knowledge memories with attribution (user + source + model). Facts, decisions, summaries. Powered by Byterover.
ROMs	Training Cycles — structured knowledge building. AI studies a topic and builds a curated knowledge base.
Cerebellum	Built-in `/mother` command router and FunctionGemma 270M ONNX model for slash command interpretation and internal app operations.
RBAC	Role-Based Access Control — granular permissions per user/project.
QR Camera Auth (Website)	Cross-device pairing via persistent QR codes. Scan to authenticate across phone, tablet, desktop.
Full 2FA/MFA (Website/Encore API)	TOTP (all authenticator apps), WebAuthn/YubiKey, Wallet/SIWE, Passphrase (argon2id), Backup Codes. JWT sessions (1hr/24hr). MB desktop app uses Touch ID App Lock for local security.
Inventions System	Plugin architecture. A2A Agent is the flagship. Third-party plugins supported.
Skills Registry	Modular AI agent capabilities — create, edit, drag-to-reorder, AI-suggested skills.
Git History Indexing	Every commit vectorized and searchable.
Media Analysis	OpenCV (WASM) vision + Tesseract.js OCR. Analyze screenshots, diagrams, photos.

Feature Status: Built vs Planned

Here's what's production-ready vs on the roadmap:

✅ Production-Ready (in the open-source invention)

A2A Protocol v1.0 compliance (9 JSON-RPC methods)
Dynamic Agent Card at /.well-known/agent.json
Dual MCP server architecture (27 knowledge tools + 13 website tools)
Triple-path authentication (JWT → License Key → Anonymous)
4-tier LLM fallback chain (Gateway → Supabase+Gateway → Workers AI → Context)
Cloudflare Workers AI offline fallback (Llama 3.3 70B)
Zero-Trust security (7 layers including network isolation, credential scoping, chat history isolation)
CRM dashboard with entity tracking (visitors, customers, AI bots)
Cross-device chat continuity
License-to-visitor linking (unified support chat)
AI-generated prompt suggestions (capped at 24/visitor)
AI-powered skill generation (agent/suggest-skills)
Pure SVG Hero Search widget (React + Web Component)
Drag-to-resize chat panel
Obsidian vault integration (pack-knowledge-base.cjs)
Configurable agent identity (name, description, skills, branding)
One-click Cloudflare Worker deployment
Public tarball cleaning (zero hardcoded secrets)
Broprint.js visitor fingerprinting
Total Recall (vectorized conversation history)

🔧 PLANNED / Roadmap

Automated RAG loop — Sub-Agent (e.g., OpenClaw) that auto-curates conversations into memories without manual intervention
True SSE streaming — Current implementation uses client-side typewriter reveal; server-sent events are planned
Visitor-side image upload — Chat widget image attachment for screenshot/photo sharing
visitor_id format validation — Prefix/length validation (in production, not yet in open-source invention)
Vue.js widget support — React + Web Component available now
Agent Federation — Multiple Mother Brain agents discovering and communicating
Agent-to-Agent Task Delegation — MCP tool for delegating tasks between agents
Agent Directory — Public registry for A2A agents to find each other
Proactive Engagement — Agent initiates conversation based on visitor behavior
Visitor Agent Twin — Digital twin built from Total Recall data
Bidirectional Website Mutation — Agent modifies live website content via MCP

Links

A2A Agent Invention for Mother Brain: https://motherbrain.app/inventions/a2a-agent
Live Agent: https://a2a.motherbrain.app
Agent Card: https://a2a.motherbrain.app/.well-known/agent.json
Website: https://motherbrain.app
Docs: https://motherbrain.app/docs
A2A Protocol: https://motherbrain.app/docs/a2a-protocol

Built by NativeApps.io with 🧠🧪. The A2A Agent Invention is a plugin for Mother Brain — the persistent memory layer for AI coding assistants. Mother Brain gives AI agents vector memory across local PostgreSQL + Supabase, with MCP tools for code search, knowledge management, and now agent-to-agent communication.

Navigation Menu

Uh oh!

A2A Agent Invention: A self-aware AI agent with dual MCP servers, Zero-Trust security, and a RAG feedback loop powered by MotherBrain.app (native MacOS app) MCP Tools, Multi-Vector Architecure Memory, and an Obsidian knowledge base #2055

Uh oh!

{{title}}

Uh oh!

Replies: 0 comments

Select a reply

Uh oh!

Uh oh!

A2A Agent Invention: A self-aware AI agent with dual MCP servers, Zero-Trust security, and a RAG feedback loop powered by MotherBrain.app (native MacOS app) MCP Tools, Multi-Vector Architecure Memory, and an Obsidian knowledge base #2055

Uh oh!

native-apps Jul 13, 2026

TL;DR

How It Uses the A2A Protocol

JSON-RPC Methods

Agent Card (/.well-known/agent.json)

The RAG Loop — A Living Knowledge Base (Design)

How It Works

The Components

Why This Matters

Mother's Three-Layer Knowledge Organization

Layer 1 (Innermost): Core - Mother Brain Internal Docs & APIs

Layer 2 (Middle): Official Website Documentation

Layer 3 (Outermost): Mother's Hidden Knowledge Base

Dual MCP Server Architecture

MCP Server 1: Project Knowledge Gateway (Mother Brain Local)

MCP Server 2: Website Controller (API MCP)

How the Dual-MCP Agentic Loop Works

Zero-Trust Security Architecture

Layer 1: Network Isolation

Layer 2: Triple-Path Authentication

Layer 3: Credential Scoping

Layer 4: Chat History Isolation (Shared-Computer Safe)

Layer 5: Rate Limiting & Input Validation

Layer 6: Client-Side Token Protection (Website)

Layer 7: Public Repository Safety

4-Tier LLM Fallback Chain (Zero Downtime)

Three-Channel Intelligent Routing

Cross-Device Chat Continuity

License-to-Visitor Linking (Unified Support Chat)

AI-Generated Prompt Suggestions

AI-Powered Skill Generation

CRM Dashboard with Conversation-to-Memory Pipeline

The Feedback Loop

Configurable Agent Identity

Pure SVG Hero Search Interface

Supabase pgvector Persistent Memory

Image Analysis Capabilities

Technology Stack

Embeddability

Architecture Diagram

Complete Feature List

Protocol & Architecture

Security (7-Layer Zero-Trust)

AI & Intelligence

Cross-Device & Unified Chat

Website Control (13 MCP Tools)

Knowledge Tools (27 MCP Tools)

CRM & Monitoring (Mother Brain Desktop App)

Widget & UI

Configuration & Deployment (Mother Brain App)

VMVA Benchmark — Up to 90% Token Savings

Session-less Chat — Total Recall

Complete Third-Party Stack

Mother Brain Feature Ecosystem

Feature Status: Built vs Planned

✅ Production-Ready (in the open-source invention)

🔧 PLANNED / Roadmap

Links

Replies: 0 comments

native-apps
Jul 13, 2026

Agent Card (`/.well-known/agent.json`)