HoldThat

HoldThat helps you resume interrupted tasks without guessing what’s done. Track confirmed progress, preserve unfinished steps, and pick up exactly where you left off.

Comment

Inspiration

Have you ever been interrupted halfway through a task, returned later, and wondered: "Did I actually finish that, or did I just start it?"

Traditional reminders tell us what we planned to do. Checklists tell us what was marked complete. But neither reliably captures uncertainty when real-world work gets interrupted.

That's the problem behind HoldThat: an interruption-recovery assistant designed to remember what is confirmed, what is unfinished, and what needs attention next.

What it does

HoldThat helps people pause real-world tasks and resume exactly where they left off, without inventing progress.

Using an interactive, Alexa+-inspired web simulation, users can:

  • Track progress: Report whether a task step is started, unfinished, or completed.
  • Confirm completion: A statement like "I'm finished" triggers a separate confirmation instead of automatically marking the step complete.
  • Pause and resume: Return later and recover the last reliable checkpoint.
  • Preserve uncertainty: Know which actions were started but never confirmed.
  • Correct mistakes: Update previous reports while preserving history and reopening dependent steps.
  • Export checkpoints: Keep a portable record of progress.

For example, while packing an overnight bag, someone might finish opening the bag but get interrupted while sorting clothes. When they return, HoldThat remembers that opening the bag was confirmed while sorting clothes remains unresolved.

It doesn't guess. It helps you continue.

How we built it

HoldThat uses TypeScript, Node.js, Express, Vite, and the Model Context Protocol (MCP).

The browser interface acts as a genuine MCP client, communicating with server-side tools through Streamable HTTP. These tools handle progress reporting, interruption recovery, and resumption.

The backend maintains explicit task states, confirmation records, and revision-aware history.

The application is deployed on Google Cloud Run, with private Google Cloud Storage providing durable session persistence. Storage generation checks help prevent conflicting updates, while session isolation and duplicate-request protection keep workflows consistent.

A SQLite persistence option supports local development and reproducible testing.

The Alexa+ experience is a clearly labelled web simulation with functional MCP tools. It does not claim native Alexa device connectivity or live AI model inference.

Challenges we ran into

1. Distinguishing reports from confirmed facts

Saying "I've finished" shouldn't automatically establish that physical work is complete. We designed a separate confirmation mechanism to preserve that distinction.

2. Recovering interrupted workflows accurately

Resuming required more than remembering the last completed item. We needed to retain uncertain progress, dependencies, and corrections.

3. Handling concurrent and stale updates

Retries, multiple browser sessions, and old requests could otherwise overwrite newer progress. We implemented revision checks and idempotent operations.

4. Making sessions survive cloud deployments

We introduced durable cloud persistence and verified that saved progress survived an actual Cloud Run revision replacement.

Accomplishments

  • Built and deployed a publicly accessible, MCP-powered application.
  • Implemented explicit completion confirmation and interruption recovery.
  • Added persistent checkpoints, correction history, and session isolation.
  • Verified actual MCP initialization, tool discovery, and execution over HTTPS.
  • Passed 50 backend/storage tests and 20 desktop/mobile browser scenarios before deployment.
  • Verified key workflows against the live application.

We also evaluated 20 synthetic interruption-recovery scenarios. HoldThat's recovery decisions matched the expected results in all 20. This was a controlled synthetic evaluation, not a human usability study.

What we learned

The most important engineering lesson is that reliable assistance isn't just about knowing what to do next. It's also about knowing what hasn't been established.

Keeping uncertainty explicit, preserving evidence, and requiring confirmation can make an assistant more dependable than one that simply generates confident responses.

Building with MCP also demonstrated how a task-state engine can be exposed through reusable tools rather than being tied to a single interface.

What's next

Future improvements could include optional natural-language interpretation, more customizable workflows, improved accessibility, and native Alexa+ integration when the appropriate developer capabilities are available.

HoldThat is built around one principle: when life interrupts you, your assistant should remember the truth—not make assumptions.

Try HoldThat

Launch the live application

View the GitHub repository

Built With

Share this project:

Updates

Submission history