AI Second Brain Tech Stack: Building a Proactive Intelligent Assistant for ADHD Users

A Real-World Need: More Than Just a Chatbot

On Reddit, a user with ADHD (Attention Deficit Hyperactivity Disorder) sparked a thought-provoking technical discussion: they wanted to build a genuine "AI second brain" — a personal assistant they could interact with naturally via WhatsApp or Telegram. Behind this request lies a fundamental question in AI application development: how do you evolve a system from a passive knowledge base into a proactive intelligent agent?

The user was clear: they didn't want "yet another chatbot," and tools like Fabric or MyMind — popular personal knowledge management (PKM) apps — weren't cutting it either. At their core, these tools are glorified information containers: you put things in, you pull things out. What this person actually wanted was a digital companion that could think proactively, send reminders unprompted, and make connections on its own.

For people with ADHD, this need is especially urgent. One of ADHD's hallmark symptoms is executive dysfunction — weak working memory, difficulty initiating tasks, and distorted time perception. Neuroscience research shows that prefrontal cortex activity patterns in ADHD brains differ significantly from neurotypical brains, creating the classic trap of "knowing what to do but not being able to do it." This is precisely why the ADHD community has historically been among the most avid users of productivity tools and cognitive-assist technology — from bullet journaling to GTD systems to digital PKM tools — all attempts to use external systems to replace or augment impaired internal executive function. Fleeting ideas that vanish in seconds, to-do lists that are impossible to track consistently, daily routines that require external scaffolding — a truly intelligent assistant isn't just a productivity tool here; it's closer to a cognitive prosthetic, filling in exactly those gaps.

Breaking Down the Requirements: What Does "Proactive" Actually Mean?

Looking closely at this user's needs, four core technical dimensions emerge.

Multimodal Natural Interaction

The user wants to communicate with the assistant through both text and voice. This means the system needs to integrate speech-to-text (STT) capabilities and understand conversational, unstructured language — far beyond form-filling, and only achievable through the semantic understanding capabilities of large language models (LLMs).

Cross-Message Context Linking

The user gave a telling example: first sending a voice message saying "this looks really interesting, remind me to look into it later," then immediately sending a URL. The assistant needs to understand that these two separate messages belong to the same intent — automatically visiting the link, creating a bookmark in a Notion database, populating attributes and tags, and saving the voice transcription as a summary.

This kind of cross-message intent binding is exactly where traditional deterministic automation pipelines struggle to handle gracefully.

Long-Term Memory and Proactive Association

The most challenging requirement: two weeks later, when the user is discussing a related topic, the assistant should proactively say, "Hey, this reminds me of something you saved a few weeks ago." This requires the system to have a long-term memory mechanism and semantic retrieval capabilities, typically powered by a combination of a vector database and retrieval-augmented generation (RAG).

Here's how vector databases work: unstructured content like text and voice transcriptions is converted into high-dimensional vectors via an embedding model (such as OpenAI's text-embedding-3), then stored in a specialized database. At retrieval time, the user's query is also converted into a vector, and the system finds semantically similar historical content by computing cosine similarity — no keyword matching required. RAG then takes those retrieved results and injects them as context into the LLM's prompt, enabling the model to generate responses as if it "remembers" past information. Every conversation triggers a vector search; when similarity exceeds a threshold, the system surfaces a related memory unprompted — the technical foundation for mimicking the human brain's associative recall.

Proactivity

The user repeatedly emphasized they "don't want it to be passive." The assistant should send reminders at the right moments without being asked. This requires event scheduling, priority judgment, and deep integration with the user's calendar (Google Calendar).

Core Tech Stack Choices: n8n, Agent Framework, or Full Custom?

The user laid out several candidate paths in their post — each representing a mainstream approach to current AI application architecture.

Option 1: Pure n8n Workflows

n8n (pronounced "n-eight-n," short for node to node) is an open-source workflow automation tool built on Node.js, using a Fair-code license with support for self-hosted deployment. Its core architecture is an event-driven directed acyclic graph (DAG), where each node represents an operation unit (HTTP request, database write, message send, etc.) and data flows between nodes as JSON.

The user astutely identified a fundamental limitation of n8n: it is inherently deterministic, following fixed "if A then B" logic — while an AI assistant requires dynamic decision-making based on semantic understanding.

That said, n8n has recently introduced AI Agent nodes with a built-in Tool Calling mechanism, allowing the LLM to dynamically decide which tools to invoke rather than following a fixed node sequence. This update blurs the line between "deterministic automation" and "intelligent agent," partially addressing the original shortcoming. But the core limitation remains: when reasoning logic requires multi-round iteration or complex memory management, the expressive power of visual workflows hits a ceiling. For developers who need heavy integration but don't want to build from scratch, this is a pragmatic starting point.

Option 2: External Agent Framework + n8n for Integration

This is likely the most balanced approach. Use a specialized framework like LangGraph or the OpenAI Agents SDK to handle complex reasoning, memory, and decision logic — and use n8n as the "hands and feet" for concrete integrations with WhatsApp, Telegram, Notion, Google Calendar, and other services.

The core advantages of this layered architecture:

• Decoupled intelligence and execution: the Agent framework focuses on "thinking"; n8n focuses on "doing"
• High maintainability: changes to integration logic don't affect core intelligence logic
• Easy to scale: adding a new service just means adding a node in n8n

LangGraph is an Agent orchestration framework from the LangChain team, with a core design philosophy rooted in directed graphs and finite state machines. Unlike linear Chains, LangGraph lets developers model an agent's reasoning process as a graph of nodes and edges, with native support for loops (like the ReAct "think-act-observe" cycle), conditional branching, and parallel execution. Its key advantage is persistent state management: intermediate conversation states, memory retrieval results, and pending tool calls can all be serialized and stored, allowing conversations to resume even if interrupted. This native support for loops, conditional branching, and long-term memory maps perfectly onto this project's "proactive association" requirement. By comparison, the OpenAI Agents SDK is lighter and better suited for rapid prototyping — the two complement each other well.

It's also worth noting significant technical differences between messaging platforms. Telegram provides an official Bot API with two modes for receiving messages — long polling and webhooks — allowing developers to interact directly via HTTP with nearly no restrictions on sending structured messages, files, and media. WhatsApp is more closed: integrating with personal accounts requires unofficial reverse-engineered implementations of WhatsApp Web (like whatsapp-web.js), which carries account ban risk; business-grade integration requires applying for the WhatsApp Business API (now part of the Meta Cloud API), which comes with significant review barriers and usage costs. For personal projects, Telegram is the friendlier starting point. n8n has official nodes for both platforms, but the underlying API differences determine real-world integration complexity.

Option 3: Fully Custom Development

Developers who want maximum control can go fully custom. The user explicitly said they "don't mind spending more time, as long as it scales well for the next few years" — with that mindset, a custom solution's value lies in completely escaping the capability limits of third-party tools.

The trade-offs are equally clear: longer development cycles, higher maintenance costs, and the need to handle messaging queues, state management, memory storage, and a lot of other infrastructure from scratch.

My Recommendation: Layered Architecture + Incremental Evolution

Given the specific requirements of this project, I believe the most rational path is a mixed layered architecture:

Memory layer: Use a vector database (Pinecone, Qdrant, or locally deployed Chroma) to store all "brain dump" content, paired with RAG to enable proactive association across time. This is the soul of the "second brain."

Intelligence layer: Use LangGraph or the OpenAI Agents SDK to build the core Agent, handling intent understanding, context linking (binding voice to URLs), priority judgment, and the trigger logic for proactive reminders.

Integration layer: Use n8n to connect external APIs — handling message sending/receiving on WhatsApp/Telegram, writing to Notion databases, and syncing with Google Calendar. n8n's visual interface dramatically reduces the cost of maintaining integrations.

Scheduling layer: Use scheduled jobs or event-driven triggers to implement the proactive capability of "reaching out to the user at the right moment."

The biggest advantage of this architecture is incremental evolvability: start with n8n's AI Agent nodes to quickly build an MVP and validate the core experience, then gradually migrate complex memory and reasoning logic to a specialized Agent framework. Avoid over-engineering from day one — run, learn, and adjust as you go.

Closing: From Passive Knowledge Base to Proactive Intelligent Agent

This ADHD user's requirements are a perfect microcosm of AI Agent application development. They clearly illustrate the most cutting-edge paradigm shift in AI today: from passive knowledge base to proactive intelligent agent.

A true second brain shouldn't just be a smarter filing cabinet. It should be a digital companion that understands you, remembers you, and gives you a nudge at exactly the right moment. For people with ADHD, a tool like this goes far beyond ordinary productivity improvement — it carries genuine cognitive-assistive value with the potential to meaningfully improve daily quality of life.

There's no single right answer when it comes to tech stack choices, but the principle of decoupling the intelligence layer from the execution layer, and evolving incrementally is worth careful consideration for any developer who wants to build a serious, long-lasting AI application.