Every AI I Use Shares One Brain: Here's the Full Stack

At 7 AM, a Slack message arrives. It's not from a colleague. It's from an autonomous agent running on my Kubernetes cluster. It has already queried my Open Brain, pulled everything I captured yesterday, cross-referenced my open action items, and assembled a briefing. I read it over coffee. By the time I open Claude Code, the AI already knows what I'm working on, what I decided last Tuesday, and that I still haven't scheduled that dentist appointment.

This isn't a prototype. It's three pieces of infrastructure that took an evening to build, cost under a dollar a month to run, and compound in value every day. Here's the full stack.

The Problem, Briefly

I covered the core architecture in the previous post: a Postgres database with vector embeddings on Supabase, accessible via MCP from any AI client. That post explains the why and the how of the brain itself. This post is about what happens when you give that brain a body.

The short version of the problem: every AI starts from zero. Claude doesn't know what you told ChatGPT. Platform memory features are walled gardens. You burn your best thinking on context transfer instead of actual work. The Open Brain fixes the memory problem. But memory alone is passive: it waits for you to ask. The full stack adds agents that act on that memory autonomously.

Layer 1: The Brain

Open Brain is a Supabase Postgres database with pgvector, fronted by two Edge Functions. One receives Slack messages, generates 1536-dimensional vector embeddings via OpenRouter, extracts structured metadata via gpt-4o-mini, and stores everything with a threaded confirmation. The other is an MCP server with four tools: semantic search, list recent, stats, and capture.

Any MCP-compatible AI connects with a URL and an access key. Claude Code, Claude Desktop, ChatGPT, Cursor: they all query the same brain. I type a thought in Slack, and five seconds later any AI I use can find it by meaning, not keywords. "Career changes" matches "thinking about leaving her job" because the vector embeddings encode semantics, not strings.

I hardened the original design with Slack signature verification (HMAC-SHA256), deduplication via unique constraints on event IDs, async processing to prevent Slack's retry storms, and markup cleaning before embedding. The details are in the architecture post and the code is on GitHub.

Layer 2: The Agents

A brain that only answers when asked is a reference book. A brain connected to autonomous agents is a colleague.

I deployed OpenClaw (an open-source autonomous agent framework) on my K8s cluster at openclaw.naviauxlab.com, connected to Slack for communication. The critical piece: I gave it access to Open Brain's MCP server. Same four tools that Claude Code uses. Same brain, same context, but now an agent can query it without me being in the loop.

This changes the dynamic fundamentally. The agent doesn't just respond. It acts. It can search my captured thoughts, identify patterns I haven't noticed, cross-reference action items from different days, and surface connections between contexts that I'd never think to compare. It writes back to the brain too, so its observations become part of the searchable knowledge base.

The Slack integration means everything stays in one place. I capture thoughts in #capture, the agent communicates back in Slack, and the brain sits underneath both: persistent, searchable, growing.

Layer 3: The Ritual

The layer that ties it together isn't technology. It's a scheduled habit. Every morning at 7 AM, OpenClaw runs a briefing agent. It queries the Open Brain for everything captured in the last 24 hours, scans for unresolved action items, clusters by topic, and delivers a synthesis to Slack.

The briefing doesn't just list what I captured. It connects dots. If I noted a meeting decision on Monday and captured a related insight on Wednesday, the briefing links them. If an action item from last week is still open, it surfaces it. If I've been capturing a lot about one project and nothing about another, it flags the gap.

This is the compounding mechanism. Without the briefing, captures accumulate silently in the database: useful when I search, invisible when I don't. The briefing closes the loop. It makes the system proactive instead of reactive. I don't have to remember to search for what I forgot. The agent does it for me, every morning, before I've finished my coffee.

How They Connect

The data flow is a loop, not a pipeline:

Throughout the day:
  Slack #capture → Open Brain (embed + classify + store)

Any AI session:
  Claude Code / Desktop / ChatGPT → MCP → Open Brain (search + capture)

Autonomous:
  OpenClaw agents → MCP → Open Brain (search + write)

7 AM daily:
  OpenClaw scheduled briefing → queries brain → delivers to Slack

The loop closes:
  Morning briefing surfaces yesterday's captures → informs today's decisions
  → today's decisions get captured → tomorrow's briefing is smarter

Every participant in this loop (me, the AI clients, the autonomous agents) reads from and writes to the same brain. There's no sync problem because there's only one database. There's no context transfer because every tool already has the context.

What This Actually Costs

People assume this kind of setup requires expensive infrastructure. It doesn't.

The K8s cluster was already running for my homelab. OpenClaw is open-source and lightweight. The most expensive part is the OpenRouter credits for embedding generation, and at 20 thoughts per day, that's pocket change.

The Compounding Effect

I seeded the brain with 21 thoughts on day one: professional context, tech stack, active projects, engineering philosophy, deployment patterns. Functional but static. Within a week of actual use, the dynamics shifted.

The morning briefings started catching things. An action item from a meeting I'd half-forgotten. A connection between a Slack capture about a CyberArk configuration issue and a separate note about a compliance requirement: two thoughts captured days apart, in different contexts, that the agent linked because the embeddings were semantically close.

New AI sessions stopped requiring preamble. I'd open Claude Code on a project and it already knew the constraints, the decisions made so far, the people involved. Not because I told it in that session. Because the brain had been accumulating context from every session, every Slack capture, every agent observation.

This is the part that's hard to convey until you experience it: the system gets better at helping you without you doing anything special. You just think out loud into Slack, and the infrastructure handles the rest.

What's Next

The obvious extension is connecting this to my life-hub dashboard: the personal data warehouse that already tracks habits, mood, sleep, goals, and 30 other data streams. Open Brain captures raw thinking. Life-hub captures structured life data. Cross-referencing them could surface patterns neither system catches alone: does my capture frequency drop when my sleep score tanks? Do my best insights come after specific types of meetings?

I'm also exploring additional scheduled agents beyond the morning briefing. A weekly synthesis that clusters themes across seven days. A relationship context agent that preps me before meetings by pulling everything I've captured about the people involved. The brain is the foundation. The agents built on top are where the real leverage appears.

The code for Open Brain is at snaviaux/OpenBrain. The architecture is simple. The advantage it creates is not.