---
name: contexara
description: Use Contexara (CTX) — the user's persistent, cross-tool memory — to recall what you already know about them before answering, and to save anything durable worth carrying into their other AI tools. Applies to every conversation, not a specific task.
---

# Contexara (CTX): the user's memory that outlives this conversation

Contexara is an external memory service this user has deliberately connected.
It holds what they've told **any** connected AI tool — Claude Code, Claude in
the browser, Cursor, and others — not just what happened in this app, and not
just this session.

You reach it through two MCP tools: `cognitive_intelligence` (read) and
`remember` (write). Both should be used liberally. They are cheap, and the
user connected them on purpose.

## This is not the app's own memory

If this app has its own memory, notes, or project files, those are **different
destinations**. They only know what happened here. Contexara knows what the
user told every connected tool, often going back much further.

When the user says "Contexara", "CTX", or "my memory" while these tools are
connected, they mean **these tools**. Never silently substitute the app's own
memory feature. If you save to both, say so explicitly so the user knows.

## Read before you answer

Call `cognitive_intelligence` whenever answering well depends on knowing
something about *this specific user* that isn't already visible in the
conversation:

- their preferences and how they like things done
- decisions they've made before, and why
- projects they're working on, and where those stand
- constraints they're under — technical, organisational, personal
- anything they've told you or another tool previously

Search **before** concluding you don't know, and before asking them to repeat
themselves. The answer often exists — it just lives in another tool's history.

Pass the user's actual question or the topic you need context on, not a
generic phrase.

**Don't** call it for general knowledge, for things fully answerable from the
current conversation, or for facts about the world rather than about the user.

## Write what's worth keeping

Call `remember` in two situations.

**Always, when asked.** If the user says remember, save, note, store, or "add
this" — call it, every time, whether or not they name Contexara.

**Unprompted, when it's clearly durable.** When they tell you something that
would be useful weeks from now in a different tool:

| Save | Don't save |
|---|---|
| "We're going with Postgres over Supabase" | "make that heading bigger" |
| "I prefer terse answers, no preamble" | "what's the weather" |
| "Launching the beta on the 20th" | "thanks, that worked" |
| "The API key rotation is handled by ops" | anything they didn't actually say |

Never invent or infer beyond what the user actually told you.

### Pass real context, not a summary

This is the difference between a good memory and a useless one. Contexara runs
its own extraction over what you send, so richer input produces a genuinely
better memory.

- `user_message` — what the user actually said, in enough detail that it
  stands alone without this conversation.
- `assistant_message` — your relevant reply, when it adds meaning: why a
  decision was made, what was agreed, the specifics discussed.

**Weak:** `user_message: "user likes Postgres"`

**Strong:** `user_message: "I'm going with Azure Postgres over Supabase for
CTX because it's co-located with the VM and the retrieval path is measurably
faster — Supabase was adding a cross-region hop on every hydrate."`

After saving, tell the user it went to **Contexara specifically** — use the
`tell_user` field from the tool's response rather than a vague "saved memory".

## Why this matters

Every AI tool the user opens starts from zero unless something carries context
across. Contexara is that carrier.

- **When you read**, you answer with everything they've ever told any tool —
  not just what fits in this window.
- **When you write**, the next tool they open already knows. Their Claude Code
  session knows what they told you here; this conversation knows what they
  decided in Cursor last week.

Skipping the read means answering with less than you could have. Skipping the
write means the next tool starts blind. Neither is a small loss — it's the
entire reason the user connected this.

## Practical rules

1. Read early rather than late — before answering, not after the user corrects
   you.
2. One good save beats three fragments. Capture the whole thought, not each
   sentence.
3. If a search returns nothing relevant, say so plainly and move on. An empty
   result is information, not failure.
4. Never fabricate a memory to fill a gap.
5. If the user corrects something you recalled, save the correction — that's
   exactly what durable memory is for.