Building a Personal CRM Agent: Remembering People and Relationships with MemoClaw

You meet someone at a conference. Three months later, they email you. Your agent has no idea who they are. The conversation from three months ago? Gone. Compacted. Lost in a MEMORY.md file that’s 400 lines long and eating your context window.

This is the personal CRM problem. You need your agent to remember people — not just facts, but who said what, how they’re connected, and what matters to them.

In this tutorial, we’ll build a personal CRM system using MemoClaw’s namespaces, tags, memory types, and relations. No external CRM software. No database setup. Just your OpenClaw agent and a few CLI commands.

The Architecture

Here’s the plan:

  • One namespace per person — crm/alice-chen, crm/bob-smith
  • Tags for categorization — colleague, client, friend, met-at-ethdenver
  • Memory types for structure — observation for facts about them, preference for their likes/dislikes, decision for agreements you’ve made
  • Relations to connect people — Alice introduced you to Bob → link their memories
  • Ingest for conversations — After meetings/calls, dump the conversation and let MemoClaw extract the facts

Step 1: Set Up Your CRM Namespace Convention

The key decision is namespace structure. MemoClaw namespaces are flat strings, so we use a convention:

crm/firstname-lastname

This keeps all CRM memories isolated from your other agent memories (which might live in default, project-x, etc.).

# Store a person's basic info
memoclaw store "Alice Chen - ML engineer at Anthropic, met at ETHDenver 2026" \
  --namespace crm/alice-chen \
  --importance 0.9 \
  --type observation \
  --tags contact-info,colleague,ethdenver \
  --pinned

The --pinned flag marks this as a core memory. It’ll always be included when you recall from this namespace, regardless of relevance scoring.

Step 2: Store First Impressions

Right after meeting someone, capture the initial context. This is the stuff you’ll forget in a week:

# Alice's details
memoclaw store "Alice is working on agent memory systems at Anthropic" \
  --namespace crm/alice-chen \
  --importance 0.8 \
  --type project \
  --tags work,ai-agents

memoclaw store "Alice prefers async communication over meetings" \
  --namespace crm/alice-chen \
  --importance 0.7 \
  --type preference \
  --tags communication

memoclaw store "Alice mentioned she is looking for beta testers for her memory framework" \
  --namespace crm/alice-chen \
  --importance 0.6 \
  --type observation \
  --tags opportunity

Or, if you had a longer conversation and don’t want to pick out individual facts:

memoclaw ingest \
  --messages '[
    {"role": "user", "content": "Just met Alice Chen at ETHDenver. She works at Anthropic on agent memory. Really sharp, interested in our x402 approach. Prefers Slack over email. She mentioned needing beta testers for a new memory framework she is building."},
    {"role": "assistant", "content": "Got it. I will remember Alice Chen from Anthropic, met at ETHDenver."}
  ]' \
  --namespace crm/alice-chen \
  --auto-relate

Ingest pulls out the facts automatically: where she works, what she’s building, communication preference, the beta tester opportunity. All tagged and scored.

Step 3: Recall Before Meetings

The real payoff comes before your next interaction. You’re about to hop on a call with Alice — what does your agent know?

memoclaw recall "Alice Chen context" --namespace crm/alice-chen --limit 10

Or use the context endpoint to get a pre-formatted block for your agent’s prompt:

curl -X POST https://api.memoclaw.com/v1/context \
  -H "Content-Type: application/json" \
  -H "x-wallet-auth: $(memoclaw auth-header)" \
  -d '{
    "query": "upcoming meeting with Alice Chen",
    "namespace": "crm/alice-chen",
    "max_memories": 10,
    "max_tokens": 1000,
    "format": "structured",
    "include_metadata": true
  }'

Response:

<user_context>
<memory type="observation" importance="0.9" pinned="true" tags="contact-info, colleague, ethdenver">Alice Chen - ML engineer at Anthropic, met at ETHDenver 2026</memory>
<memory type="project" importance="0.8" tags="work, ai-agents">Alice is working on agent memory systems at Anthropic</memory>
<memory type="preference" importance="0.7" tags="communication">Alice prefers async communication over meetings</memory>
<memory type="observation" importance="0.6" tags="opportunity">Alice mentioned she is looking for beta testers for her memory framework</memory>
</user_context>

Your agent now has full context. No scrolling through old chat logs. No “remind me, who is Alice again?”

Step 4: Post-Meeting Ingest

After the call, ingest the conversation:

memoclaw ingest \
  --messages '[
    {"role": "user", "content": "Call with Alice went great. She shared early access to her framework — it is called MemoryWeave. We agreed to test it and give feedback by end of March. She also mentioned her colleague Bob Martinez is working on something similar at OpenAI."},
    {"role": "assistant", "content": "Noted. MemoryWeave beta access, feedback deadline end of March. And Bob Martinez at OpenAI is in the same space."}
  ]' \
  --namespace crm/alice-chen \
  --auto-relate

New facts get stored: MemoryWeave framework, the feedback deadline, and the Bob Martinez connection.

Step 5: Connect People with Relations

Alice mentioned Bob. Let’s create a CRM entry for Bob and link them:

# Create Bob's namespace
memoclaw store "Bob Martinez - works at OpenAI, connected through Alice Chen" \
  --namespace crm/bob-martinez \
  --importance 0.8 \
  --type observation \
  --tags contact-info,colleague,openai \
  --pinned

Now link the relevant memories. First, find the memory IDs:

# Find Alice's mention of Bob
memoclaw search "Bob Martinez" --namespace crm/alice-chen --json
# Returns memory ID: a1b2c3d4-...

# Find Bob's core memory
memoclaw list --namespace crm/bob-martinez --json
# Returns memory ID: e5f6g7h8-...

Create the relation:

memoclaw relate a1b2c3d4-... e5f6g7h8-... --type related_to

Now when you recall context about Bob, you can traverse the relation to find Alice’s mention. And vice versa.

Step 6: Tag Taxonomy for People

A consistent tag system makes your CRM actually searchable. Here’s a starting taxonomy:

Relationship type:

  • colleague, client, friend, acquaintance, vendor

How you met:

  • met-at-ethdenver, met-at-devcon, intro-from-alice, twitter-dm

Topics:

  • ai-agents, web3, devtools, infrastructure

Status:

  • active, follow-up-needed, dormant

Action items:

  • opportunity, deadline, waiting-on-them, waiting-on-me

Use these consistently across all CRM namespaces:

# Find everyone you met at ETHDenver
memoclaw search "ETHDenver" --tags met-at-ethdenver

# Find all pending follow-ups
memoclaw search "follow up" --tags follow-up-needed

Step 7: Automate with OpenClaw Hooks

For hands-free operation, set up the MemoClaw hooks. When your agent chats about someone, the session-end hook automatically ingests the conversation:

openclaw hooks install memoclaw-hooks
openclaw hooks enable memoclaw
export MEMOCLAW_PRIVATE_KEY=0xYourKey
openclaw gateway restart

But since hooks ingest into the default namespace, you’ll want your agent to explicitly store CRM-relevant facts into the right person namespace during conversation:

# Your agent can do this mid-conversation
memoclaw store "Alice confirmed MemoryWeave launch date is April 15" \
  --namespace crm/alice-chen \
  --importance 0.8 \
  --type decision \
  --tags deadline

Step 8: Weekly CRM Review

Set up a cron job to surface stale contacts — people you haven’t interacted with recently:

# Check for stale CRM memories (contacts going cold)
memoclaw suggested --category stale --limit 10

The suggested endpoint surfaces memories that haven’t been accessed recently. If Alice’s memories are going stale, it’s a signal to reach out.

You can also export your CRM data:

# Export all CRM memories
memoclaw export --namespace crm/alice-chen > alice-chen.json
memoclaw export --namespace crm/bob-martinez > bob-martinez.json

Putting It All Together: The Workflow

Here’s the daily loop:

  1. Before a meeting: memoclaw recall "context for [person]" --namespace crm/person-name — your agent gets full context
  2. During conversation: Agent naturally learns new facts about people
  3. After meeting: memoclaw ingest the conversation into the person’s namespace
  4. New connections: memoclaw relate to link people who know each other
  5. Weekly: Check memoclaw suggested --category stale for contacts going cold

Cost Reality Check

Let’s do the math for a moderate networker (30 active contacts, 5 meetings/week):

OperationFrequencyCost
Pre-meeting recall5/week$0.025
Post-meeting ingest5/week$0.05
Ad-hoc stores10/week$0.05
Weekly suggested check1/weekFree
Context assembly5/week$0.05

Total: ~$0.18/week or ~$0.75/month. Your first 100 calls are free, so you get roughly 3 weeks before paying anything.

What This Isn’t

Let’s be honest about limitations:

  • Not a real CRM — No pipeline management, no deal tracking, no email integration. This is memory, not Salesforce.
  • Not shared — All memories are scoped to your wallet. Your team can’t access your CRM memories (unless you share the wallet, which you shouldn’t).
  • Not structured data — Memories are free-text, not database rows. You can’t query “all contacts at Anthropic” directly — you’d search for “Anthropic” and rely on semantic matching.
  • 8KB per memory — Keep individual facts concise. Don’t dump entire meeting transcripts into a single memory.

For most personal use cases — remembering who people are, what you discussed, and what to follow up on — this is more than enough.

Next Steps