AI Memory — Visible, Portable, Yours

AI that learns
what works.

Chorum extracts patterns from your conversations, shows you exactly what it learned, and gets smarter over time. Your memory, your rules.

See How It Works

"Other AI tools learn in the dark.
Chorum learns in the open."

Real Problems, Real Solutions

Sound Familiar?

The Context Problem

"Always use Zod for validation." You've told Claude this 47 times this month.

Every new conversation starts at zero. Your patterns, your preferences, your architectural decisions — forgotten. You spend the first five messages of every chat re-establishing context that should already exist.

With Chorum: It learns your patterns automatically — no "remember this" commands. Tell it once. Chorum surfaces it when it matters and stays quiet when it doesn't.

// learned: typescript-validation
// used 47x · confidence: 0.94
---
"Always use Zod for runtime validation.
Parse, don't validate. Schema-first."
→ auto-injected when context matches
domain: coding · type: preference

The Visibility Problem

"What did it learn from that conversation?" You have no idea.

Every AI memory tool claims to learn from you. None of them show you what. You're training a system you can't inspect, can't correct, and can't trust. When it gives bad advice, you don't know why — and it'll do it again.

With Chorum: After every response, you see exactly which memories shaped it. Pin what's useful. Mute what isn't. Ask "why did you say that?" — and get a real answer.

♫ Conductor Trace3 items · 847 tokens

Chorum remembered 3 things

RulePinned

Always auth API routes before processing

Preference

Use Result<T,E> for error handling

Decision

Drizzle ORM for all DB operations

Memory DepthBalanced

The Lock-In Problem

Six months of Claude conversations. Now you want to try GPT. What happens to all that context?

Your conversation history lives in their silos. Your patterns are trapped in each provider's separate universe. Switching means starting over. You're not a customer — you're a hostage.

With Chorum: Your knowledge graph is encrypted, exportable, and yours. Switch providers without losing a single insight. Models are interchangeable — your memory isn't.

$ chorum export --project "my-startup"
> passphrase: ********
✓ 142 patterns
✓ 38 decisions
✓ 12 rules
✓ my-startup-2026.chorum
AES-256-GCM · 2.3 MB · yours forever

Why Chorum

What Makes It Different

Learning you can see

Most AI memory is a black box. Chorum shows you exactly what it learned, why it surfaced something, and how confident it is. Disagree? Fix it with a tap.

Memory that stays fresh

Stale patterns fade. Useful ones get stronger. You're never getting advice from six months ago that no longer applies.

Domain-aware context

Coding patterns don't leak into your fiction writing. Your trading thesis doesn't appear when you're debugging. Chorum understands the difference.

Portable by design

Your knowledge is encrypted, exportable, and yours. Switch providers, switch platforms — your memory comes with you.

Human always in the loop

Chorum proposes changes based on what it observes. You approve or reject. Nothing updates without your say.

Capabilities

AI that learns how you work.

Smart Memory

Chorum extracts patterns, decisions, and rules from your conversations — automatically. No manual note-taking. No "remember this" commands. It just learns.

Visible Learning

See what Chorum remembered after every response. Pin what matters. Mute what doesn't. You're not training a black box — you're building a knowledge system you can trust.

Fresh Context

Learnings earn confidence over time. New patterns start tentative. Proven ones grow stronger. Stale advice fades away. Your context stays relevant.

Domain Modes

Coding, writing, research, trading — Chorum understands the difference. Each domain has its own extraction rules and memory types. No cross-contamination.

Works Everywhere

Chat interface, VS Code, Claude Desktop, CLI. Same memory, every surface. Chorum is a backend, not just an app.

Your Data, Your Rules

Encrypted at rest. Exportable anytime. Self-hostable if you want. No lock-in, no hostage data, no "we own your context" fine print.

Under the Hood

How Chorum Works

Four layers working together so your AI gets smarter without getting in your way.

◈

Your Knowledge Graph

Everything Chorum learns lives here — tagged, searchable, exportable

Automatic Extraction

After every conversation, Chorum identifies patterns, decisions, and rules. No tagging, no commands. It reads what happened and records what matters.

Confidence System

Every learning starts tentative. When it keeps proving useful, confidence grows. When it stops being relevant, it fades. Your context stays current.

Domain Separation

Coding advice stays with coding. Writing notes stay with writing. Tag your knowledge however makes sense — Chorum keeps it organized and surfaces it in context.

Encrypted at Rest

AES-256-GCM encryption. Export anytime. Self-host if you want. Your knowledge graph is yours — not a feature of someone else's platform.

♫

The Conductor

Learning you can see — and steer

Every AI tool claims to learn from you. None of them show you what they learned or let you correct it when they're wrong.

The Conductor is different. After every response, you see exactly which memories shaped it — not "context applied," but the actual items, with controls to keep what's useful and mute what isn't.

Pin what mattersMute what doesn'tTune memory depthFeedback that learns

For developers: Full observability — scores, retrieval reasons, confidence curves, domain signals.

For everyone else: "Chorum remembered 3 things" with a tap to see them and a tap to fix them.

♫Conductor Trace

3 items · 847 tokens

Chorum remembered 3 things

RulePinned

Always authenticate API routes before processing

Preference

Use Result<T,E> pattern for error handling

Decision

Drizzle ORM for all database operations

⊕

Smart Injection

The right context, at the right time — not everything, always

Reads the Room

Chorum doesn't dump everything it knows into every conversation. Coding question? You get your coding patterns. Writing session? Your voice and style notes appear.

Learns What Helps

Thumbs up a suggestion that helped? Chorum remembers. Thumbs down something that missed? It learns that too. Over time, the same mistakes stop happening.

Auto-Failover

Claude down? Rate-limited? Chorum routes to your next provider with full context intact. Your work never stops. Providers are interchangeable — your memory isn't.

Ask Why

Every suggestion can be traced back to what Chorum learned and when. You're never left wondering where something came from.

⋮

Any Provider, Any Interface

Same knowledge, everywhere you work

Cloud Providers

Anthropic (Claude), OpenAI (GPT), Google (Gemini), Perplexity. Bring your own API keys. Each provider's strengths, available on demand.

Local Models

First-class Ollama support. Run Llama, Mistral, or any model locally. Zero cost, full privacy, offline capable.

Every Surface

Chat interface, VS Code, Claude Desktop, CLI. Chorum is a backend, not just an app. Your knowledge follows you wherever you work.

Cross-Model Review

Have Claude write code, GPT review it for security holes. Different models, different strengths — same memory keeping it coherent.

Request Flow

Your prompt→Read the room→Score memories→Inject context→Route to provider→Response + learn

Take back your context.

Your memory, your rules.

View Documentation

AI that learnswhat works.