penfieldPersistent memory for OpenClaw agents. Store decisions, preferences, and context that survive across sessions. Build knowledge graphs that compound over time. Hybrid search (BM25 + vector + graph) recalls what matters when you need it.
Install via ClawdBot CLI:
clawdbot install dial481/penfieldPersistent memory that compounds. Your agent remembers conversations, learns preferences, connects ideas, and picks up exactly where it left off—across sessions, days, and channels.
| Tool | Purpose | When to use |
|------|---------|-------------|
| penfield_store | Save a memory | User shares preferences, you make a discovery, a decision is made, you learn something worth keeping |
| penfield_recall | Hybrid search (BM25 + vector + graph) | Need context before responding, resuming a topic, looking up prior decisions |
| penfield_search | Semantic search (higher vector weight) | Fuzzy concept search when you don't have exact terms |
| penfield_fetch | Get memory by ID | Following up on a specific memory from recall results |
| penfield_update_memory | Edit existing memory | Correcting, adding detail, changing importance or tags |
| Tool | Purpose | When to use |
|------|---------|-------------|
| penfield_connect | Link two memories | New info relates to existing knowledge, building understanding over time |
| penfield_explore | Traverse graph from a memory | Understanding how ideas connect, finding related context |
| Tool | Purpose | When to use |
|------|---------|-------------|
| penfield_save_context | Checkpoint a session | Ending substantive work, preparing for handoff to another agent |
| penfield_restore_context | Resume from checkpoint | Picking up where you or another agent left off |
| penfield_list_contexts | List saved checkpoints | Finding previous sessions to resume |
| penfield_reflect | Analyze memory patterns | Session start orientation, finding themes, spotting gaps |
| Tool | Purpose | When to use |
|------|---------|-------------|
| penfield_save_artifact | Store a file | Saving diagrams, notes, code, reference docs |
| penfield_retrieve_artifact | Get a file | Loading previously saved work |
| penfield_list_artifacts | List stored files | Browsing saved artifacts |
| penfield_delete_artifact | Remove a file | Cleaning up outdated artifacts |
Memory content quality determines whether Penfield is useful or useless. The difference is specificity and context.
Bad — vague, no context, unfindable later:
"User likes Python"Good — specific, contextual, findable:
"[Preferences] User prefers Python over JavaScript for backend work.
Reason: frustrated by JS callback patterns and lack of type safety.
Values type hints and explicit error handling. Uses FastAPI for APIs."What makes a memory findable:
[Preferences], [Project: API Redesign], [Investigation: Payment Bug], [Decision]Use the correct type. The system uses these for filtering and analysis.
| Type | Use for | Example |
|------|---------|---------|
| fact | Verified, durable information | "User's company runs Kubernetes on AWS EKS" |
| insight | Patterns or realizations | "Deployment failures correlate with Friday releases" |
| correction | Fixing prior understanding | "CORRECTION: The timeout isn't Redis — it's a hardcoded batch limit" |
| conversation | Session summaries, notable exchanges | "Discussed migration strategy. User leaning toward incremental approach" |
| reference | Source material, citations | "RFC 8628 defines Device Code Flow for OAuth on input-constrained devices" |
| task | Work items, action items | "TODO: Benchmark recall latency after index rebuild" |
| strategy | Approaches, methods, plans | "For user's codebase: always check types.ts first, it's the source of truth" |
| checkpoint | Milestone states | "Project at 80% — auth complete, UI remaining" |
| identity_core | Immutable identity facts | Set via personality config, rarely stored manually |
| personality_trait | Behavioral patterns | Set via personality config, rarely stored manually |
| relationship | Entity connections | "User works with Chad Schultz on cybersecurity content" |
Use the full range. Not everything is 0.5.
| Score | Meaning | Example |
|-------|---------|---------|
| 0.9–1.0 | Critical — never forget | Architecture decisions, hard-won corrections, core preferences |
| 0.7–0.8 | Important — reference often | Project context, key facts about user's work |
| 0.5–0.6 | Normal — useful context | General preferences, session summaries |
| 0.3–0.4 | Minor — background detail | Tangential facts, low-stakes observations |
| 0.1–0.2 | Trivial — probably don't store | If you're questioning whether to store it, don't |
Connections are what make Penfield powerful. An isolated memory is just a note. A connected memory is understanding.
After storing a memory, always ask: What does this relate to? Then connect it.
Knowledge Evolution: supersedes · updates · evolution_of
Use when understanding changes. "We thought X, now we know Y."
Evidence: supports · contradicts · disputes
Use when new information validates or challenges existing beliefs.
Hierarchy: parent_of · child_of · sibling_of · composed_of · part_of
Use for structural relationships. Topics containing subtopics, systems containing components.
Causation: causes · influenced_by · prerequisite_for
Use for cause-and-effect chains and dependencies.
Implementation: implements · documents · tests · example_of
Use when something demonstrates, describes, or validates something else.
Conversation: responds_to · references · inspired_by
Use for attribution and dialogue threads.
Sequence: follows · precedes
Use for ordered steps in a process or timeline.
Dependencies: depends_on
Use when one thing requires another.
Good queries find things. Bad queries return noise.
Tune search weights for your query type:
| Query type | bm25_weight | vector_weight | graph_weight |
|-----------|-------------|---------------|--------------|
| Exact term lookup ("Twilio auth token") | 0.6 | 0.3 | 0.1 |
| Concept search ("how we handle errors") | 0.2 | 0.6 | 0.2 |
| Connected knowledge ("everything about payments") | 0.2 | 0.3 | 0.5 |
| Default (balanced) | 0.4 | 0.4 | 0.2 |
Filter aggressively:
memory_types: ["correction", "insight"] to find discoveries and correctionsimportance_threshold: 0.7 to skip noiseenable_graph_expansion: true to follow connections (default, usually leave on)penfield_store({
content: "[Preferences] User wants responses under 3 paragraphs unless complexity demands more. Dislikes bullet points in casual conversation.",
memory_type: "fact",
importance: 0.8,
tags: ["preferences", "communication"]
})// Start
penfield_store({
content: "[Investigation: Deployment Failures] Reports of 500 errors after every Friday deploy. Checking release pipeline, config drift, and traffic patterns.",
memory_type: "task",
importance: 0.7,
tags: ["investigation", "deployment"]
})
// Discovery — connect to the investigation
discovery = penfield_store({
content: "[Investigation: Deployment Failures] INSIGHT: Friday deploys coincide with weekly batch job at 17:00 UTC. Both compete for DB connection pool. Not a deploy issue — it's resource contention.",
memory_type: "insight",
importance: 0.9,
tags: ["investigation", "deployment", "root-cause"]
})
penfield_connect({
from_memory_id: discovery.id,
to_memory_id: initial_report.id,
relationship_type: "responds_to"
})
// Correction — supersede wrong assumption
correction = penfield_store({
content: "[Investigation: Deployment Failures] CORRECTION: Not a CI/CD problem. Friday batch job + deploy = connection pool exhaustion. Fix: stagger batch job to 03:00 UTC.",
memory_type: "correction",
importance: 0.9,
tags: ["investigation", "deployment", "correction"]
})
penfield_connect({
from_memory_id: correction.id,
to_memory_id: initial_report.id,
relationship_type: "supersedes"
})penfield_save_context({
name: "deployment-investigation-2026-02",
description: "Investigated deployment timeout issues. memory_id: " + discovery.id,
memory_ids: [discovery.id, correction.id, initial_report.id]
})Next session or different agent:
penfield_restore_context({
name: "deployment-investigation-2026-02"
})Keep them short, consistent, lowercase. 2–5 per memory.
Good: preferences, architecture, investigation, correction, project-name
Bad: 2026-02-02, important-memory-about-deployment, UserPreferencesForCommunicationStyle
The native OpenClaw plugin is the fastest path, but Penfield works with any AI tool anywhere:
Claude Connectors
Name: Penfield
Remote MCP server URL: https://mcp.penfield.appClaude Code
Claude mcp add --transport http --scope user penfield https://mcp.penfield.appMCP Server — for Gemini CLI, Cursor, Windsurf, Intent, Perplexity Desktop or any MCP-compatible tool:
{
"mcpServers": {
"penfield": {
"command": "npx",
"args": [
"mcp-remote@latest",
"https://mcp.penfield.app/"
]
}
}
}API — direct HTTP access at api.penfield.app for custom integrations.
Same memory, same knowledge graph, same account. The plugin is 4-5x faster (no MCP proxy layer), but everything stays in sync regardless of how you connect.
Generated Mar 1, 2026
A support agent uses Penfield to remember customer preferences, past issues, and solutions across multiple support sessions. When a customer returns with a related problem, the agent can quickly recall their technical environment, previous resolutions, and personal preferences to provide personalized, efficient support without asking repetitive questions.
A research assistant employs Penfield to store findings, connect related studies, and track hypotheses over long-term projects. The hybrid search helps retrieve specific data points from vast literature, while graph connections reveal patterns between different research threads, accelerating discovery and ensuring continuity despite team changes.
A financial advisor uses Penfield to record client investment preferences, risk tolerance discussions, and past financial decisions. The persistent memory allows the advisor to resume conversations seamlessly after breaks, reference previous strategies accurately, and build a knowledge graph of client goals that compounds over years of relationship management.
A team lead utilizes Penfield to store architectural decisions, codebase insights, and project checkpoints. When onboarding new developers or resuming work after interruptions, the lead can restore context quickly, share learned patterns through connected memories, and maintain consistency in technical approaches across the development lifecycle.
A legal professional uses Penfield to track case details, client communications, and legal precedents across multiple cases. The tool helps connect related evidence, store reference materials as artifacts, and ensure that critical decisions and corrections are preserved and easily retrievable during lengthy legal proceedings.
Offer Penfield as a cloud-hosted service with tiered subscription plans based on storage capacity, number of memories, and advanced features like graph analytics. Revenue comes from monthly or annual fees, with enterprise tiers offering custom integrations and dedicated support for large organizations.
Sell perpetual licenses or annual enterprise agreements to large corporations, government agencies, or research institutions. This model includes on-premise deployment options, custom training, and premium support services, generating high-value contracts tailored to organizational needs and security requirements.
Provide a free version with basic memory storage and search capabilities to attract individual users and small teams. Monetize through premium upgrades offering advanced tools like graph exploration, artifact storage, and API access, converting free users as their needs grow and they require more sophisticated features.
💬 Integration Tip
Start by integrating Penfield's core memory tools (store and recall) into existing workflows, then gradually add graph connections and artifacts as users become comfortable with persistent context management.
Captures learnings, errors, and corrections to enable continuous improvement. Use when: (1) A command or operation fails unexpectedly, (2) User corrects Clau...
Helps users discover and install agent skills when they ask questions like "how do I do X", "find a skill for X", "is there a skill that can...", or express interest in extending capabilities. This skill should be used when the user is looking for functionality that might exist as an installable skill.
Search and analyze your own session logs (older/parent conversations) using jq.
Typed knowledge graph for structured agent memory and composable skills. Use when creating/querying entities (Person, Project, Task, Event, Document), linking related objects, enforcing constraints, planning multi-step actions as graph transformations, or when skills need to share state. Trigger on "remember", "what do I know about", "link X to Y", "show dependencies", entity CRUD, or cross-skill data access.
Ultimate AI agent memory system for Cursor, Claude, ChatGPT & Copilot. WAL protocol + vector search + git-notes + cloud backup. Never lose context again. Vibe-coding ready.
Headless browser automation CLI optimized for AI agents with accessibility tree snapshots and ref-based element selection