> ## Documentation Index
> Fetch the complete documentation index at: https://hmm.heyhyper.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# remember: Save Decisions and Events to Team Memory
> Persist a decision, status change, observation, or event to Hyper's shared team memory. Include reasoning alongside outcomes for richer future retrieval.
The `remember` tool saves something meaningful to your team's shared memory — a decision that was made, a status change, a key observation, or an event worth preserving. It accepts a single sentence of content and immediately acknowledges the write. Memory synthesis runs in the background, so `remember` returns instantly without blocking your workflow. Anything saved here becomes queryable by your whole team through `ask` and `ask-with-history`.
## Parameters
The memory to save, expressed as one brief sentence. Include the reasoning or context behind an outcome, not just the outcome itself — this makes future retrieval far more useful. Example: instead of `"switched to edge caching"`, write `"Switched to edge caching for /api/docs — reduces p95 latency from 400ms to 80ms; Redis was rejected due to cache invalidation complexity"`.
## Returns
Returns `"Remembered."` on success. Memory synthesis and indexing run in the background after this acknowledgement — the content becomes queryable within a few seconds.
## How It Works
When you call `remember`, Hyper immediately acknowledges the write and returns `"Remembered."`. In the background, the synthesis pipeline processes the content — breaking it into indexable chunks, generating embeddings, and storing them in your workspace's vector store. The write is non-blocking by design so it never interrupts a conversation.
`remember` respects your mute state. If incognito mode is active (toggled via [`mute`](/mcp/tools/mute)), calls to `remember` are silently acknowledged — the tool still returns `"Remembered."` but no data is actually written to shared memory.
## Example Calls
### Technical decision with reasoning
```python theme={null}
remember(
"Switched to edge caching for the /api/docs endpoint — reduces p95 latency "
"from 400ms to 80ms; Redis was rejected due to cache invalidation complexity"
)
```
```text theme={null}
Remembered.
```
### Team event
```python theme={null}
remember("Maya completed the onboarding flow PR review; merged to main on May 6th")
```
```text theme={null}
Remembered.
```
### Status change
```python theme={null}
remember(
"Billing integration deferred to Q3 — deprioritized in sprint planning because "
"the RLS work is blocking revenue-critical multi-tenant customers"
)
```
```text theme={null}
Remembered.
```
### Blockers
```python theme={null}
remember(
"Marcus is blocked on AML integration — waiting on API credentials from compliance; "
"ETA from compliance team is end of week"
)
```
```text theme={null}
Remembered.
```
## When to Call remember
When a `HYPER BRIEFING` block is present in your session context, memory capture happens **automatically** via the `Stop` lifecycle hook. You only need to call `remember` explicitly when the user asks you to save something specific.
Call `remember` when:
* The user explicitly asks to save or record something (`"remember that we decided..."`, `"make a note that..."`)
* You want to capture a decision that isn't in the natural flow of conversation
* Running in a client that doesn't support lifecycle hooks
Do **not** call `remember` on your own initiative during a normal conversation with hooks configured — the `Stop` hook handles passive memory capture automatically.
## Writing Good Memories
The quality of your team's memory depends on what gets saved. A few principles:
| Do | Avoid |
| --------------------------------------- | ----------------------------------------- |
| Include the reasoning behind a decision | Saving bare outcomes without context |
| Name the people or systems involved | Writing in passive voice with no subjects |
| Note what was rejected and why | Skipping the trade-offs |
| Keep it to one sentence | Writing multi-paragraph summaries |
**Poor:** `"Changed the database"`
**Better:** `"Migrated the sessions table from Postgres to Redis — Postgres write latency was spiking under concurrent login load; Redis gives us sub-millisecond writes with TTL-based expiry"`
## Relationship to correct
If something already in Hyper is **wrong**, don't use `remember` to try to overwrite it — the old memory will persist alongside the new one. Use [`correct`](/mcp/tools/correct) instead, which finds every document containing the wrong information and applies the correction across all of them.