Deterministic AST extraction, zero LLM
Client-side tree-sitter (~30 languages): 276 files → 2,143 nodes / 4,509 edges in ~14 s. No indexing cost, reproducible to the commit.
The command deck
The product as it actually runs, not a mockup.
Four real screens from the production cloud admin — dark-first, a living Cortex dome, full-screen explorers.
What Spongram does today
Every capability listed here is verifiable in the shipped codebase.
Personas
Personas that travel between Claude Desktop, Claude Code and Codex
An identity the agent adopts when you ask for it: role, voice (tone, register, language), intent, rules. One active per brain, never stacked, never implicit. It lives next to the brain, on your infrastructure, and follows you from one client to the next and from one machine to another.
Skills in the open Agent Skills standard
Each persona carries up to 8 skills in the SKILL.md format (agentskills.io): paste them, edit them, or import them from a raw URL. Progressive disclosure — the agent only sees the name and description, and loads the full body when the task calls for it.
A memory of its own for every persona
What the persona learns is tagged with its name and follows it everywhere it is active, whatever the project. The sorting happens server-side from the episodes' tags: its own memories come first, the noise from other projects is dropped, and the number dropped is handed back so a broader search can be offered.
Activation stays your move
You say "switch to my marketing specialist" and the agent adopts the role. The interface creates, edits and shows what is active — it never activates. Claude Code is never degraded: by default it inherits the tone and language only, preceded by the rule that project conventions win.
Foundations
On-prem self-host
docker-compose or Swarm + Portainer stack. Zero external cloud dependency.
Pluggable inference & hot-swap
Admin Settings page + 8-preset dropdown + Custom mode + 3-layer probe (chat / tool_calls / strict json_schema). Provider change takes effect on the next request, no container restart.
Claude Code and Codex plugins
Per-tenant .plugin bundle: marketplace, SKILL.md, SessionStart hook. Codex adapter with a connection assistant (instance URL + key in the keychain) and the same MCP tools.
Native Desktop edition (macOS)
Developer ID-signed Tauri app: frozen Python sidecar (PyInstaller), embedded FalkorDB, 100% offline. Memory, Code map, 3D Cortex, Wiki, Search, Pulse, Settings — no Docker, no external database. Windows and Linux in preparation.
Built-in Lemon Squeezy licensing (desktop)
In-app license activation, local validation, lifetime per-seat license.
Memory & multi-tenant
Strict multi-tenant
Server-injected group_id, anti-tampering rejection. One instance, N brains, zero cross-leakage.
Bi-temporal facts
valid_at / invalid_at inherited from Graphiti — automatic supersession on contradiction.
Proactive memory capture
Agents (Claude Code, Claude Desktop) call add_memory on their own whenever a fact, preference or decision is stated — no need to ask. Codex calls the same tools, on explicit request.
Cross-project, cross-client "global" memory
A fact tagged project=global (stated in any project, from Claude Desktop or Codex) is recalled across ALL your projects: one brain shared across every codebase and client. Project-specific facts stay scoped per project; search keeps the current project + global by default and drops other-project noise.
Authority validation at ingest (constitutional layer)
Optional provenance gate at the add_memory boundary: an episode must carry the expected tags (project=, and client= from a configured allow-list) before it enters the brain, otherwise it's rejected before even hitting the durable queue. Deterministic, dependency-free, flag-activated. Answers the classic critique « stores whatever it's given with no authority validation on ingested entities ».
Durable episode queue
Every add_memory is persisted to Postgres before reaching Graphiti. Zero loss on container restart, automatic retry on transient error (writes via the queue, reads via bounded retry/backoff on the Graphiti path). Oversized episodes (>32k tokens) are auto-chunked before extraction so they're never rejected by the LLM.
Confidence scoring on facts
Every relationship carries a confidence score that climbs on multi-source corroboration. Threshold-based filtering exposed via /v1/graph/data.
Granular forgetting (3 levels)
Entity (one-click in the 3D Cortex), specific fact (DELETE /forget/fact/{uuid}, GDPR-grade with audit log), whole instance (DELETE that automatically purges Neo4j and Postgres).
Code map
Code map (structural code graph)
Client-side AST extraction via tree-sitter (~30 languages): files, classes, functions, imports, calls — including AST-inferred qualified module.attr() calls. 276 files → 2,143 nodes / 4,509 edges in ~14 s on the Spongram repo itself. Portable graph on Neo4j (cloud) and FalkorDB (desktop), tenant-isolated, kept fresh by a git post-commit hook.
5 code_map_* MCP tools + dedicated 3D tab
code_map_query / neighbors / god_nodes / shortest_path / stats. Memories that mention a file or symbol automatically surface their linked code nodes in search_nodes. A mini-map (~110 tokens) is injected at SessionStart: repo size, directories, central files — the agent is oriented before its first tool call.
Background science
Sleep-time compute (Sleeper)
Background worker that synthesises Summary nodes and Wiki pages, with bounded concurrency (several entities in parallel, cap via SPONGRAM_SLEEPER_CONCURRENCY). Idempotent: only re-runs entities whose episode set actually changed (sha256 hash). Enabled via feature flag (off by default).
Dream cycle (periodic consolidation)
Duplicate-candidate detection via cosine similarity, time decay on edges (Ebbinghaus curve exp(-Δt/τ)), community propagation (LPA), boost on multi-source corroboration. Enabled via feature flag (off by default).
Non-destructive de-duplication + co-evolution (A-MEM)
The Dream links same-normalised-name entities via a :SAME_AS edge — no merge, zero data loss: recall and UI treat them as one. Aliases co-evolve (A-MEM pattern, NeurIPS 2025): when one carries a fresher summary, the other is re-synthesised on the next tick instead of drifting apart.
Importance score at ingest
Every entity gets a 1-10 score derived from source count and connection density (log-based formula). Acts as a 3rd retrieval axis (cosine + recency + importance) via reciprocal rank fusion.
Multi-hop search with Personalized PageRank
HippoRAG-style Personalized PageRank over the 2-hop subgraph of top-K cosine seeds, reciprocal-rank fused. Observable (Prometheus rerank / fallback-by-reason / latency metrics), subgraph timeout widened so the rerank actually runs instead of silently falling back. Flag-activated, ready for measured A/B.
Hot cache on the search path
LRU + TTL on top of search_nodes / search_memory_facts, scoped per tenant. Repeated recall served in a few milliseconds (measured locally), immediate write-invalidation (including via the ingestion queue), hit-rate exposed in Prometheus. Flag-activated (Memory³ pattern).
Procedural memory (skills)
Separate :Skill namespace, isolated from facts. MCP tools record_skill / recall_skill — recall scored name > intent > body, strict multi-tenant isolation.
Failure reflection
reflect_on_failure MCP tool: verbal capture of a failure (intent + lesson) transcoded into a failure_pattern-tagged episode with boosted importance. Reflexion pattern (Shinn et al. 2023), no weight updates.
Wiki & 3D Cortex
Karpathy-style block-by-block Wiki
Deterministic Markdown page per entity: header, Sleeper summary, sources, [[wiki]] links. Only the summary comes from the LLM, the rest is rendered by pure Python — versioned, exportable as Obsidian ZIP.
Communities and themes
Label Propagation Algorithm in pure Cypher on the Neo4j graph (no GDS plugin), /v1/wiki/themes.json endpoint. Each community gets a deterministic label (key members by importance, no LLM so no hallucination), generated by the Dream pass after detection, then rolled up into a tenant-level digest (a hierarchical abstraction above communities). The Wiki and admin render a named per-tenant « Themes » section.
Bundled 3D Cortex UI
Graph explorer rendered with 3d-force-graph (no bundler pipeline). SSE live updates, per-project filters, point-and-click entity deletion, server-side pagination to explore large graphs in windows.
Production hardening
Full admin web
Inference settings, instances, per-tenant activity, 90-day usage ledger, bundle downloads, token and marketplace management. SPONGRAM_ADMIN_TOKEN-gated.
Production hardening
Multi-component /healthz (Postgres, Neo4j, Graphiti, 3 workers), /metrics Prometheus, circuit breakers on LLM and embedder, Postgres ↔ Neo4j audit, idempotency-checked migrations, /orphans/{gid}/purge recovery endpoint.
Per-instance rate limiting
100 requests/minute per tenant, 429 beyond that (spec §8.4). Protects shared inference: one noisy tenant can't starve the others.
Reproducible recall-quality bench
pytest tests/bench/ suite that replays a LongMemEval subset (knowledge_update) with LLM-as-judge. The bench waits for the real queue drain AND the extraction plateau before measuring (no more truncated baseline). Reports accuracy / latency p50-p95 / tokens, JSON-frozen baseline, ON / OFF comparison of retrieval features.
Full i18n
Fully bilingual product
Admin (300+ keys), desktop (140+ keys), landing and server surfaces (/v1/graph, /v1/wiki, /v1/codemap via ?lang=) — FR/EN end to end, parity verified key by key every release.
Personas: one identity, its skills, its memory
Claude.ai Styles, Claude Code output styles and Roo Code modes all exist — none of them travels between clients, and none is wired to a memory. A Spongram persona is both.
One active per brain
Enforced by a partial unique index in the database, not by convention: two active personas are impossible. With no persona active, nothing is injected — the path is byte-identical to what it was before. No implicit default persona.
Activation through the agent only
The activate_persona MCP tool is the only path. There is deliberately no HTTP activation route: the interface creates and edits, the agent adopts. An activation returns the full block to adopt, and replaces the previous persona in one transaction.
Skills in the Agent Skills standard
The full SKILL.md is stored as-is, frontmatter included; name and description are validated on the way in. Import from https URLs only, https→https redirects bounded, body capped at 32 KB, never executed. 50 skills per brain, 8 per persona.
Per-persona memory as a lens
One graph, no sub-graph: the persona's episodes carry its tag, set and validated server-side. A tag that does not match the active persona is stripped, exactly like the group_id — the same anti-tampering stance. No existing episode is re-tagged or moved.
Read filtering with no silent loss
Search results are sorted from their source episodes' tags, in one indexed query. The active persona's memories come first, other projects are dropped — and the number dropped is returned in the response, so the agent can offer to widen the search.
Claude Code is never degraded
No output style, ever; no change to the system prompt, to CLAUDE.md, to permissions or to the tool list. The injection is additive and replayed after compaction. By default Claude Code inherits the voice only, preceded by the reminder that engineering instructions win.
Personas you can export as cards
Export and import in the open Character Card V2 format (chara_card_v2), JSON body only: no image, no URL fetched by the server. An imported persona always arrives inactive — activation stays your move.
A "what I already know" summary
The background worker compiles, for each persona, a summary of its own episodes, capped at 120 words, and attaches it to the block on activation. Idempotent: it is only recomputed when the set of episodes actually changed.
The code map: fewer tokens, better answers
Spongram maps your repos via AST (tree-sitter) and exposes the graph to Claude Code through 5 MCP tools. Everything below is measured in real claude -p sessions, on the Spongram repo itself — protocol and runner ship with the product (docs/BENCH_CODEMAP_2026-06-10.md).
| Code-navigation question | Without Spongram (grep/read) | With Spongram (code map) | Δ cost |
|---|---|---|---|
| Most central files / symbols | $0.329 — subagent + 29 greps, estimated ranking | $0.105 — 1 god_nodes call, exact graph degree | −68% |
| Package overview | $0.291 | $0.178 | −39% |
| Who calls this function? | $0.086 | $0.106 — prod + test callers in 1 call | +23%* |
| Module contents (classes, methods) | $0.128 | $0.181 | +41%* |
| Dependency path A → B | $0.107 | $0.129 | +20%* |
| Total (6 questions) | $1.05 | $0.83 | −21% |
| Cumulative response time | 293 s | 151 s | −48% |
* For point lookups grep stays cheaper — and that is exactly what the shipped SKILL tells the agent: every tool where it belongs. A/B bench in real claude -p sessions (Sonnet), 1 question per session, read-only tools, 276-file repo; total between −12% and −21% across runs.
5 dedicated MCP tools
code_map_query, neighbors, god_nodes, shortest_path, stats — including AST-inferred qualified module.attr() calls that grep often misses.
Mini-map at SessionStart
~110 tokens injected at session open: repo size, directories, central files. The agent is oriented before its first tool call.
Memory and code linked
A memory that mentions a file or symbol automatically surfaces its code nodes in search_nodes. The map stays fresh via the git post-commit hook.
In both editions
3D “Code map” tab; portable graph on Neo4j (cloud) / embedded FalkorDB (desktop), tenant-isolated.
Choose your inference
Spongram speaks OpenAI-compat. Eight presets plus a Custom mode for any endpoint. Hot-swap from the admin, 3-layer validation built in.
hosted
SPT Models
Sponge Theory hosted stack (default)
local
Ollama
Local workstation, port 11434
local
LM Studio
Desktop Mac/Win, port 1234
local
vLLM
Local NVIDIA GPU server, port 8000
cloud
OpenAI
Cloud, gpt-4.1 family
cloud
Anthropic Claude
Cloud via LiteLLM adapter
cloud
Mistral
Cloud, mistral-large
cloud
Groq
Cloud, llama-3.3 sub-second
All driven by the same admin Settings page. “Test connection” button → 3-layer probe (chat / tool_calls / strict json_schema) → you know in 3 seconds whether your provider is Graphiti-compatible.
Architecture in one slide
A single FastAPI instance serves the MCP, the admin SPA, the 3D Cortex explorer and this landing. Everything else is Postgres + Neo4j, side by side.
- Client (Claude Code, Claude Desktop, Codex) → MCP HTTP → Spongram (Bearer spt_brain_* auth)
- Spongram injects `group_id`, routes to Graphiti, rejects any tampering attempt
- Graphiti writes to Neo4j (graph) and Postgres (episodes/instances), calls SPT Models for LLM + embeddings
- Sleeper (enabled via feature flag) runs a background loop that generates Summary nodes and deterministic Wiki pages
Install, short version
On purchase you receive the Docker images and the env template. Three steps, 10 minutes on any box with Docker.
- 01
Configure the environment
cp .env.example .env # set SPONGRAM_ADMIN_TOKEN + SPONGRAM_INFERENCE_API_KEY # point SPONGRAM_INFERENCE_BASE_URL to your OpenAI-compat endpoint - 02
Boot the stack
docker compose up -d # Postgres + Neo4j + Spongram come up; # SQL migrations applied automatically - 03
Create a brain, then wire up your client
# Admin console: http://localhost:8091/admin/ # create an instance, copy the spt_brain_ key (shown once) claude plugin marketplace add ezeeFlop/claude-plugins claude plugin install spongram@sponge-theory # on enable: instance URL + spt_brain_ key (stored in your keychain) # Codex: install the spongram-codex plugin from the same repo, then run spongram-setup
For prod: Docker Swarm behind Traefik, deploy via Portainer. Full documentation shipped with purchase.