Threadback

What if your assistant remembered what you meant to accomplish, not just what you asked it to do? Threadback reconstructs forgotten intentions and helps you safely close the loop through conversation.

Comment

Inspiration

People don't forget tasks. They forget intentions.

We noticed that when people return to unfinished work, the hardest part is rarely remembering the task itself. The real problem is reconstructing the context: Why did I start this? What was I waiting for? What blocked me? Did my goal change? What should I do now?

Traditional task and reminder systems are built around isolated items. We wanted to explore something different: an assistant that understands an unfinished intention as a living thread across conversations, commitments, evidence, blockers, and decisions.

That became Threadback — a system designed to bring forgotten intentions back into context and help people safely pick up where they left off.

What it does

Threadback discovers unfinished intention threads and explains why they deserve attention now.

It can:

  • Reconstruct the context behind an unfinished intention.
  • Identify commitments, blockers, dependencies, and supporting evidence.
  • Determine the next useful action.
  • Explain why an intention is receiving attention.
  • Detect meaningful changes and potential conflicts.
  • Identify whether a deferred intention can safely be resumed.
  • Simulate What-If scenarios without changing real state.
  • Recommend what can realistically be accomplished within a time budget.
  • Prepare actions and require confirmation before consequential changes.
  • Verify completion independently before allowing an intention to be closed.

Threadback is built around a critical distinction:

An action succeeding does not mean the intention was completed.

External-world actions are simulated in the current implementation, while internal Threadback mutations are persistent. Completion requires explicit verification and supporting evidence.

How we built it

We built Threadback incrementally, starting with a FastAPI foundation and evolving it into a persistent intent intelligence system.

The core architecture separates conversational intelligence from deterministic application logic:

Agent / Provider → Application & Domain Services → Repository → SQLite

Threadback is built around the Model Context Protocol (MCP) and exposes exactly nine canonical tools through Streamable HTTP at /mcp, using protocol version 2025-11-25.

The system combines:

  • Persistent IntentThread memory and lifecycle management.
  • Deterministic evidence and confidence analysis.
  • Next-action reasoning.
  • Safe action preparation and confirmation.
  • Controlled simulated execution.
  • Intent evolution and goal revision.
  • Proactive attention, change, conflict, and resume analysis.
  • Intent Copilot capabilities including What-If simulations and time-budget planning.
  • Verification-gated completion and closure.

We also designed the architecture so the agent is not the source of truth. Structured state and deterministic services establish what is actually known; the agent orchestrates reasoning and conversation around that state.

The final implementation contains 401 automated tests, with backend linting and frontend lint/build validation passing.

Challenges we ran into

The biggest challenge was not getting an AI agent to call tools. It was defining what the agent must never assume.

We had to establish strict boundaries around evidence, confirmation, persistence, and completion. Threadback must not fabricate intentions, invent evidence, silently mutate state, or declare an intention complete simply because an action was executed successfully.

Another challenge was making proactive intelligence useful without turning it into a black box. We therefore built deterministic and explainable scoring for urgency, attention, inactivity, blockers, commitments, and evidence rather than relying on vague generated reasoning.

We also had to design around real integration constraints. MCP became a working core protocol, while AgentCore and Alexa+ capabilities were prepared at the integration level without falsely depending on unavailable cloud or partner access.

Accomplishments that we're proud of

We are particularly proud that Threadback grew from a simple MCP-enabled prototype into a persistent, explainable intent intelligence system without losing control over state or safety.

Some highlights include:

  • 401 automated tests covering the backend and major integration paths.
  • Exactly 9 MCP tools with a stable Streamable HTTP interface.
  • Persistent intent memory across application restarts.
  • Intent evolution with immutable original goals and explicit revisions.
  • Proactive attention, change, conflict, and resumability analysis.
  • What-If simulations that guarantee no real state changes.
  • Safe action preparation with explicit confirmation.
  • Independent verification before completion and closure.
  • A clear separation between simulated external actions and persistent internal mutations.
  • A conversational Intent Copilot that brings these capabilities together instead of exposing them as disconnected features.

Most importantly, we are proud of the central design principle: Threadback does not simply tell the user what to do; it explains why, preserves context, and refuses to confuse execution with completion.

What we learned

The project taught us that reliable agentic systems require much more than a capable model.

The model can reason and communicate, but structured state, deterministic rules, persistence, confirmation, and verification are what make that reasoning trustworthy.

We also learned that continuity is a powerful dimension for AI assistants. Instead of treating every conversation as an isolated request, an assistant can become significantly more useful when it understands the history and evolution of an intention.

Finally, we learned that safety should not be something added after the agent works. It needs to be part of the architecture from the beginning.

What's next for Threadback

The next step is to move Threadback from a controlled local implementation toward a real-world assistant experience.

We want to explore:

  • Real external integrations for calendars, email, documents, and task systems.
  • Real notification and proactive delivery mechanisms.
  • Production deployment of the MCP and agent infrastructure.
  • Deeper Alexa+ conversational integration when the required access is available.
  • AgentCore deployment and evaluation in a supported AWS environment.
  • Multi-user and personalized intent memory.
  • Richer evidence sources while preserving the same conservative safety model.

The long-term vision is simple:

When you lose the thread, your assistant should be able to find it—not just remind you that it exists.

Built With

Share this project:

Updates

Submission history