Thread

One Place For Everything That Matters.

Comment

Inspiration

Inspiration The idea for Thread started with a simple frustration: Why do I have to remember where everything is? An important email is in Gmail. A meeting is in Calendar. A document is somewhere else. A task lives in another system. The conversation that explains why any of it matters may be somewhere completely different. The information exists. The problem is that the context is fragmented. I realized that I was spending time doing something computers should be much better at doing: connecting the dots. So I started asking a different question: What if, instead of giving me more places to organize my work, technology could understand the work I was already doing? That question became Thread.

What it does

Thread is a personal workspace that brings together the information surrounding your work and turns it into context you can actually act on. It connects things like Gmail, Calendar, files, tasks, notes, and projects so they don't feel like completely separate worlds. The most important part is the Morning Brief. Instead of opening five different apps and trying to figure out what deserves attention, Thread looks at the context available to it and answers a much simpler question: What should I care about right now? A meeting isn't treated as just a calendar event. Thread can connect it with the emails, people, documents, commitments, and tasks surrounding it. Search isn't just about finding a file. It's about being able to ask for something in the way you naturally remember it. Threads bring related information together around the projects and topics you're actually working on. The goal is not to add another place where information lives. The goal is to make the information you already have make sense.

How we built it

I started with the experience rather than the technology. I didn't want to build another dashboard covered in charts, notifications, and AI buttons. I wanted to open Thread and immediately understand what mattered. From there, I built the product piece by piece. The interface was built around a clean, focused workspace, while the backend handles authentication, data, integrations, retrieval, and the relationships between different pieces of information. Thread connects to services such as Gmail, Calendar, and Drive, retrieves relevant information, and uses AI to reason over the context rather than simply generating isolated responses. One of the most important parts of building it was creating a system where AI responses were grounded in the information actually available to Thread. I wanted the product to be able to say why something was important, not simply make something up that sounded intelligent. I also kept rebuilding the interface whenever something felt unnecessary. That became one of the defining principles of Thread: If a feature adds complexity without adding understanding, it probably shouldn't be there.

Challenges we ran into

The hardest challenge wasn't getting AI to generate text. It was getting the system to understand relationships. An email, a calendar event, a document, and a task can all refer to the same underlying piece of work without explicitly saying so. Making those connections useful—and doing it without overwhelming the user—was much harder than I expected. Another challenge was deciding what the product should not do. It is incredibly easy to keep adding features to an AI product. I had to repeatedly step back and ask: Does this make Thread more useful, or does it just make Thread bigger? There were also plenty of technical challenges along the way: authentication, integrations, data models, retrieval, API limitations, debugging, redesigning parts of the application, and rebuilding things when an approach simply wasn't good enough. And I was doing all of this while still being a student. There were moments when the project would have been much easier to abandon as a prototype. Instead, every time something didn't work, I treated it as another reason to make the product better.

Accomplishments that we're proud of

I'm proud that Thread became more than the original idea I had in my head. I started with a frustration about fragmented information. I ended up building a working system that can bring together multiple sources of context and turn them into an experience designed around what matters now. I'm especially proud of the Morning Brief because it represents the central idea behind Thread. It isn't simply: "Here are the things that happened." It tries to answer: "Here's what you should probably pay attention to—and here's the context behind it." I'm also proud of how much I learned by actually building the product instead of stopping at the idea. Thread forced me to think about product design, AI, APIs, authentication, data architecture, information retrieval, user experience, and, most importantly, what makes a product genuinely useful. But perhaps the accomplishment I'm most proud of is much simpler: I turned an idea that existed in my head into something another person can actually open and use.

What we learned

The biggest thing I learned is that AI itself isn't the product. Context is. Anyone can ask an AI to write something. The interesting question is: What does the AI know when it answers? Give it isolated information, and you get an isolated answer. Give it the right context—what happened, who was involved, what is coming next, what has already been discussed—and suddenly the interaction becomes much more useful. I also learned that great product design is often about subtraction. My first instinct was constantly to add. More features. More controls. More information. Over time, I learned that the best version of Thread was usually the version where I removed something and made the remaining experience clearer. And I learned something personally important: Being a student doesn't mean you have to build student-sized ideas. You may have fewer resources, less experience, and a lot more things competing for your time. But you can still start with a problem that feels enormous and try to solve it.

What's next for Thread

What's next

What you're seeing today is only the beginning of Thread.

The first version brings together a part of the Google ecosystem—Gmail, Calendar, Drive—and shows what becomes possible when those tools stop behaving like completely separate products.

But that is only one ecosystem.

Imagine adding Slack. Notion. Microsoft 365. WhatsApp. Linear. GitHub. CRM systems. Project management tools. Notes. Files. Travel. Personal planning. And eventually, the services that haven't even been built yet.

The exciting part isn't simply having more integrations.

It's what happens when Thread can understand the information flowing through all of them.

Today, an email might live in Gmail, a decision might be buried in a conversation, the deadline might be in a calendar, and the work itself might be sitting in a project-management tool.

Thread's opportunity is to make those pieces feel like one story.

The more context Thread can responsibly understand, the less the user has to do manually.

And that creates a very different kind of product.

Instead of asking:

"Which app do I need to open?"

You start asking:

"What do I need to know?"

And Thread figures out where the answer lives.

From workspace to personal context

The long-term vision goes beyond work.

The same problem exists everywhere.

You shouldn't have to remember which conversation contains the restaurant someone recommended, where the booking confirmation went, which calendar contains the trip dates, or which document has the information you need.

A system that understands those connections could eventually become useful far beyond productivity.

That is where I see Thread going:

from a workspace that understands your work to a layer that understands the context surrounding your life.

The opportunity grows with every connection

There is also something I find particularly exciting about the architecture of the idea.

Thread doesn't need to replace every tool.

It can let the tools people already love continue doing what they're good at, while Thread becomes the layer that helps them work together.

Gmail can remain Gmail.

Calendar can remain Calendar.

Notion can remain Notion.

Slack can remain Slack.

Thread can sit above them and answer the question none of them is designed to answer on its own:

"How does all of this connect?"

That means the vision doesn't depend on convincing the world to abandon the tools it already uses.

It depends on making those tools more useful together.

And this is just version one

I'm still a student, and I built the first version with the resources I have today.

That makes the future especially exciting to me.

With a larger engineering team, deeper integrations, stronger infrastructure, and more time to develop the underlying intelligence, there is so much further this idea can go.

I can imagine Thread becoming increasingly proactive—not simply waiting for someone to search for information, but recognizing when context could genuinely help and surfacing it at the right moment.

The goal isn't to create an app with hundreds of integrations just so we can say we have hundreds of integrations.

The goal is to reach a point where the boundaries between those tools stop mattering to the person using them.

Because that's what I think the next generation of software should feel like.

You shouldn't have to think about where your information lives.

You should be able to think about what you're trying to accomplish.

Thread is my first step toward that.

Built With

Share this project:

Updates

Submission history