branchat

Git for AI chats

Comment

Inspiration

Modern AI chat platforms like Gemini, ChatGPT, and Claude are powerful but face three consistent user pain points:

  1. Conversations quickly become unstructured and hard to navigate.
  2. Memory is inconsistent, either remembering too much or forgetting useful context.
  3. Insights from previous chats remain trapped, making it hard to reuse knowledge efficiently.

These issues make it difficult for users, developers, and researchers to manage complex ideas and maintain meaningful continuity. We built Branchat to solve this by rethinking how AI conversations are structured, recalled, and extended, locally and privately.

What it does

Branchat is a next-generation AI workspace that transforms ordinary chats into structured, intelligent knowledge flows.

  • Users can branch any message into a SubChat, a focused sub-conversation that explores a specific idea without losing context.
  • Each SubChat ends with two actions: Merge and Continue (combine insights into the main chat) or Continue Without Merging (keep it separate).
  • When starting a new chat, users can choose between using past memory or starting fresh, ensuring full control over context and hallucination prevention.
  • Every conversation and sub-conversation is summarized into clear, reusable knowledge blocks stored locally for privacy and reusability.

This creates a workflow that feels like “Git for conversations” - branch, explore, and merge ideas seamlessly.

How we built it

Branchat was built as a web application using Chrome’s built-in AI APIs combined with a lightweight backend and local-first architecture.

  • Frontend: Built with Next.js and React to replicate a ChatGPT-like interface, extended with UI states for SubChats and memory control.
  • Backend: Handles structured conversation data, memory storage, and summary management.
  • APIs used:
    • Prompt API: Generates structured, context-aware prompts dynamically, enabling SubChat creation and multimodal (text, image, audio) input.
    • Summarizer API: Automatically distills SubChats and main threads into concise summaries for local memory.
    • Writer API: Creates original, context-sensitive responses during SubChats.
    • Rewriter API: Refines merged summaries for clarity and cohesion.
  • Local-first integration: By leveraging Chrome’s on-device AI APIs, all processing (prompting, summarization, rewriting) happens locally for faster response and complete privacy.

This hybrid model allows the app to run efficiently both online and offline, providing a resilient and secure user experience.

Challenges we ran into

  • Context management: Designing a memory system that feels natural without overwhelming the user required multiple iterations of data structuring.
  • UI complexity: Building a dynamic interface that could switch between SubChat, Merge, and Main Chat modes while staying intuitive was challenging.
  • API integration: Balancing the use of multiple Chrome built-in AI APIs locally while maintaining performance and modularity required fine-tuning.
  • Summarization accuracy: Ensuring that summaries captured meaningful insights without losing nuance was key to maintaining user trust.

Accomplishments that we're proud of

  • Successfully created a modular SubChat system that mimics Git-style branching and merging within AI conversations.
  • Achieved a privacy-first memory layer where all context and summaries are stored locally on the client.
  • Integrated multiple Chrome built-in AI APIs to create a smooth, intelligent, and context-aware chat experience.
  • Built a highly functional, offline-capable AI workspace that bridges productivity and structured reasoning.

What we learned

  • Chrome’s built-in AI APIs can form the backbone of complex, privacy-preserving applications without relying on external servers.
  • Structured summarization and user-controlled context dramatically reduce hallucination and improve AI response quality.
  • Designing for clarity and cognitive flow in AI UIs is as crucial as model performance - users need to feel in control of their memory and reasoning.
  • Hybrid architectures (local + minimal backend) can deliver both power and privacy without sacrificing usability.

What's next for Branchat

  • Launch SDKs and APIs: Extend Branchat as an SDK or API layer (“Branchat Kit”) for developers to integrate structured chat and memory into their own tools.
  • Chrome Extension: Build a browser extension version to allow users to branch, summarize, and recall context across the web.
  • Enhanced multimodal support: Integrate image and audio reasoning more deeply via the Prompt API for richer SubChats.
  • Collaborative memory: Allow teams to merge and manage collective reasoning threads while maintaining individual privacy.
  • Open-source release: Publish the project with documentation and invite developer contributions.

Branchat aims to redefine how humans interact with AI, turning isolated conversations into a continuous, evolving flow of structured intelligence.

Built With

Share this project:

Updates