Accessibility · Public interest
Bunch: a context system for continuity across memory gaps
I built Bunch to meet a continuity need that the tools I had tried did not address: recovering working context across memory gaps. The source code and data model are public to inspect, and a no-sign-in demo uses fictional records. The engineering problem was preserving context so the right information surfaces at the moment it matters. The accessibility problem turned out to be the same problem in a different hat.
- Try the interactive demo (opens in a new tab)
- How I engineered Bunch →
- View the source code (opens in a new tab)
- My role
- Product design, architecture, agent-assisted implementation, testing, and delivery.
- System
- Web app + MCP server, shared service rules, PostgreSQL.
- Inspect it
- Public source and a fictional-data demo. Source rights are reserved; this is not an open-source licence.

Evidence
Proof you can inspect
- Observed recovery
- About 15 seconds for one real catch-up that had previously taken roughly 20 minutes to reconstruct manually.
- Public implementation
- Source code, setup documentation, and the data model are published.
- Shared engine
- The web app and MCP server operate on the same explicit records and service rules.
- Production failure analysis
- Nine OAuth failures connecting the MCP server to ChatGPT, each fixed with a regression test and without loosening the private-data boundary. Read it
The 15-second result is one personal observation, not a population-wide performance benchmark.
Engineering & product
What the artifact taught me
Under the hood
Bunch has two front doors onto the same records: a web application for browsing and editing, and an MCP server so an AI assistant can read and write under the same rules.
The record model is deliberately explicit. A missing entry means nothing was recorded; the system does not infer that nobody was present. That boundary is part of the product, not an implementation footnote.
The product insight
I started by thinking I was building identity-tracking software. The more general problem was continuity: preserve enough structured context that the next person, session, or interface can keep going.
That makes the architecture productizable across different surfaces. The audience-specific language can change while the core job stays the same: maintain canonical context, track changes over time, and hand a harness the smallest useful packet of truth.
The problem
I have spent years trying to accommodate a practical problem created by dissociative amnesia while maintaining a demanding professional career. Earlier tools helped me track who was fronting, but they were much better at looking inward than helping me recover what had happened in the outside world.
What I owned
I owned the product decisions, record model, web and MCP interfaces, and the rules that keep them consistent. I used AI as an implementation tool and retained responsibility for reviewing, testing, and shipping the result.
What I did
I experimented first with community tools like PluralKit and Simply Plural, then began building small applications against their APIs. That process taught me both API integration and the limits of identity tracking alone. Later, while working deeply with AI context management, I reframed the problem: the interface was not the important part. Continuity of context was. I began building Bunch as an accessibility harness designed around that idea.
What changed
During one weekend, another alter was continuously fronting and I had little usable memory of what had happened. Instead of spending roughly 20 minutes asking people and reconstructing events manually, Bunch gave me a summary of everything I had worked on since I was last present in about 15 seconds.
That changed the problem from “How do I keep track of who I am?” to “How do I make sure the next version of me can keep going?”
The newsletter
Get the build notes.
I write about building AI systems in public—what worked, what broke, and what I’d do differently.
