RadioHeader

Cross-project memory for Claude Code. Stop re-solving bugs you already fixed in another project.

The Problem

Coding agents like Claude Code are great at analysis, but they don't accumulate experience. Even with the built-in memory system, Claude remembers the general direction — not the key details. And project memories are completely isolated: what Project A learned, Project B has no idea about.

Existing tools (.cursorrules, awesome-rules, CLAUDE.md) work at the "rules" level. RadioHeader works at the experience level — the kind of know-how you only get by hitting a problem yourself, solving it, and writing it down.

The name — I'm a fan of the band Radiohead, and this system works like a signal tower that projects tune into when they need information. RadioHeader.

What Changes

Before — Claude encounters a white screen bug in Project B:

You: App shows white screen for 10+ seconds on launch

Claude: Let me investigate... [reads files, runs debugger, checks logs]
        ... 30 minutes later ...
        Found it! Task {} in .onAppear inherits MainActor,
        blocking iCloud I/O on the main thread.
        Fix: use Task.detached(priority:)

After — Same bug, but RadioHeader is installed:

You: App shows white screen for 10+ seconds on launch

Claude: RadioHeader has experience from ProjectA:
        "Task {} in SwiftUI .onAppear inherits Main Actor —
        iCloud I/O blocks main thread, causing 10s+ white screen.
        Fix: use Task.detached(priority:)"

        Let me verify this applies here... ✓ Same pattern confirmed.
        Applying the fix now.

From the second time onward, the same class of problem goes from minutes to seconds. Not because the AI got smarter — because the answer was already there.

Key Features

Three-Layer Memory — RadioHeader (global, shared by all projects) → Project memory (project-specific) → Session context (ephemeral). Experience flows up from projects to the global hub, then back down to wherever it's needed.

Echo (Experience Flows Back) — After each task, experience automatically flows back into the memory system. Four hooks drive the cycle: SessionStart shows status, PostToolUse detects memory writes and triggers Echo, Stop reminds Claude to check for new experience. No manual intervention needed.

Shortwave (Knowledge Distillation) — Topic entries contain project-specific details ([source:MyApp]). Shortwave strips out project names, file paths, and framework details into universal, project-agnostic knowledge units — searchable across any tech stack. This also protects privacy: raw entries might contain project paths, internal naming, or API keys. Shortwave removes all of that.

Search → Apply → Trace — Not a suggestion, a mandatory behavioral rule injected into CLAUDE.md. When Claude finds relevant experience, it must cite and apply it. Finding experience but ignoring it is explicitly prohibited.

Learn (External Knowledge) — RadioHeader isn't limited to lessons learned the hard way. The learn command extracts articles from any URL — including walled gardens like WeChat Official Accounts, Medium, and Substack — and distills them into shortwave entries. This turns RadioHeader from a passive experience manager into an active information gateway for Claude Code: not just remembering mistakes, but actively absorbing knowledge from the outside world.

Context Digest (Attention-Compressed Awareness) — Inspired by Kimi's Attention Residuals research, RadioHeader builds a compressed environmental awareness profile that gets injected at session start. Instead of weighting search results (which adds little value when content matching already works), the attention mechanism operates at the memory consolidation level — like sleep consolidation in human memory. Every few memory syncs, consolidate automatically runs and produces a context-digest.md containing: user traits (problem-solving style, strengths, known weaknesses), a full project landscape with scope annotations (each project's path, so the Agent can navigate directly), recent search patterns, and cross-project technology overlaps. The digest enforces a 3,500-character budget (inspired by Claude Code's internal 4K-per-file instruction limit) — when projects grow, lower-priority sections are automatically dropped to stay within budget, with a secondary guard in the loader hook. The Agent starts every session already knowing who it's helping — not just what code it's looking at.

User Profile (Three Dimensions) — RadioHeader maintains a user model across three dimensions: (1) What you've done — project portfolio with domains, problems, and pain points tracked in project-registry.json; (2) How you work — problem-solving style, interaction preferences, known strengths and weaknesses; (3) What you have — devices, network access, infrastructure. This profile serves as the "query vector" for memory consolidation — it determines what gets emphasized, what gets connected, and what the Agent should proactively watch for.

Community Sharing — Opt-in community shortwave library. Your local experience stays local; when you choose to publish, entries pass three gates (quality score ≥6/8, privacy scan, dedup check) before reaching the shared pool. Quality follows a Stigmergy model — like ant pheromone trails: good entries get reinforced through usage, bad entries decay naturally.

Quick Start

git clone https://github.com/ZaptainZ/radioheader.git
cd radioheader
./install.sh

That's it. Start Claude Code in any project and RadioHeader is active — hooks fire, rules are loaded, experience is searchable. The installer is fault-tolerant: if your existing settings.json is corrupted, it backs up and rebuilds automatically instead of failing.

Optionally, run radioheader init inside a project to add per-project scaffolding (Echo rules, log directory, doc templates). This is not required — RadioHeader works globally without it.

How It Works

RadioHeader (~/.claude/radioheader/)
├── shortwave/            ← refined, project-agnostic knowledge
├── topics/               ← detailed experience with [source:] tags
├── project-registry.json ← project cards (domains, problems, pain points)
├── user-profile.md       ← user traits (work style, resources)
├── context-digest.md     ← attention-compressed awareness (auto-generated)
└── INDEX.md              ← master index

    ▲ Echo        ║ search      consolidate ──→ context-digest.md
    ║             ▼                                    ║
                                                       ▼
Project A memory/    Project B memory/    SessionStart (injected)

When you solve a bug, Claude records it in the project's memory. A PostToolUse hook fires and prompts Claude to check: is this useful cross-project? If yes, it flows up to topics/ with a [source:ProjectName] tag, then gets distilled into a shortwave/ entry.

The three layers connect like this: experience flows back to RadioHeader via Echo, then Shortwave strips project noise and turns it into reusable knowledge that can be broadcast across all projects.

Later, in a different project, Claude hits a similar issue. The Search → Apply → Trace rule kicks in: search RadioHeader first, cite and apply what's found, trace back to the source project if more detail is needed.

Learn — The Second Channel

Echo captures experience from mistakes. learn captures knowledge from articles:

Sources                     RadioHeader               Consumers
─────────────────           ─────────────────         ─────────────────
Bug fixes (Echo) ────────→                        ──→ search command
Web articles (learn) ────→  topics/ + shortwave/  ──→ Agent Search→Apply→Trace
Community (sync) ────────→                        ──→ publish to community
User behavior ───────────→  consolidate           ──→ context-digest (SessionStart)

This makes RadioHeader an information gateway — the single entry point through which external knowledge flows into Claude Code's working memory. Not a browser, not a bookmark manager — a system that absorbs, distills, and serves knowledge exactly when it's needed.

Consolidate — Memory During Sleep

Human memory compresses during sleep: episodes fade, but patterns and skills solidify. RadioHeader's consolidate command does the same:

Memory syncs accumulate → every 5 syncs, consolidate runs automatically
                                    ↓
                  Analyzes search logs + project activity + user profile
                                    ↓
                  Generates context-digest.md (compressed awareness)
                                    ↓
                  Next session: Agent starts with full environmental context

The context digest tells the Agent, before any code is read:

Who it's helping — problem-solving style, strengths, known weaknesses
What they're working on — 12 projects with their domains, pain points, activity levels
What they've been searching — recent focus areas and hot topics
Where technologies overlap — which skills transfer across projects

This is not search optimization — it's Agent calibration. The difference: without the digest, the Agent treats every user the same. With it, the Agent knows this user tends toward greedy initialization on startup paths, has weak schema migration testing habits, and is currently focused on search quality improvements. That context shapes every recommendation.

Community Sharing

The default community repository is radioheader-community (you can point to your own via `config.

Radioheader

Install / Use

README