Later, Me.

A quiet AI phone call from your earlier self to your future self—designed around timing, restraint, and human consideration. Powered by CALL-E.

Comment

Inspiration

AI phone calls are getting easier to build.

But I kept thinking about a different question:

What should an AI consider before it calls a human?

A successful phone connection does not automatically mean a considerate interaction.

Later, Me. started from a simple experience: before asking an AI to call someone else, first let it call you.

You schedule a call to your future self. Hours later, an AI calls and carries a small message from the person who cared about you earlier: yourself.

The project explores whether an AI phone call can feel less like an automated task and more like a modest, considerate presence.

What it does

Later, Me. lets you schedule a real phone call to your future self.

You choose when the call should arrive and optionally leave a short message for the person you will be when the call reaches you.

At the scheduled time, CALL-E handles the real outbound phone call and live conversation.

The project currently has two usable forms:

Public Live Build

The public web version allows users to:

  • choose English or Japanese
  • register their own phone number
  • create one future reservation at a time
  • reserve calls at least 4 hours ahead
  • see the next scheduled call and countdown
  • change or cancel a reservation
  • view completed-call history
  • use a limited real-call quota during the hackathon judging period

The public build runs on:

  • React / TypeScript / Vite
  • Python
  • Render Web Service
  • Render PostgreSQL
  • Render Cron Job
  • CALL-E
  • OpenAI Responses API for optional post-call Relationship Trace generation

Local Judge Build

The downloadable Windows Judge Build also supports:

  • reservations from 4 hours up to 10 years ahead
  • Windows Task Scheduler for future execution
  • Windows DPAPI for protected local credential storage
  • evaluator-owned CALL-E credentials
  • isolated local scheduling and testing

Relationship Trace

After a completed call, OpenAI can optionally generate a small Relationship Trace from the interaction.

Relationship Trace is intentionally not a complete transcript, an intimacy score, or a relationship level.

Its purpose is much smaller:

to decide whether one limited fragment from the completed interaction is worth leaving visible afterward.

Sometimes the considerate decision is to leave nothing.

The live phone conversation itself is not run by OpenAI in this version.

CALL-E handles the live phone experience.

OpenAI is used only after the call for the optional Relationship Trace.

Human Consideration Model

The interaction design is inspired by four ideas:

Sassuru (察する) — notice context that may not be stated directly.

Kizukai (気遣い) — take a considerate first step instead of remaining passive.

Tsutsushimu (慎む) — restrain certainty, insistence, and goal-at-all-costs behavior.

Omoiyari (思いやり) — when enough context exists, sometimes go one modest step further while preserving the person's choice.

These are not implemented as a score or rigid state machine.

The goal is not compliance.

The question is closer to:

Did this contact make everyday life slightly easier?

Why the four-hour minimum?

Later, Me. deliberately does not optimize for repeated engagement.

The four-hour minimum creates temporal distance between the person who schedules the call and the person who later receives it.

The experience is meant to feel like something your earlier self quietly left for you, rather than another notification designed to bring you back immediately.

There are no streaks, relationship levels, affection scores, paid closeness, or engagement rewards.

How we built it

Later, Me. separates the live phone layer from the surrounding scheduling and memory logic.

CALL-E is responsible for the real outbound phone call and live conversation.

The public build uses a React / TypeScript / Vite frontend connected to a Python service hosted on Render.

Public reservations are stored in PostgreSQL, and a Render Cron Job checks for due reservations and dispatches them to CALL-E.

Phone numbers are stored in protected server-side form rather than exposed in the browser.

The local Judge Build uses a different execution path:

  • Python local backend
  • Windows Task Scheduler
  • Windows DPAPI
  • evaluator-owned CALL-E credentials

OpenAI is intentionally outside the live voice loop.

Its implemented role in this version is the optional post-call Relationship Trace.

That boundary is deliberate and explicit.

Challenges

One of the hardest parts was not simply making a phone call work.

It was defining what should happen around that call.

Early real-call tests exposed problems such as repetitive dialogue, awkward timing, overly task-oriented responses, and speech-recognition mistakes.

Those failures changed the project.

Instead of measuring only whether a call completed, I started treating timing, hesitation, refusal, fatigue, repetition, and graceful endings as part of the technical problem.

Another challenge was distribution.

The original prototype was local and Windows-based, with future scheduling and protected credentials.

To make the project actually testable by judges, I built two separate delivery paths:

  • a downloadable Windows Judge Build
  • a public live web build with server-side persistence, real reservations, and CALL-E dispatch

The public build required a separate deployment architecture using Render, PostgreSQL, and scheduled server-side dispatch.

Current CALL-E regional limitation

As of Sep 14, 2026, CALL-E has temporary regional restrictions affecting outbound calls in some regions, including Japan.

The Later, Me. public application itself remains usable in those regions:

  • onboarding works
  • phone registration works
  • reservations can be created
  • reservations can be changed or canceled
  • reservation history and quota state are persisted

However, actual outbound AI phone delivery may not complete in a region currently restricted by CALL-E.

Real +81 calls had successfully completed earlier in development before this restriction was introduced.

CALL-E support confirmed that Japan is currently affected by a temporary regional restriction.

Availability may change as CALL-E restores regional support.

Accomplishments that I'm proud of

  • completed real scheduled CALL-E phone calls end to end
  • built a working reservation flow from UI to real outbound call
  • kept the production minimum at four hours instead of weakening the experience for the demo
  • separated factual call history from optional Relationship Trace
  • implemented protected local credential handling
  • created a public web version with real server-side reservation persistence
  • added English and Japanese onboarding and application flows
  • implemented reservation creation, change, cancellation, and quota recovery
  • deployed the live application using Render Web Service, PostgreSQL, and Cron
  • created a source-available public repository with explicit privacy boundaries
  • created and rehearsed an isolated Windows Judge Build
  • published a downloadable Judge Build with a SHA-256 checksum
  • added Later, Me. to the official CALL-E community repository through a merged pull request

What I learned

The most important lesson was that phone-agent quality is not only a speech or latency problem.

A phone call is an interruption in another person's life.

That makes restraint, timing, uncertainty, and the ability to stop just as important as the ability to speak.

I also learned that a relationship with an AI does not need to be represented through points, levels, or scripted closeness.

It can emerge from small decisions about what to remember, when to speak, and when not to.

A second major lesson came from deployment.

A prototype that works locally is not the same thing as something another person can actually evaluate.

Building the public version forced me to think about persistence, scheduling, quotas, credential boundaries, deployment failures, regional availability, and what happens when the external telephony provider itself becomes temporarily unavailable.

What's next

I would like to explore a deeper live conversational architecture where CALL-E continues to provide the real telephony layer while an external conversational model can reason during the call.

That depends on the availability of a supported live-media or agent handoff interface from CALL-E.

I would also like to continue exploring the Human Consideration Model beyond phone calls:

not as a personality score or fixed rule system, but as a way to reason about timing, restraint, interruption, uncertainty, and whether an AI action should happen at all.

For now, Later, Me. remains a working hackathon prototype built around one idea:

AI does not need to pretend to be human to become better at considering humans.

Built With

Share this project:

Updates

Submission history