How Hubble's Open-Source Notetaking App Is Redefining Human-AI Collaboration

Why Hubble Just Launched an Agent-Ready Notetaking App (And What It Means for Founders)

Most notepad to-do you send it?’ It’s a note-taking app for you and your AI agents to collaborate in real time.

Hubble, an open-source notetaking app built with web technologies, just released a version that treats AI agents as first-class collaborators. The app lets you and your AI co-edit notes, share context, and build workflows without leaving the editor. For founders building AI-powered products, this isn’t just another note-taking tool - it’s a glimpse into how human-AI teamwork will actually work.

Background

Hubble launched earlier this year as a Markdown-based notetaking app with a focus on simplicity and extensibility. It’s built on a plugin architecture that lets anyone add features via web technologies. The latest release, version 0.8.0, introduces two key agent-friendly features: real-time collaborative editing with conflict resolution and a structured context API that lets agents read and write notes in a predictable format.

The timing is notable. As AI agents become more capable of handling tasks like research, drafting, and workflow automation, the bottleneck shifts to how humans and agents share information. Traditional tools like Google Docs or Notion weren’t built for agents to natively interact with them. Hubble’s approach is to make the note itself the shared workspace.

Key Insights

1. Real-time collaboration isn’t just for humans anymore.

   Hubble’s new collaboration layer uses operational transforms (OT) to synchronize changes between multiple clients, whether that client is a human typing in the UI or an AI agent sending JSON patches via the API. This means an agent can update a task list in a note while you’re reading it, and you’ll see the change instantly - no refresh needed.

2. The context API turns notes into structured data agents can act on.

   Beyond plain text, Hubble now supports a frontmatter-like metadata block that agents can read and write. For example, an agent could tag a note with #action-item and set a due date, then another agent or a automation workflow could pick it up and act. This transforms notes from passive documents into active nodes in a workflow.

3. Open source and extensible by design.

   Because Hubble is open source (MIT license) and built on web technologies, developers can create custom views, plugins, or even entirely new interfaces that interact with the same note store. This means you’re not locked into a single way of working with your AI teammates - you can shape the tool to fit your process.

What This Means for Founders

If you’re building an AI product, consider how your users will collaborate with the agent. Hubble shows that the note - a simple, familiar format - can be the common ground. Here’s how to apply this insight:

1. Treat shared state as a first-class citizen. Whether it’s a note, a task board, or a document, make sure your agent can read and write to it in real time without friction. Look for technologies like OT or CRDTs that enable conflict-free collaboration.
2. Design for structured, machine-readable context. Humans can parse unstructured notes easily; agents need schema. Think about how to embed lightweight metadata in your shared artifacts so agents can understand intent, priority, and dependencies without complex NLP.
3. Leverage extensibility to let users shape the experience. No single interface will fit every workflow. By making your collaboration layer pluggable, you empower users (or your community) to build the specific views and tools they need - whether that’s a kanban board, a calendar view, or a code snippet manager.

Hubble’s release is a quiet signal that the future of human-AI collaboration won’t require fancy new interfaces - it’ll start with the tools we already use, made just a little smarter. For founders, the opportunity isn’t just to build better agents, but to build better shared spaces where humans and agents can truly work side by side.

What This Means for Founders (continued)

One concrete step: if you’re developing an AI agent that interacts with users, prototype a simple note-based interface using a library like Yjs (which powers Hubble’s collaboration) and see how it changes the dynamics. You might find that reducing the friction of information exchange unlocks more ambitious use cases than you originally imagined.

Another angle: consider open-sourcing your collaboration layer. Hubble’s MIT license means anyone can host their own instance or build proprietary extensions on top. For early-stage startups, this can reduce development time and foster community trust.

Finally, think beyond text. The same principles apply to any shared artifact - designs, spreadsheets, code notebooks. The key is making the artifact both human-friendly and agent-accessible.

---

In a world where AI agents are becoming teammates, not just tools, the humble note might just be the most important interface we have.