Persistent memory for coding agents

chitta stores memories, indexes code, and injects retrieved context into Claude Code and Codex sessions. A C++ daemon manages the local Rust store.

Install the plugin, then configure the agent hooks.

Get started Explore the tools View on GitHub

claude plugin install chitta@genomewalker-chitta

Restart Claude Code to load the plugin.

Also works with Codex — see the Codex setup guide.

Full setup guide →

Status as of 2026-09-20 · v5.73.0

Native hooks, startup measurements, relation transfer

The project is now chitta. Plugin, marketplace and repository moved to the name the binaries always had. Every CC_SOUL_* variable, stored realm and existing store keeps working through an alias shim — see the rename note for the three migration commands. Recall-biased pre-filter. Recall now widens the candidate pool and over-selects it with cheap scalar rules instead of cutting at the top of the ranking. On the 30-query golden set, mean nDCG@20 went from 0.435 to 0.487. How recall works → SMRITI-Bench. A benchmark that asks whether memory changes an objective pass/fail check and its token cost, rather than scoring conversational recall. First matrix: 23/27 tasks passed without memory, 27/27 with, at roughly half the tokens. Protocol and caveats → Relation transfer answers a:b::c:? through actual indexed graph edges and explains abstentions: 14/14 positive hits and 14/14 negative abstentions on the frozen benchmark. Native hooks and startup. Routine lifecycle paths use bash/jq and the CLI; task ledgers are daemon-owned. Snapshot sidecars and parallel decode bring measured warm startup to about 9.5 s. Replication weighting remains default-off. Evolve offers opt-in --candidates N streams; the automatic-learning experiment's prospective panel is still pending. See the changelog →

Memory across sessions

The store holds preferences, corrections, and project records.

Access reinforces memories. Confidence decays over time.

Prompt hooks retrieve context from previous sessions.

Pratyabhijñā — recall examples

> An auth query can retrieve a stored decision to use JWT over sessions, with its date and recorded reasoning.

> A debugging query can retrieve a previous connection-pool failure and its recorded resolution.

> A build query can retrieve a recorded convention to run the linter first.

> The /shepherd skill monitors a snakemake pipeline, detects errors, retrieves recorded fixes, and attempts restarts. It reports completion or unresolved errors.

Memory records and retrieval

Stored content and metadata supply the retrieval and maintenance pipelines.

Stored records

Memory content and timestamps
Keywords and embeddings
Per-memory confidence
Observed workflow patterns
Realm and theme membership

chitta

Access reinforcement and confidence decay
Embedding similarity search
Confidence tracking per memory
Habit matching and action prediction
Self-organizing theme clusters

Explore the philosophy behind it →

Memory components

Semantic retrieval

Semantic retrieval compares query and memory embeddings to rank related content.

Confidence tracking

Tracks confidence over time through reinforcement and decay.

Graph retrieval

Graph traversal follows relationships between memories and contributes candidates to recall.

Local storage

The daemon owns an embedded Rust store. Agent sessions query it through RPC.

Memory compression

Memory compression stores condensed records for retrieval. The documented maximum size reduction is 95% relative to raw text.

Background maintenance

The daemon runs memory reinforcement, decay, and consolidation between sessions.

Pipeline monitoring

Autonomous monitoring for snakemake, nextflow, or slurm jobs. Sense-think-act loop detects errors, applies fixes from memory, restarts automatically.

Workflow patterns

Records recurring trigger/action pairs, such as linting before a commit, and returns matching action predictions.

Goals and work modes

Stores goals and milestones. Work-mode detection uses tool activity to distinguish modes such as building and debugging.

chitta-field — Rust memory store

Memory lives in chitta-field, an embedded Rust store linked into the daemon. Claude Code and Codex sessions share the daemon over RPC; one daemon owns each store through an instance lock.

Each memory is encoded as a sparse code: exactly 64 of 16,384 feature dimensions activate. Recall is driven by overlap between patterns, not keyword matching. Memories with overlapping active features become retrieval candidates.

Snapshots and uncovered write-ahead log records recover the store. Ordinary WAL syncs are batched on a 200 ms timer; explicit durable operations force persistence. Warm sidecar startup measured about 9.5 s on the current live store, with about 20 s for the first start after deployment.

16,384 feature dimensions

64 active per memory

0.4% sparsity

<1ms recall via cortical index

Sparse field activation — each pulse is one memory encoding 64 / 16,384 features

Active feature (sparse code)

Inactive dimension

Overlap — associative recall

Write-Ahead Log

Operations are logged in CRC-validated segments. Snapshot families plus uncovered WAL recover the store. Multiple agent sessions share one owning daemon; ordinary syncs are batched.

Cortical Posting Index

Each active feature maintains an inverted list of memories it belongs to. Recall intersects the k posting lists for the query's top-k features. Sub-millisecond, no HNSW⁴ graph traversal.

Organic Decay

Memories move through tiers based on access frequency and recency. Frequently accessed memories are promoted; inactive memories are demoted over time.

chitta-field on GitHub →

chitta-research — autonomous research

chitta-research is an autonomous research system built on chitta-field. Seven specialized agents coordinate to explore a research agenda, build a structured belief graph, and store durable findings across sessions.

Each research session accumulates into a belief graph: ResearchProgram → Question → Hypothesis → ExperimentPlan → Run → Observation → Claim → Method. Findings persist in chittad — the same daemon that powers chitta.

Brahman, the coordinating agent, enforces a research constitution: self-improvement depth cap, hard novelty stop, and a hypothesis backlog gate that prevents runaway recursion.

7 specialized agents

4 sources: arXiv, bioRxiv, Semantic Scholar, GitHub

8 belief graph node types

chittad persistent memory across sessions

Belief Graph

Research accumulates as a typed graph: Programs link to Questions, Questions to Hypotheses, Hypotheses to ExperimentPlans and Runs. Claims and Methods are first-class nodes. The graph is stored across sessions.

Brahman Constitution

The coordinating agent enforces hard limits: self-improvement depth cap prevents recursive self-modification spirals; novelty stop halts when marginal gain drops below threshold; hypothesis backlog gate prevents queue saturation.

Install & Run

make install drops cresearch into your PATH. Point it at an agenda YAML and it runs. Findings surface in chitta memory automatically — the same chitta recall that powers your daily sessions.

chitta-research on GitHub → Documentation →

Memory workflows

Indexing, stored observations, and recall supply context across sessions.

Indexing

Foundation

Basic recall and code indexing. chitta remembers what you tell it and indexes your codebase structure — symbols, call graphs, file relationships.

Observation

Adaptation

Preferences, corrections, conventions, and recurring errors are stored as memory records.

Prediction

Anticipation

Observed context/action pairs supply predictions; work-mode records distinguish flow, debugging, and blocked states.

Tracking

Goals and calibration

Goal records track progress. Curiosity records track unresolved questions, and calibration records track prediction outcomes.

Memory resonance — hover to activate

Memory node (size = confidence)

Semantic connection

Activated memory

Documentation

The MCP tool reference is generated from a live daemon. The architecture and philosophy pages describe the implementation and its 13 Sanskrit concepts.

System reference

Read the tool reference, recall pipeline, and evaluation results.

chitta — daemon, store, MCP server, and hooks.

Explore the system

References

Yu. A. Malkov and D. A. Yashunin. Efficient and robust approximate nearest neighbor search using Hierarchical Navigable Small World graphs. IEEE TPAMI 42(4), 824–836 (2020); arXiv:1603.09320 (2016). https://arxiv.org/abs/1603.09320 https://doi.org/10.1109/TPAMI.2018.2889473