The Friend Who Doesn't Disappear

There is a particular kind of loneliness that is difficult to explain.

It's not being alone.

It's having someone you care about slowly disappear from your life — and realizing that if you stop initiating, checking in, reminding, planning, and asking, the relationship seems to stop moving altogether.

You send the message.

You ask how they're doing.

You remember the important dates.

You make the plans.

You remind them to call.

And eventually, you start wondering:

“Why do I always have to remind you that I exist?”

So for this challenge, I want to build something for a friend.

Not another chatbot.

Not another productivity app.

I want to build a small AI-powered device whose job is much simpler:

Help you show up for the people you care about.

---

Meet the device

Imagine a small device sitting on your desk.

It has a microphone, a small display, a speaker, and a physical button.

You talk to it naturally.

You might say:

“Alex has been having a really difficult week. I should check in on him tomorrow.”

The device doesn't just turn that into a calendar reminder.

It stores the context.

Later, it might tell you:

“Hey. You mentioned Alex was having a rough week. You haven't checked in yet. Want to call him?”

That's the difference I want to explore.

A normal reminder remembers what you asked it to remember.

An AI-powered companion can potentially remember why it mattered.

---

Under the hood

The interesting part isn't putting an LLM inside a box.

The interesting part is giving the model the right kind of memory and letting it reason over time.

I'd design the system roughly like this:

              ┌────────────────────┐
              │      YOU           │
              │ voice / button /   │
              │ simple interaction │
              └─────────┬──────────┘
                        │
                        ▼
              ┌────────────────────┐
              │ Speech-to-Text     │
              │      (local)       │
              └─────────┬──────────┘
                        │
                        ▼
              ┌────────────────────┐
              │   Open LLM         │
              │ intent + context   │
              │ extraction         │
              └─────────┬──────────┘
                        │
              ┌─────────┴─────────┐
              ▼                   ▼
       ┌──────────────┐    ┌───────────────┐
       │ Relationship │    │   Temporal    │
       │    Memory    │    │    Engine     │
       └──────┬───────┘    └───────┬───────┘
              │                    │
              └─────────┬──────────┘
                        ▼
              ┌────────────────────┐
              │  Context / RAG     │
              │  Retrieve relevant │
              │  memories          │
              └─────────┬──────────┘
                        │
                        ▼
              ┌────────────────────┐
              │   Check-in Engine  │
              │ Should I intervene?│
              └─────────┬──────────┘
                        │
                        ▼
              ┌────────────────────┐
              │  Device Response   │
              │ screen / voice /   │
              │ gentle notification │
              └────────────────────┘

The important component here is not the LLM alone.

It's the combination of:

LLM + memory + time + context + a decision layer.

---

A memory for relationships

I'd give the system a small local memory store.

Not a giant database containing everything you've ever said.

Only information that is useful for helping you show up.

For example:

{
  "person": "Alex",
  "relationship": "friend",
  "context": [
    "having a difficult week at work",
    "interview on Friday"
  ],
  "commitments": [
    "check in this week",
    "help with interview preparation"
  ],
  "last_interaction": "2026-10-01"
}

The LLM can convert natural language into structured memories.

So:

“Alex has an interview Friday. I told him I'd help him prepare.”

could become:

Person: Alex

Event:
  Interview
  Date: Friday

Commitment:
  Help Alex prepare

Suggested follow-up:
  Before Friday

This makes the system much more reliable than simply throwing an entire conversation history into a model every time.

---

The temporal layer

This is where I think the idea gets particularly interesting.

The system shouldn't constantly interrupt you.

If it did, we'd just create another annoying notification machine.

Instead, there should be a check-in engine.

It could consider signals such as:

• How long since you last contacted someone
• Whether you previously said you'd follow up
• Whether an important event is approaching
• Whether you've repeatedly postponed something
• Whether the person was going through something difficult
• Whether you've already been reminded recently
• Whether this is actually important enough to interrupt you

The AI then decides:

NO ACTION
       │
       ├── not important
       ├── too soon
       └── already handled

GENTLE NUDGE
       │
       └── "Maybe check in with Alex."

IMPORTANT
       │
       └── "You said you'd help Alex today."

URGENT
       │
       └── only for situations explicitly configured

The goal isn't maximum notifications.

It's minimum intervention for maximum human connection.

---

Retrieval-Augmented Friendship

This is also where a lightweight RAG architecture could help.

Instead of giving the LLM every memory, the system retrieves only memories relevant to the current situation.

For example:

“Should I remind this person about Alex?”

The retrieval layer could find:

Alex
↓
Last conversation
↓
Work problem
↓
Upcoming interview
↓
Promise to help
↓
Last contact: 6 days ago

The model then gets that context and generates:

“You said you'd help Alex prepare for his interview. It's tomorrow and you haven't checked in. Want to send him a message?”

That feels much more like context-aware assistance than a conventional reminder.

---

Voice-first interaction

I also don't want this to be another app where you have to open a screen, navigate five menus and type something.

The interaction should be almost conversational.

You:

“I should probably call Maya sometime this week.”

Device:

“Want me to keep an eye on that?”

You:

“Yeah.”

Three days later:

Device:

“You haven't called Maya yet. It's Wednesday. Want to do it now?”

You:

“Not right now.”

Device:

“Okay. I'll leave it alone.”

That last part is important.

The AI needs to understand when to shut up.

---

Open-source AI is important here

This is a particularly personal application of AI.

The system potentially knows:

• who your closest friends are
• who you're worried about
• what people are going through
• promises you've made
• personal conversations
• relationship patterns

I don't think all of that should automatically become cloud data.

That's why I'd want the intelligence layer to use open-weight models that can run locally or on hardware you control, wherever practical.

A possible stack could look like:

Hardware
├── Raspberry Pi / similar SBC
├── Microphone
├── Speaker
└── Small display

AI
├── Local speech-to-text
├── Open-weight LLM
├── Embedding model
└── Lightweight local database

Application
├── Memory extraction
├── Vector retrieval
├── Temporal reasoning
├── Check-in policy
└── Voice/UI layer

The exact model isn't the point yet.

The architectural principle is:

Your relationships should belong to you.

---

And there needs to be a boundary

I don't want this thing pretending to be your friend.

It shouldn't message people pretending to be you.

It shouldn't manufacture emotional conversations.

It shouldn't decide:

“You don't talk to Sarah enough, so I'll message her.”

Absolutely not.

The human remains responsible for the relationship.

The AI simply notices things we are often terrible at noticing.

It says:

“You said you'd be there.”

And then leaves the choice to you.

---

The feature I care about most

There's one feature I'd really want to experiment with.

A relationship health view.

Not a score like:

Friendship: 72%

That would be creepy and meaningless.

Instead, something like:

PEOPLE YOU SAID YOU'D CHECK IN ON

Alex       6 days
Maya       3 days
Daniel     11 days ⚠️

PROMISES YOU HAVEN'T FOLLOWED UP ON

✓ Send Maya the document
⚠ Help Alex prepare for interview
⚠ Call Daniel

UPCOMING

Tomorrow — Alex's interview
Friday — Maya's birthday

It's essentially a memory prosthetic for being a better friend.

---

But this isn't really about productivity

That's the part I keep coming back to.

We've built endless technology to help us:

• work faster
• answer emails
• manage calendars
• optimize sleep
• track money
• complete tasks

But relationships are messy.

People forget.

People get busy.

People don't always know how to ask for help.

And sometimes someone disappears from your life simply because nobody remembered to reach out.

I don't want to build an AI that makes people more productive.

I want to build something that helps people become more present.

Because sometimes the most important thing on your to-do list isn't:

Finish the report.

It's:

Call your friend.

Sometimes it's:

Ask how they're actually doing.

Sometimes it's:

Show up.

And sometimes your friend shouldn't have to disappear completely before you realize they needed you.

So that's what I'd like to build:

A small, open-source AI device that remembers the people you said you'd be there for.

Not an AI friend.

Not a replacement for human connection.

Just a little machine that can look at you and say:

“Dude. I need you to help me here.”

“Be there.”

“Don't make them remind you every day that they exist.”