The Umami of Your AI Tooling

You know what makes a great colleague great? It's not just that they're smart. It's that they were in the room.

They were in the meeting six months ago when you tried approach X and it didn't work. They remember why the architecture decision went the way it did. When Sundar mentions "the performance issue," they know he's talking about the Q2 incident, not the recent one. They don't need a briefing. They have context.

Now open Claude, ChatGPT, or Gemini. Ask it to help with the thing you were working on last week. Watch it politely ask you to explain everything from scratch.

The gap between "smart AI" and "useful teammate" isn't intelligence. It's grounded, accumulated, cross-tool context.

---

What the platforms are doing (and it's a lot)

Let's start with the elephant in the room. Claude currently has the most complete attempt at solving this.

Memory extracts key facts across conversations. Projects let you upload persistent docs that load every session. MCP (Model Context Protocol) is a massive leap forward: it lets Claude connect to Google Drive, Slack, GitHub, and custom tools to pull live context. Claude Desktop brings the agent to your local environment, while CLAUDE.md (popularized by Claude Code) lets developers define project context in a markdown file the agent reads on startup.

Credit where it's due: MCP changes the game by turning Claude from a closed system into an extensible one.

But here's the gap I keep running into: these solve context at the session level, not at the life level.

Memory stores what you told Claude, but it doesn't know about the meeting you didn't mention or the Slack thread that got resolved while you were offline. Projects are static: great for a codebase, but your work context changes daily and nobody re-uploads docs every morning. MCP connections are transactional: Claude can query your calendar right now, but it doesn't have a persistent, compounding model of your work over time.

ChatGPT's memory is similar. It stores preferences and facts across sessions, but it's shallow. Profile-level, not work-context. It knows about you, not what you've been doing.

Gemini has the deepest data advantage via Google Workspace (Gmail, Calendar, Drive, Meet). But it's still pull-based and scoped. You don't get a unified context layer connecting your emails to your meetings to your notes over a six-month timeline.

---

What the open-source ecosystem is building

Hundreds of developers and startups are attacking this from different angles. The sheer volume of activity is a signal: the need is real.

The memory infrastructure heavyweights: Open-source projects like Mem0 (formerly Embedchain) and Letta (formerly MemGPT) are building OS-level memory for LLMs. Mem0 provides a personalized, adaptive memory layer across applications, while Letta treats LLM memory like an operating system, managing tiered storage so the AI doesn't forget past events. They are brilliant developer primitives, but most people would be better off with an out-of-the-box AI that knows what happened last week.

The markdown bootstrap crowd: Developers are solving context with discipline. Projects like context-engineering-intro use structured CLAUDE.md files. On r/PKMS, "Portable Brain" projects use PARA-inspired markdown hierarchies with nightly bash scripts that rebuild context files automatically. The agent writes back to a memory.md file, creating a self-improving loop. The ceiling? It only knows what you actively write down.

Persistent context for coding agents: Tools like OpenContext and OneContext sync your identity and code history to solve the "I just spent 2 hours debugging and lost the session" problem. But they are strictly scoped to code. The product meeting where the architectural decision was made remains invisible.

Passive capture tools: Limitless (formerly Rewind.ai) pioneered the "record everything on your screen and mic" approach for macOS. Meanwhile, tools like Granola and tl;dv are capturing meeting context flawlessly. Yet, they remain somewhat siloed: great at capture, but lacking the unified, automated knowledge graph that connects your Tuesday meeting directly to your Friday pull request.

---

The Umami Layer

All these approaches share one thing: they solve a slice of the problem, but none aggregate your actual digital life into a unified, persistent context layer.

Think about what an AI that was functionally "in the room" would look like. It attended your meetings (via transcription), read what you read (via bookmarks), tracked your calendar, and knows who you work with. When you ask, "What was that thing from Q2 planning relevant to this feature?" it doesn't search. It knows.

We believe this requires six things that are incredibly hard to get right simultaneously:

Passive aggregation. It pulls from your tools without manual input. The moment it requires upkeep, people abandon it.

Temporal grounding. It understands when things happened. "Last Tuesday" is a real reference a flat vector database struggles to represent.

Entity resolution. "Sarah" in your notes, "sarah@company.com" in your calendar, and "@sarah" in Slack are the same person. The context layer must just know this.

Cross-source connections. The article you read last week connects to the feature you're building, which connects to the Slack thread where the decision was made.

Compounding value. A context layer with six months of history isn't linearly better than one with six days. It's qualitatively different. It knows things about your work that you've forgotten yourself.

Local-first privacy. Here's the thing nobody talks about enough: a context layer that holds your meetings, notes, tasks, contacts, and work history is one of the most sensitive datasets imaginable. Your data has to live on your machine, under your control. Not on a startup's servers, not in a cloud database. When LLMs are involved for tasks like summarization or enrichment, a hybrid approach is necessary: anonymized data sent for processing, but your raw content never leaves your device. This isn't a nice-to-have. For a product that knows this much about your work, security-first architecture is table stakes.

This isn't just RAG (Retrieval-Augmented Generation). RAG retrieves documents. A true context layer understands the relationships between people, timelines, and ideas.

---

Why I think about this

I've been building infrastructure for AI agents for a while. Last year I built IAMHeimdall, exploring a critical question: who is this agent and what is it allowed to do? That work is open, and I still believe agent identity is a massive unsolved problem.

But even a properly identified, perfectly authorized agent is useless if it doesn't know what you've been working on. Identity without context is just a security badge with amnesia. That realization led me to Popy.

---

What we're building, and an honest ask

We're all circling the same core issue. The markdown crowd solves it with discipline; Mem0 solves it with infrastructure; Limitless solves it with screen recording.

Our approach with Popy is to build a local-first macOS app that passively aggregates your scattered digital life into one timeline, then builds a knowledge graph on top that automatically resolves and connects entities across everything. Your data lives on your machine. When we use LLMs for enrichment, the data is anonymized in transit and never stored on our servers.

Here's what this actually looks like in practice.

You're figuring out a caching layer for your app. You ask Claude: "Have we looked at this before?"

Popy, connected via MCP, finds that three months ago, in a meeting with your engineering lead, you discussed the same approach. You decided against it at the time because of a scalability concern she raised. Popy also surfaces an article you saved that same week about edge caching patterns, and a task that was created and later closed without resolution.

It's very tough for a combination of individual MCP calls to Granola, Linear, or Google Docs to surface this. Each of those tools holds one piece, and none of them know the pieces are related. The connection only exists because Popy has been quietly building a graph of your work across tools and time. That's the difference between "AI that can look things up" and "AI that was in the room."

We're starting with the integrations that matter most: calendar, meetings, your notes, and reads. The knowledge graph connects them, and MCP makes the context available to Claude and other AI tools. We're building outward from there.

Passive aggregation across a whole digital life is hard. Really hard. Which is why we're not pretending we've solved it all on day one. But the core loop (capture, connect, surface via MCP) is working, and every week the graph gets richer.

It's early, and we're actively looking for people who deeply feel this pain point to try it and tell us where it breaks.