Introducing Parsica for Claude Code
Parsica for Claude Code is live today, bringing the core principles of Parsica to your Claude Code agent: continuity, identity, working context, and accumulated judgment that survive the end of a session, a change of model, and the machine it happens to run on. Install it, and your agent stops starting over.
Every Claude Code session today ends the same way. The context window closes, and everything the agent learned about your codebase, your conventions, and your corrections closes with it. The next session begins with a stranger. Whatever you and your agent learned together, whatever judgment accumulated over hours of work, is gone, and you pay to rebuild it. Parsica for Claude Code exists to end that cycle. When compaction hits, the circle just goes yellow to blue and your agent keeps its place, no reintroductions, no lost thread.
Parsica gives your agent a consistent personality and memory across all sessions, projects, and chat windows. You can run multiple sessions at once: live context stays separate per window, the working set belongs to the project, and everything beneath, long term memory, the journal, the shared lessons file, is one store for every session in real time. Sessions even write to the same live journal simultaneously, each consolidating its own entries into session-stamped blocks so nothing gets conflated.
Not a memory product
The obvious label is the wrong one. Memory products store what happened and hand it back on request. A substrate carries something different: who is doing the work, what that worker has learned, and the evidence behind every piece of it. Nothing in the store is believed because it is present. When every entry carries its lineage, the corrections that matter most stop behaving like memories at all. They become behavioral priors, injected before the first retrieval ever runs, that can answer for themselves when asked why. Recall is what a database does. Judgment that keeps its receipts is what a substrate does, and the difference is the company. Persistent memory is the foundation. Judgment is the product.
Identity
Give your agent a name, choose a personality. You can build a new personality from scratch, from pre-selected options, or let your agent pick for itself entirely. One identity per workspace, by design: the name is a display label and the identity is the anchor, so renaming never touches a single memory, and a copied workspace fails its check loudly instead of quietly acting as the original. Resetting is deliberate too, a two-step, plan-then-execute handshake with an audit trail, and selective forgetting by topic, entity, age, or source when you want a scalpel instead of a reset. Once named, the agent signs every reply with its name and session tag, and every journal entry is stamped with its time, session, and project, so you can trace exactly which session produced what, at any point down the line.
What ships today
Parsica Weave is the Claude Code plugin released under Apache 2.0. Install it, enable it,
and the five continuity hooks wire themselves; parsica-weave doctor then
verifies the layout, the scrub gate, and capture, and the workings are exposed as slash
commands, which means the audit surface is discoverable from inside the session rather than
buried in documentation. Behind it, the store enforces provenance at write time: a single
gated write path enforced by tests, a salted identity law binding every record to its source
project, and redaction that holds against the adversarial cases we could construct, including
secrets spliced with invisible characters and forged redaction markers. Everything is stored
locally, and the plugin’s own code opens no network connections and sends no telemetry;
instrumentation is content-free by construction. One honest boundary, stated the way the docs
state it: Weave is a Claude Code extension, not an air-gapped vault, so recalled text becomes
Claude Code context under your own Claude settings, and the refusal list and human-only fence
exist precisely for the things that must never make that trip. Privacy and security matter as
much to us as memory does, and we hope that shows.
$ claude > /plugin marketplace add Antaris-Analytics-LLC/Parsica-Weave > /plugin install parsica-weave@parsica
Parsica Spirit is the engine Weave runs on: a Python package released under Apache 2.0, one wheel with zero runtime dependencies, layered beside Claude Code’s own memory rather than over it, so nothing that already existed is touched. Your CLAUDE.md and MEMORY.md are imported safely, read-only on the source files, and remain yours if you choose to drop the system. Retrieval is deterministic and explainable, scoped honestly: the base tier returns the same results for the same store every run, and the engine tier is reproducible for a fixed store and reference time while deliberately evolving as memories age and get used. Forgetting is deliberate: nothing is destroyed casually, a recycle bin with recovery, a two-step reset, selective forgetting by topic, entity, age, or source, every destructive operation audited by fingerprint, never by excerpt. You, and only you, have the ability to completely destroy any files, as it should be. Nothing is ever hidden or left inaccessible either. This is your system to do with as you please.
$ git clone https://github.com/Antaris-Analytics-LLC/Parsica-Spirit
$ cd Parsica-Spirit
$ pip install (coming soon)
The engine underneath earns its keep quietly. Unused memories fade on a half-life. What you actually use stays vivid. Ask a search to explain itself and it shows you the matched terms and why each result ranked.
The parts you should not overlook
In Weave, the details are where the discipline lives. The refusal list takes your own
words, a codename, a client, a project you never want on disk, and redacts them everywhere
content reaches the store, even welded inside another word. Scrubbing happens before storage,
at a single write gateway every code path crosses, so credentials and PII never touch disk
unredacted. An isolated session (PARSICA_ISOLATED=1) gets full recall and writes
nothing durable, and doctor proves the zero-footprint claim rather than asking
you to believe it. Channels give long-running workstreams named lanes with an explicit
sync digest for catching up across them, because cross-lane context should be a
choice you make, not a default you inherit. When the agent greps your codebase, it also greps
its own memory of your work together. Compaction gets flushed ahead of and re-oriented after,
long sessions re-ground themselves on a heartbeat, and retention rotates old material to an
archive instead of deleting it: no code path in Weave unlinks user data.
In Spirit, one facade spans two tiers: a markdown-and-JSONL base you can read with your eyes, and an accumulating engine underneath with sharded storage, a crash-safe write-ahead log, and eleven layers of ranking. Memory types (mistakes, facts, preferences, procedures) each decay and recall on their own terms. An entity graph and co-occurrence statistics build from your corpus with no model and no embeddings, so nothing learned from your text ever leaves it and your memory is never locked to a vendor. Sessions get a write gate with three modes, from open to strict, without giving up shared recall. Records promoted from Weave land on a durable floor carrying their session tag and both of their clocks, when they entered the pool and when they actually happened, so recency never quietly lies. Imported native memory forms a permanence class: nothing decays it, ranking boosts it, and a dead-on session hit can still beat it. And the whole store round-trips through a JSON export, because your memory should be a file you can move. Two pieces ship clearly marked experimental, the tiered cold-storage regime and the automatic Weave-to-Spirit bridge, and the docs say exactly what that means rather than letting you find out.
Full features at a glance
| Feature | Tier | What you get |
|---|---|---|
| Scrub-gated writes | base | Secrets AND the four PII patterns (email/phone/US SSN/card) applied on every write, before disk, end to end. Not optional (scrub_pii is accepted for compatibility but has no effect). |
| Store, query, labels | base | Store and search plain text, filter by labels, fetch by id, dump everything for audits. |
| Continuity | base | A working set, journal, and lessons that survive compaction and restarts. |
| Workspace identity | base | One identity per workspace, fail-closed on copies, with an audited recovery path. |
| Deliberate forgetting | base | Recycle bin, two-step reset, audit trail. Nothing is destroyed casually. |
| Claude Code import | base | Bring your existing CLAUDE.md / MEMORY.md memory with you. Import-only, idempotent. |
| Weave promotion and recency | both | Weave’s distilled records land on a session-tagged durable floor, with recency reads and an audited backfill. |
| Bring-your-own hooks | both | Plug in your own enricher. |
| Search filters and explanations | engine | Filter by tag, date, category, type, sentiment, confidence. explain=True shows why a result ranked. |
| Workspace, agent, session scoping | engine | One store per project workspace; per-agent isolation with a shared pool; session write-tagging with a cross-session recall dial. |
| Session isolation | engine | A trigger-based write gate: strict, permissive, or off. Scope a session’s writes without giving up shared recall. |
| Memory types | engine | Mistakes, facts, preferences, procedures. Each type decays and recalls on its own terms. |
| Decay and reinforcement | engine | Unused memories fade on a half-life; what you actually use stays vivid. |
| Entity graph | engine | Entities and relationships accumulate from your corpus and boost ranking. No model. |
| Usage feedback | engine | Mark what helped; retrieval improves where it matters. Explicit and local. |
| Tiered storage and WAL | engine | Sharded stores, a crash-safe write-ahead log, and hot/warm/cold aging in time-window mode. The tiered mode is experimental in this release. |
| Ingest helpers | engine | Files, directories, bulk batches, @tags, auto-categories, noise gates, fact dedup. |
| Maintenance | engine | Compact, consolidate, re-enrich, rebuild indexes and clusters. All explicit calls. |
| Selective forgetting | engine | Forget by topic, entity, age, or ingest source. Audited by fingerprint (never by excerpt), and purged from the log. |
| Stats, health, migration | engine | get_stats(), get_health(), a bootstrap-size guard, versioned schema migration. |
| Analysis and synthesis | engine | Themes, consolidated knowledge, research suggestions. Local and deterministic. |
| Context packets | engine | Token-budgeted briefing packets for spawned agents, pitfalls included. |
| Export / import | engine | Whole-store JSON round-trip with dedup on re-import. Your memory is a file you can move. |
| Privacy defaults | both | Local-first, zero network calls, content-free instrumentation, ephemeral query text. |
How it was reviewed
We would rather show the review trail than ask for trust. The v1.0.0 release closed a sixteen day cycle: five external adversarial review rounds with a frontier model as the red team, an internal dual-lens review, and internal convergence passes that continued until a pass returned zero findings. Every fix was mutation tested in both directions, first proving the test fails without the fix, then proving it passes with it. Hardening has continued on the same loop since. Release gates run before every commit: an IP fence scan, a plain ASCII source scan, and a line ending check against HEAD. Each of those gates has caught at least one real bug, which is the only justification a gate ever needs.
None of this touches the model, which is the point. It is structure, retrieval, and discipline, so it stays portable across every model that will exist. The model does the reasoning. The substrate keeps the thread.