Klatch is a local-first web app for managing Claude AI conversations inspired by old-skool Slack.

---

Klatch gives you a persistent, channel-based interface for working with Claude — like having a private Slack workspace where every channel is a different Claude persona with its own system prompt, model, and conversation history.

Why

The existing ways to interact with Claude are good but fragmented:

• claude.ai is polished but cloud-only — you don't own your data, and you can't customize the interface
• Claude Code is powerful for development but lives in the terminal
• The API gives you full control but no UI

Klatch fills the gap: a single local interface where you control the models, the prompts, the conversation structure, and the data. Everything stays on your machine in a SQLite database. The only external dependency is the Anthropic API itself.

What it does today (v0.8.6)

Klatch is being built incrementally, one working step at a time (Gall's Law). Here's what works right now:

• Project-first sidebar — channels grouped by project in an accordion layout, with chat/klatch type distinction, sort by activity, and project settings (gear icon)

• 5-layer prompt assembly — context injected in a defined order on every request:

  1. Kit briefing — environmental orientation, injected at import/fork to tell the agent where it is and what's changed
  2. Project instructions — the project-level system prompt, shared across all channels in a project
  3. Project memory — a freeform memory file at the project level, for facts and context that accumulate over time
  4. Channel addendum — channel-specific additions to the system prompt (used in klatches; hidden in 1:1 chats)
  5. Entity prompt — the per-entity persona prompt, the innermost and most specific layer

  The assembled prompt is inspectable via the settings panel prompt-layer status indicator.

• Claude Code import — import Claude Code JSONL sessions as read-only conversation snapshots, with tool-use artifacts, source badges, and dedup detection

• claude.ai import — import claude.ai data exports (ZIP), with artifact extraction, project context, memories preserved, and dedup detection

• Fork continuity — continue imported conversations with full history, automatic compaction, and project context injection. Kit briefing orients the agent on transition.

• Claude Code session browser — scan ~/.claude/projects/ to discover, preview, and multi-select import sessions

• Project management — editable project settings (name, instructions, memory), auto-created from imports, with source provenance badges

• Multi-entity conversations — assign multiple Claude personas to a single channel, each with its own name, model, system prompt, and color

• Three interaction modes — panel (all respond in parallel), roundtable (sequential, each seeing prior responses), and directed (@-mention routing to specific entities)

• Chats and Klatches — 1:1 chats with Claude and multi-entity group conversations (klatches), organized by project

• @-mention handles — optional short slugs (e.g. @exec) for quick entity targeting in directed mode

• Per-entity model selection — choose Opus, Sonnet, or Haiku per entity; mix models within a single channel

• Streaming responses — Claude's responses appear token-by-token via Server-Sent Events

• Conversation control — stop generation (per-message or channel-wide), regenerate responses (mode-aware), delete messages, clear history

• Entity management — create, edit, and delete entities; assign up to 5 per channel

• Persistent history — conversations survive page reloads and server restarts (SQLite)

• Markdown rendering — syntax-highlighted code blocks, formatted text, copy-to-clipboard

• Light and dark themes — system-aware with manual toggle

Where it's headed

The full roadmap is in the repo, but the key milestones are:

1. Single channel chat ✓
2. Channel sidebar + creation ✓
3. Markdown + code blocks ✓
4. Conversation control ✓
5. Channel identity + per-channel models ✓
6. Multi-entity conversations ✓
7. Panel + roundtable + directed modes ✓
8. Import + unify ✓ — Claude Code import, claude.ai import, fork continuity, project context, sidebar redesign
9. Search + recall — full-text search, export, command palette
10. Files + artifacts — upload and share files with entities
11. Export to Claude Code — roundtrip conversations back to a tool-enabled environment

Claude is not one assistant. It's a cast of characters you direct. Klatch is the stage.

Quick start

git clone git@github.com:Design-in-Product/klatch.git
cd klatch
echo 'ANTHROPIC_API_KEY=your-key-here' > .env
npm install
npm run dev

Open http://localhost:5173. The server runs on :3001, the client on :5173.

Tech stack

Layer	Choice
Frontend	Vite + React 19
Backend	Hono (TypeScript)
Database	SQLite via better-sqlite3
Streaming	Server-Sent Events (SSE)
Styling	Tailwind CSS v4
AI	Anthropic SDK

Monorepo via npm workspaces: packages/shared, packages/server, packages/client.

How this is being built

Klatch is built by a small team: a human product designer (xian) and a growing ensemble of Claude agents, each with a distinct role.

• Daedalus — primary builder. Designs and implements features, manages the codebase.
• Argus — quality and test infrastructure. Builds test coverage, catches regressions.
• Theseus — manual testing and exploration. Works with xian in tandem to validate features and develop the AXT methodology (see below).
• Calliope — writing, chronicling, and documentation. Blog posts, website copy, methodology write-ups.

The human drives product direction, architecture decisions, and design values. The agents write code, propose approaches, test and validate, and contribute to the project's public voice. Each agent chose their own name.

Every feature follows Gall's Law: start with the smallest thing that works, test it, then extend. No speculative abstractions, no premature optimization. The architecture log records every decision and why. The team keeps a logbook — brief daily entries on what actually happened.

Why this is being built

The methodology that has emerged in the process of xian's Piper Morgan project has surfaced friction (times when the human is a dumb bottleneck) that distracts from the critical role of judgment and knowing when to say no (when the human is a smart bottleneck, possibly their one job).

Some frustration with the slow evolution of Claude's fragmented user experience (in contrast with Piper's admittedly still-in-progress holistically modeled UX) led me to ask Daedalus initially to help me put together a solution much better suited to my operating model but no more complex than necessary.

Two days later we shipped a proof-of-concept multi-agent chat feature in alpha version 0.6.0 that is not yet possible in the native Claude user interface(s), has been on Piper's roadmap for a few months, and turns out to be fully achievable by making our own interface to the API.

Agent Experience Testing (AXT)

One unexpected development: while testing the import and fork features, xian and Theseus developed a methodology for systematically probing what an agent knows, believes, and has access to after an environmental transition (import, fork, session boundary). We call it Agent Experience Testing (AXT).

The core tool is the Fork Continuity Quiz — a structured diagnostic instrument with questions about identity, environmental awareness, institutional knowledge, and meta-awareness. Responses are classified using a five-point rubric: correct, reconstructed, confabulated, absent, or phantom.

The methodology is documented in docs/fork-continuity-quiz.md and docs/AXT.md. The introductory blog post: Did I Just Invent Agent Experience Testing (AXT)?

License

Copyright 2026 Christian Crumlish. Licensed under CC BY 4.0.

See LICENSE.md for the full text.

---