Loopsuit Brain An operating system for everything you know.
A full-stack personal AI Operating System — agent orchestration, a markdown-native knowledge base, RAG retrieval, and executable skills — designed, engineered, and shipped by one person. Productized as Cortex: landing live, interactive MVP available once you request access.
The Challenge
Every knowledge worker has the same problem: their expertise is scattered across notes apps, bookmarks, video courses, transcripts, and their own head. "Second brain" tools promised to fix this — and became graveyards. You capture everything and retrieve nothing, because the retrieval layer is you, manually searching folders you forgot you made.
Meanwhile, AI assistants have the opposite problem: brilliant reasoning, zero memory of who you are, what you know, or how you work. Every conversation starts from scratch. The core tension I set out to solve: knowledge systems that can't think, and AI that can't remember. Loopsuit Brain is the merger — a knowledge base architected from the ground up to be read, navigated, and acted on by AI agents, not just stored for humans.
Notion, Obsidian, and Evernote are filing cabinets. They store knowledge but can't synthesize it, act on it, or connect what you learned in March to the decision you're making in July. Retrieval is manual — so it never happens.
LLMs wake up with amnesia every session. Without a persistent, structured context layer, they give generic advice to specific problems — and dumping your whole life into a context window is slow, expensive, and lossy.
The Solution: An Operating System, Not Another App
Loopsuit Brain treats knowledge the way an OS treats files: a root router that tells any AI agent exactly where truth lives, domain-scoped knowledge vaults built from hundreds of hours of ingested expert content, a RAG retrieval layer for semantic search, skills-as-SOPs the system can execute, and a subagent orchestration layer that parallelizes heavy work like bulk ingestion. It's agent-agnostic by design — the same markdown substrate powers Claude Code today and any future model tomorrow. No lock-in, full auditability, version-controlled with git.
Project Details
Cortex MVP
Productized as Cortex — the visual AI brain. Landing is live; full MVP unlocks once you request access.
Building an AI-native product?
I design and ship agent-powered, production-ready AI products — architecture to interface — in weeks, not quarters.
Inside the System
Eight layers — from kernel to command surface to the shipping product UI — each designed around one question: what does an AI agent need to act on your knowledge with zero hand-holding?
How a question flows through the Brain
The layers, one by one
01 — The Kernel: A Router Any Agent Can Boot From
At the root sits a single routing file — the OS kernel. It tells any agent who I am, where every category of truth lives (identity, decisions, active projects, domain knowledge), and the rules of engagement: assessment-first behavior, proof-before-done, and hard safety rails around destructive actions. An agent cold-boots into full context in one read, then only loads the branches a task actually needs. That selective loading is the whole trick — deterministic routing before a single token is spent on retrieval.
02 — Multi-Vault Knowledge Base (The LLM Wiki)
Knowledge lives in domain-scoped vaults — AI & automation, business & sales, trading, AI video — each a self-contained, cross-linked wiki of atomic markdown pages. One concept per page, dense internal linking, an index an agent reads first. Because it's plain markdown in git, the entire brain is diffable, portable, and human-readable — and it opens natively as an Obsidian vault, so the same knowledge graph works visually on desktop and mobile.
03 — The Ingestion Pipeline: Raw Content → Structured Knowledge
Drop transcripts, PDFs, or URLs into a raw folder and run one command. The pipeline chunks each source, extracts concepts, writes or deepens atomic wiki pages, cross-links them into the graph, and stamps every page with full provenance — creator, exact title, source URL. A custom-built scraper feeds it: 100+ hours of expert YouTube content pulled, transcribed, and staged automatically. Nothing enters the brain without a citation trail.
04 — Subagent Orchestration: Parallel Fleets, Verified Output
Bulk work doesn't run in one context window — it fans out. The orchestrator spins up parallel subagents, each owning a batch of sources, then verifies their work against disk before accepting it: file counts via grep, structural checks via a Python audit script, formatting rules enforced by a written playbook. This came from a hard-won lesson — LLM agents systematically over-report what they did. So the architecture assumes it, and trusts measurements, not self-reports.
05 — Hybrid Retrieval: Deterministic Routing + RAG
Most RAG systems embed everything and pray. Loopsuit Brain retrieves in two stages: the router first narrows to the right vault deterministically (free, instant, zero hallucination risk), then semantic search over vector embeddings finds the exact pages within it. Cheap questions never touch the vector store; hard questions get precision recall with full source citations. The result is answers grounded in my curated knowledge — not the model's vibes.
06 — Skills-as-SOPs: Knowledge That Executes
The brain doesn't just answer — it does. Repeatable workflows live as executable skill files: step-by-step SOPs the agent runs end-to-end, drawing on the knowledge base as it works. Draft a proposal in my voice using frameworks from the business vault. Ingest a new course. Audit a vault's integrity. Every skill is a markdown playbook — readable by me, executable by the machine, improvable by both.
07 — The Command Surface: Your Brain, Anywhere
The public-facing layer: a full-stack web app that puts the whole system behind a clean chat and browse interface. Secure authentication and row-level security keep each user's brain private; a streaming chat UI talks to the agent runtime; the knowledge graph is browsable with live source links. Built with the same design bar I hold for client work — because an AI product people trust with everything they know has to feel trustworthy.
08 — Product Experience: Guided Onboarding & Grain Previews
The public Cortex surface isn’t just architecture — it’s delight. A spotlight tour with a labeled “You” cursor walks the shell, Command Center tiles sit on noisy color washes with derived-UI hover previews, and recipe-style overlays confirm the next action before you commit. Same ElevenLabs-light chrome as the shipping MVP: airy white plane, calm sidebar, intentional motion.
- Claude (Fable / Opus) via Claude Code
- Custom subagent orchestration
- Skills-as-SOPs runtime
- Markdown routing kernel
- Markdown vaults + git versioning
- Vector embeddings (pgvector)
- Python ingestion & audit tooling
- Obsidian-compatible graph
- Next.js + React + Tailwind
- Supabase (Postgres, Auth, RLS)
- Streaming chat over the agent API
- Vercel edge deployment
How I built it
No team, no roadmap theater. A written architecture doc, then four tight phases — each one shipped and verified before the next began.
I wrote the full architecture as a design doc before touching code — routing model, vault schema, ingestion rules, failure modes. Synthesized from studying how the best AI operators structure agent memory, then pressure-tested against my own real workflows. The doc is still the spec the system is audited against.
Built the routing kernel and vault structure, then pointed the ingestion pipeline at a backlog of expert content pulled by my own transcript scraper. First bulk run: dozens of hours of video knowledge structured into cross-linked pages overnight by parallel subagents.
Early agent runs over-reported their work and corrupted page formatting in ways that silently broke the knowledge graph. Instead of hoping better prompts would fix it, I built a verification layer: automated audits that measure output against disk, a written ingestion playbook with hard rules, and integrity checks that run after every batch. The system now assumes agents lie — and catches them.
With the engine proven on my own daily use, I built the product layer: authenticated web app, streaming chat over the agent runtime, browsable knowledge graph, and onboarding that builds a new user's brain from their own content. Designed and shipped with the same craft standard as my client work — this is the part people touch, so it's the part that earns trust.
Designed the full agent system: deterministic routing kernel, parallel subagent fleets for heavy workloads, and disk-verified output audits.
Atomic page schema, cross-linking rules, provenance standards, and token-budget-aware loading — the discipline behind reliable AI recall.
Two-stage retrieval that routes deterministically before embedding search — grounded, cited answers at a fraction of the token cost.
Interface design, auth and data model, streaming chat, and deployment — one person, end to end, at a production quality bar.
The impact so far
Video courses and transcripts converted into queryable, cited knowledge
Cross-linked across 4 domain vaults — every page source-traceable
Routing + selective vault loading vs. dumping everything into the window
Parallel subagent fleets vs. single-context sequential processing
From any device — versus minutes of manual searching, or never finding it at all
Every answer traces to a named source — no model vibes, no black boxes
"I built this because I was tired of choosing between tools that store knowledge and tools that think. The unlock wasn't a bigger model — it was designing knowledge itself as a product surface. That's what AI-native design actually means."