Sulcus Memory Skill

Sulcus is a cognitive memory system for AI agents — not a simple key-value store. Every memory is automatically scored, classified, graph-linked, and subject to thermodynamic decay. The system learns what matters and keeps it accessible.

What Sulcus Is

• - Thermodynamic memory — memories have heat that decays over time and interaction patterns. High-utility memories stay hot; irrelevant ones cool and disappear.
• Apache AGE knowledge graph — temporal graph over all stored memories. Entities and relationships are extracted automatically. Graph queries reveal connections across time.
• SIU v2 pipeline — every memory_store fires: SIVU (utility scoring) → SICU (type classification) → SILU (entity extraction) → AGE graph update → trigger evaluation.
• Curator (sleep cycle) — background process that reclassifies, consolidates, summarizes, and re-vectorizes memories. No manual cleanup needed.
• Reactive triggers — rules that fire automatically on memory events. Useful for auto-pinning important facts, notifying on key recalls, or chaining memory actions.

Memory Lifecycle

Storing

CODEBLOCK0

Recalling

CODEBLOCK1

Memory Types — Choose Carefully

Decay rates differ significantly. Wrong type = memory disappears too fast or lingers too long.

Type	Decay	Use For
INLINECODE1	Fast	Events, sessions, one-off observations
INLINECODE2

Slow | Concepts, relationships, domain knowledge |
| preference | Slower | User preferences, opinions, style choices |
| fact | Slow | Stable factual knowledge, ground truth |
| procedural | Slowest | How-tos, processes, workflows, playbooks |

Best practices:

• - Store user preferences as preference — they survive long and surface reliably
• Store how-tos and processes as procedural — these should never decay quickly
• Store facts as fact — stable, slow decay, always available
• Use episodic for events and session context — fast decay is correct here
• Use semantic for domain concepts and relationships

Interaction-Based Decay

Sulcus supports 3 decay modes (configured server-side):

• - Time-only — classic: memory cools based on wall-clock time since last access
• Interaction-only — memories decay per agent interaction, not time; great for high-frequency agents
• Hybrid (default) — combination of both; high-utility memories (high SIVU score) resist decay

The Hybrid mode is the right default. High-utility memories (procedural, fact, high-SIVU) decay slowly. Low-utility noise (episodic, low-SIVU) cools quickly and gets consolidated.

Trigger System

Triggers fire automatically on server-side memory events. You can evaluate them explicitly with evaluate_triggers.

Events:

• - on_store — fires when a memory is stored
• INLINECODE16 — fires when a memory is recalled
• INLINECODE17 — fires when a memory's heat is boosted
• INLINECODE18 — fires when a memory cools below a threshold

Actions:

• - notify — emit a notification event to the agent
• INLINECODE20 — raise heat on matching memories
• INLINECODE21 — prevent a memory from decaying
• INLINECODE22 — add a tag to a memory
• INLINECODE23 — mark a memory as superseded
• INLINECODE24 — call an external URL with memory context
• INLINECODE25 — trigger another trigger

Curator (Sleep Cycle)

The curator is a background process that runs independently of agent activity:

• - Reclassifies memories where SICU confidence is low
• Consolidates near-duplicate memories (merges or deprecates)
• Summarizes clusters of episodic memories into semantic nodes
• Re-vectorizes memories whose embeddings are stale
• Resolves conflicts detected by the conflict detection system (v2.3.0+)

You don't need to trigger the curator — it runs on a schedule. Use consolidate to manually initiate a consolidation pass when needed.

Confidence Levels (v2.3.0+)

Every memory carries a confidence level:

• - observed (default) — directly observed fact or event
• INLINECODE28 — derived from other memories or reasoning
• INLINECODE29 — explicitly stated by user or system

The conflict detection system flags memory pairs with high similarity but contradictory content. Use memory_status to inspect open conflicts.

Tool Reference

Tool	What It Does
INLINECODE31	Store a memory. SIU pipeline fires automatically.
INLINECODE32

Semantic search with relevance weighting. | | memory_status | Backend status, hot nodes, decay mode, curator state, open conflicts. | | memory_delete | Delete by ID. Optional SIVU training to reject similar content. | | consolidate | Merge and prune cold memories below a heat threshold. | | export_markdown | Export all namespace memories as Markdown. | | import_markdown | Import memories from a Markdown document. | | evaluate_triggers | Evaluate reactive triggers against an event + context. | | trigger_feedback | Submit feedback to improve trigger accuracy (SITU scoring). |

Usage Patterns

Start of session

memory_recall(query="[current task or project]", limit=5)

Surface relevant context before starting work.

Capturing preferences

CODEBLOCK3

Capturing a process

CODEBLOCK4

After compaction/reset

The plugin auto-captures a session summary on compaction (captureOnCompaction=true) and reset (captureOnReset=true). These fire automatically — no manual action needed.

Periodic cleanup

consolidate(min_heat=0.1)

Run occasionally to merge near-duplicates and prune cold noise.

Troubleshooting

• - Plugin not responding — ensure openclaw-sulcus is installed and enabled in ~/.openclaw/openclaw.json. Run openclaw gateway restart after config changes.
• No cloud sync — serverUrl and apiKey required. Get a key at sulcus.ca. Without them, plugin runs local-only.
• Local mode — sulcus-local binary manages embedded PostgreSQL. Check memory_status to confirm backend mode.
• Memories not persisting — verify namespace matches across sessions (agentId / namespace in config).
• Memories decaying too fast — check decay mode via memory_status. Switch to Hybrid mode server-side, or use procedural/fact types for long-lived knowledge.
• Conflicts detected — use memory_status to inspect. The curator will attempt auto-resolution; use memory_delete + memory_store to manually resolve.