Beta Features
Claude-Mem offers a beta channel for users who want to try experimental features before they’re released to the stable channel. The primary beta feature is Endless Mode — a biomimetic memory architecture designed to extend how long Claude can maintain context in a single session.Version Channel Switching
Switch between the stable and beta versions directly from the Web Viewer UI — no command line required.How to Switch Channels
What Happens During a Channel Switch
When you switch versions, the following steps occur automatically:- Local changes are discarded — Any modifications in the plugin directory are reset
- Git fetch and checkout — The installed plugin switches to the target branch
- Dependencies reinstall —
npm installruns to ensure correct dependencies for the branch - Worker restarts automatically — The background service restarts with the new version
Your memory data is always preserved. The database at
~/.claude-mem/claude-mem.db is not affected by version switching. All your observations, sessions, and summaries remain intact.Version Status Indicators
The Version Channel section in Settings shows your current channel:| Badge | Color | Meaning |
|---|---|---|
| Stable | Green | You’re running the production release |
| Beta | Orange | You’re running the beta with experimental features |
main for stable or beta/endless-mode for beta.
Endless Mode (Beta)
The flagship experimental feature in the beta channel is Endless Mode — a biomimetic memory architecture that dramatically extends how long Claude can maintain context in a session.The Problem Endless Mode Solves
In standard Claude Code sessions, context window exhaustion is a fundamental constraint:- Tool outputs (file reads, bash output, search results) accumulate in the context window
- Each tool call can add 1,000–10,000+ tokens to the context
- After roughly 50 tool uses, the context window fills (~200k tokens)
- You’re forced to start a new session, losing conversational continuity
How Endless Mode Works
Endless Mode applies a two-tier memory architecture inspired by how human memory works:- Waits for the worker to generate a compressed observation (blocking, up to 110 seconds)
- Transforms the transcript file on disk
- Replaces the full tool output with the compressed observation
- Claude resumes with the smaller, compressed context
Key Architecture Components
Pre-Tool-Use Hook
Pre-Tool-Use Hook
Tracks the start of each tool execution and sends a
tool_use_id to the worker service for correlation.Save Hook (PostToolUse) — Critical
Save Hook (PostToolUse) — Critical
Blocks execution until a compressed observation is generated (110-second timeout). This is what makes Endless Mode synchronous — the full tool output is replaced before Claude’s next response begins.
SessionManager.waitForNextObservation()
SessionManager.waitForNextObservation()
An event-driven wait mechanism with no polling. The hook subscribes to completion events from the SDKAgent rather than checking the database on an interval.
SDKAgent
SDKAgent
Generates observations via the Claude Agent SDK and emits completion events that unblock the waiting Save Hook.
Database Schema
Database Schema
Extended with a
tool_use_id column for observation correlation between the Pre-Tool-Use hook and the Save Hook.Projected Results
- Token savings: Significant reduction in context window usage per session
- Efficiency gain: More tool uses possible before context exhaustion
- Quality preservation: Observations cache the synthesis result, so no information is lost from the full tool output
Important Caveats
Not in Stable Release
You must manually switch to the beta branch to use this feature. It is not available on the
main branch.Slower Than Standard Mode
The blocking observation generation step adds latency to every tool use while the worker processes the output.
Theoretical Projections
Efficiency claims are based on simulations, not real-world production data. Results have not been validated at scale.
New Architecture
Less battle-tested than standard mode. May have bugs, breaking changes, or incomplete functionality.
When to Use Beta
Consider switching to the beta channel if you:- Frequently hit context window limits during long sessions
- Work on complex, multi-hour sessions with many tool uses
- Want to help test and provide feedback on new features
- Are comfortable with experimental software and occasional instability
When to Stay on Stable
Stay on the stable channel if you:- Need maximum reliability for critical or production work
- Prefer battle-tested, production-ready features
- Do not frequently hit context window limits
- Want the smoothest and fastest experience
Manual Channel Switching (Command Line)
If you prefer the command line over the web viewer:- Switch to Beta
- Switch Back to Stable
Checking for Updates
While on either channel, you can pull the latest changes:- Open Settings in the web viewer (
http://localhost:37777) - In the Version Channel section, click Check for Updates
- The plugin pulls the latest changes and restarts automatically
Switching Back to Stable
If you encounter issues on beta:- Open Settings in the web viewer
- Click Switch to Stable
- Wait for the worker to restart
Providing Feedback
If you encounter bugs or have feedback about beta features:- Open an issue at GitHub Issues
- Include your branch name (e.g.,
beta/endless-mode) in the report - Describe what you expected vs. what actually happened
- Include relevant worker logs if available (
npm run worker:logs)
Next Steps
Configuration
Customize Claude-Mem settings including observation limits and context injection behavior.
Architecture Overview
Understand how the hooks, worker service, and database work together under the hood.
Troubleshooting
Common issues and solutions for both stable and beta channels.
Getting Started
Review how Claude-Mem’s automatic operation works if you’re new to the plugin.