Kairos

Kairos — Your life, remembered intelligently.

Comment

Inspiration

We kept running into the same problem: we were constantly creating information, but rarely able to find it when we actually needed it.

A thought would live in a note. Something useful would be buried in a browser tab. A project decision would exist somewhere in a chat. An important idea might only exist in our memory.

That led us to one question:

What if your phone could remember the context of your life—not just the things you explicitly saved?

We wanted to build a system that could continuously build an understanding of a person's digital life and make that context useful later.

That idea became Kairos.

What it does

Kairos is a mobile-first personal memory and world-model system.

It has four core experiences:

  • Capture — Intentionally save thoughts, observations, and information.
  • Ask — Ask questions about your personal memory using natural language.
  • Library — Keep your captured information in a persistent, searchable knowledge base.
  • Recall — Passively capture meaningful digital activity and turn important events into retrievable memories.

The key difference is that Kairos isn't designed to be just another chatbot.

Instead of only answering from the current conversation, Kairos builds a longitudinal memory layer around the user's own information and activity.

For example, instead of remembering the exact words used to save something, a user can ask:

"What was I researching for my project last week?"

and retrieve relevant context through semantic search.

How we built it

Kairos is built as a React Native mobile application with a NestJS backend.

The memory and retrieval layer is built around:

  • PostgreSQL
  • pgvector
  • Semantic embeddings
  • PostgreSQL full-text search
  • Metadata filtering
  • Hybrid retrieval
  • Project-scoped memory
  • Background processing

When a user asks a question, Kairos generates an embedding for the query and performs vector similarity search against stored observations.

We also implemented lexical search alongside semantic retrieval. This matters because semantic search is good at understanding meaning, while lexical search is useful for exact names, technical terms, and phrases.

The results can then be combined with metadata such as timestamps and project context to retrieve information that is both semantically relevant and contextually appropriate.

Recall

Recall extends the memory system beyond manually created notes.

When enabled, Recall can observe screen activity, identify meaningful events, and convert those events into structured memories and embeddings.

For example, a user might research a technical topic in a browser or compare products online. Instead of requiring them to manually write down what happened, Recall can turn meaningful activity into something Kairos can remember and retrieve later.

The goal isn't to permanently store every interaction.

The goal is to transform a noisy stream of digital activity into useful personal context.

Challenges we ran into

The hardest challenge was not building a chatbot. It was building a memory system.

A chatbot can generate a good response from a relatively small amount of context. A personal memory system has to determine which information matters from a potentially large history of observations.

We had to solve several problems:

1. Semantic vs. lexical retrieval

Pure vector search can understand meaning but may miss exact technical terms or names.

Pure keyword search has the opposite problem.

We therefore combined semantic retrieval with PostgreSQL full-text search and metadata filtering to create a hybrid retrieval system.

2. Processing observations

Raw observations are not automatically useful memories.

We needed a processing pipeline that could turn incoming information into structured observations, generate embeddings, and make those observations available for retrieval without blocking the user experience.

3. Recall signal vs. noise

Recall introduces a much larger stream of information than manually created memories.

The difficult question became:

What is actually worth remembering?

Capturing more data isn't necessarily better. The system needs to extract meaningful events rather than turning every screen interaction into a permanent memory.

4. Building a simple UX around complex infrastructure

Underneath Kairos are embeddings, vector search, indexing, processing pipelines, APIs, and database operations.

The user shouldn't have to understand any of that.

One of our biggest challenges was hiding the complexity while making the product feel simple, fast, and understandable.

Accomplishments that we're proud of

We're proud that Kairos became more than a collection of AI features.

We built a complete vertical slice from capturing information to retrieving it later.

Some of the parts we're particularly proud of are:

  • A persistent personal memory system backed by PostgreSQL and pgvector
  • Hybrid semantic + lexical retrieval
  • Project-scoped memory and search
  • Background observation processing
  • Natural-language memory retrieval
  • A mobile-first experience built around memory rather than chat
  • Recall, which extends memory beyond manually entered information
  • A complete Pro entitlement and purchase flow for Recall

Most importantly, we were able to connect these pieces into a single experience where the user can capture → remember → ask → retrieve → continue.

What we learned

Our biggest lesson was that memory is not the same thing as storage.

Storing more information does not automatically make a system more intelligent.

A useful memory system needs to understand:

  • relevance
  • time
  • context
  • relationships between observations
  • retrieval quality
  • what should and shouldn't become memory

We also learned that retrieval quality is often more important than simply choosing a more powerful model.

A sophisticated AI system with poor context retrieval can still produce a poor answer.

Building Kairos forced us to think about the entire pipeline:

$$ \text{Activity} \rightarrow \text{Observation} \rightarrow \text{Embedding} \rightarrow \text{Retrieval} \rightarrow \text{Context} \rightarrow \text{Answer} $$

Every stage affects the final experience.

We also learned that privacy and UX have to be considered alongside the technology, especially when building something that can observe personal digital activity.

What's next for Kairos

Kairos is only the beginning of the idea we originally imagined.

Right now, Kairos can capture information, retrieve memories, and turn meaningful digital activity into searchable context.

The next step is moving from remembering what happened toward understanding what it means.

We want Kairos to eventually recognize longer-term patterns across a user's life:

  • recurring behaviors
  • changes in habits
  • relationships between activities
  • project evolution
  • personal preferences
  • productivity patterns
  • important moments that would otherwise be forgotten

The long-term vision is a personal world model that becomes more useful as it understands a person's history.

Not another chatbot.

Not another notes app.

A memory layer for your digital life.

Your digital life already contains a story. Kairos helps you remember it.

Built With

Share this project:

Updates

Submission history