Introducing CAS: Persistent Memory for AI-Assisted Development
AI coding assistants are powerful, but they have a critical flaw: they forget everything. CAS gives Claude Code persistent memory, task tracking, coding rules, and skills.
Introducing CAS: Persistent Memory for AI-Assisted Development
AI coding assistants are powerful, but they have a critical flaw: they forget everything. Every session starts fresh. Context you explained yesterday is gone. Decisions you made together vanish when you close the terminal.
Today, we're launching CAS (Coding Agent System)—a memory layer purpose-built for Claude Code that solves the context problem once and for all.
CAS gives Claude Code persistent memory, task tracking, coding rules, and skills. It's free, runs locally, and transforms how you work with AI assistants.
The Problem: AI Assistants Have Amnesia
If you've used Claude Code, Cursor, or any AI coding tool, you know the frustration:
- Repeated explanations: "Remember, we use React Query for server state..."
- Lost context: "Yesterday we decided to use JWT, not sessions..."
- Forgotten conventions: "I told you, async/await only, no .then() chains..."
- No task continuity: "Where was I on that authentication feature?"
The underlying models are incredibly capable. But without persistent context, every session is like working with a brilliant developer who has short-term memory loss.
Why This Happens
LLMs are stateless by design. Each request is processed independently. Claude doesn't "remember" your previous conversations—it only sees what's in the current context window.
CLAUDE.md helps, but it's manual. You write it once and rarely update it. It doesn't capture the dynamic learnings, decisions, and progress from your actual work.
---
The Solution: CAS
CAS is a Model Context Protocol (MCP) server that runs alongside Claude Code, providing four core capabilities:
title="Persistent Memory" description="Store learnings, preferences, and discoveries that persist across sessions." /> title="Task Tracking" description="Track work with full context restoration. Pick up exactly where you left off." /> title="Coding Rules" description="Standards and conventions that surface automatically when relevant." /> title="Skills" description="Captured workflows and procedures that can be invoked by name." />
How It Works
CAS integrates as an MCP server. Once configured, new tools become available in Claude Code:
``
Store important context
cas_remember: "This project uses TailwindCSS v4 with @apply for component variants"
Track tasks with full context
cas_task_create: "Implement user authentication with JWT"
cas_task_start: "cas-abc1"
Search across everything
cas_search: "How did we handle rate limiting?"
Rules that auto-surface
cas_rule_create: "Always use async/await instead of .then() chains"
`
When you start a session, CAS provides relevant context automatically. When you close a task, its learnings persist. When you search, you find answers from past work.
---
Key Features
Unified Memory
CAS stores different types of information with appropriate metadata:
| Type | Use Case | Example |
|------|----------|---------|
| Learning | Facts discovered during work | "API uses pagination with cursor tokens" |
| Preference | User-specific choices | "Prefer functional components over classes" |
| Context | Project-specific info | "Auth service runs on port 3001" |
| Observation | Session discoveries | "Found memory leak in useEffect cleanup" |
All memories are searchable through hybrid BM25 + semantic search.
Task Tracking with Context
Unlike simple todo lists, CAS tasks carry full context:
`
cas_task_create: "Fix authentication bug"
cas_task_start: "cas-abc1"
Work on the task...
cas_task_notes: "Found issue: JWT expiry check uses wrong timezone"
cas_task_notes: "Solution: Use UTC consistently in all date comparisons"
cas_task_close: "Fixed by adding UTC normalization in jwt.verify()"
`
When you revisit a closed task or start a related one, the full context is available.
Automatic Rule Surfacing
Coding rules in CAS aren't just stored—they surface when relevant:
`
Create a rule
cas_rule_create:
content: "Use Zod for all API input validation"
paths: "src/api/*/.ts"
`
When you're working in
src/api/, this rule appears in context automatically. When you're elsewhere, it doesn't consume tokens.
Skills for Repeated Workflows
Capture procedures you use repeatedly:
`
cas_skill_create:
name: "deploy-staging"
description: "Deploy to staging environment"
invocation: "bun run build && wrangler deploy --env staging"
`
Skills are available across sessions and can be invoked by name.
---
Why CAS Over Alternatives?
vs. CLAUDE.md
CLAUDE.md is static. You write it once and it rarely reflects your evolving understanding. CAS captures learning dynamically as you work.
| CLAUDE.md | CAS |
|-----------|-----|
| Static document | Dynamic memory |
| Manual updates | Automatic capture |
| Always in context | Selective surfacing |
| Project-level only | Multi-level + search |
vs. Mem0
Mem0 is a powerful universal memory layer for any AI application. CAS is purpose-built for Claude Code development workflows.
| Mem0 | CAS |
|------|-----|
| Universal, any LLM | Claude Code specific |
| Cloud-hosted (default) | Local-first |
| Memory only | Memory + Tasks + Rules + Skills |
| API costs | Free tier available |
If you're building customer-facing AI apps, Mem0 is excellent. If you're using Claude Code for development, CAS is purpose-built for your workflow.
vs. Custom Solutions
You could build your own context system. Many developers have tried. CAS gives you a tested, integrated solution from day one.
---
Installation
CAS installs in seconds:
`bash
Add CAS to Claude Code
claude mcp add cas
`
That's it. CAS runs locally—no API keys, no cloud accounts, no costs.
Configuration
CAS stores data in
~/.cas/ by default. Customize in your MCP config:
`json
{
"mcpServers": {
"cas": {
"command": "cas-mcp-server",
"env": {
"CAS_DATA_DIR": "/path/to/custom/location"
}
}
}
}
`
---
Getting Started
Run
claude mcp add cas to add CAS to your Claude Code setup.
When you learn something important, use
cas_remember to store it.
Use
cas_task_create for significant work. Add notes as you progress.
When you establish conventions, create rules so they surface automatically.
Use
cas_search to find relevant information from past sessions.
Quick Examples
Remember a discovery:
`
cas_remember: "This codebase uses React Query v5 with suspense mode enabled"
`
Track a task:
`
cas_task_create: "Implement user dashboard"
cas_task_start: "cas-xyz1"
`
Create a coding rule:
`
cas_rule_create: "Always handle loading and error states in data fetching components"
`
Search for context:
`
cas_search: "How did we implement pagination?"
`
---
What's Next
CAS is just getting started. Our roadmap includes:
- Team collaboration: Shared memories and rules across team members
- IDE integrations: Extensions for VS Code and JetBrains
- Enhanced analytics: Insights into your development patterns
- Workflow automation: Trigger actions based on task states
We're building in public. Follow development, report issues, and contribute at our GitHub repository.
---
Try CAS Today
Every Claude Code session without CAS is context lost forever. Learnings fade, decisions get forgotten, and you repeat explanations endlessly.
CAS changes this. Your AI assistant finally remembers what matters.
CAS has a free tier and runs locally. Install it today:
claude mcp add cas`
---