> ## Documentation Index
> Fetch the complete documentation index at: https://docs.memanto.ai/llms.txt
> Use this file to discover all available pages before exploring further.

# Temporal Memory

> Query memories as of a specific point in time, since a given date, or by recency.

# Temporal Memory

Query memories from specific points in time using temporal queries. All temporal endpoints are `POST` and accept a JSON body. Authentication uses `X-Session-Token` only — clients do not send a Moorcheh API key.

## Temporal Queries

Memanto supports three time-based query variants:

### 1. As Of (Point in Time)

Return memories that were valid at a specific moment, excluding memories created after that moment or expired before it:

```
Query: "What did we know on May 1?"
Result: Memories valid as of May 1 — created before that date,
        not expired before it.
```

**Use case:** Historical audit trail.

```python theme={null}
import httpx

response = httpx.post(
    f"{base}/agents/{agent}/recall/as-of",
    headers={"X-Session-Token": session_token, "Content-Type": "application/json"},
    json={
        "as_of": "2026-05-01T14:00:00Z",
        "type": ["fact", "decision"],
    },
)
```

There is **no `query` parameter** for `/recall/as-of`; results are listed chronologically. Use `type` to narrow the listing server-side.

### 2. Changed Since (Time Range)

Return memories created or updated after a given timestamp:

```
Query: "What changed in the last 7 days?"
Result: All memories created or updated since that date.
```

**Use case:** Recent updates and changes.

```python theme={null}
import httpx

response = httpx.post(
    f"{base}/agents/{agent}/recall/changed-since",
    headers={"X-Session-Token": session_token, "Content-Type": "application/json"},
    json={
        "since": "2026-05-01",
        "limit": 50,
    },
)
```

There is **no `query` parameter** for `/recall/changed-since`; results are sorted by `updated_at` descending. Each item carries a `change_type` field (`"created"` or `"updated"`). Use `type` to narrow by memory type.

### 3. Recent (Newest-First)

Return the most recently stored memories, sorted by `created_at` descending. Useful when you want the latest context without a semantic query:

```
Result: The N latest memories for the agent (optionally filtered by type).
```

**Use case:** "What did the agent learn most recently?"

```python theme={null}
import httpx

response = httpx.post(
    f"{base}/agents/{agent}/recall/recent",
    headers={"X-Session-Token": session_token, "Content-Type": "application/json"},
    json={"limit": 10, "type": ["fact", "decision"]},
)
```

There is **no `query` parameter** for `/recall/recent`; results are purely chronological.

## Time Format

Temporal endpoints accept ISO 8601 (with UTC) or date-only:

```
2026-05-09T16:30:00Z   ← full ISO 8601
2026-05-09             ← date-only
                         /recall/as-of:        end-of-day UTC
                         /recall/changed-since: start-of-day UTC
```

## Use Cases

### 1. Audit Trail

Verify what was known at a specific time:

```python theme={null}
import httpx

response = httpx.post(
    f"{base}/agents/support/recall/as-of",
    headers=headers,
    json={
        "as_of": "2026-05-01T00:00:00Z",
        "type": ["fact"],
    },
)
```

### 2. Change Tracking

See what changed during a project window:

```python theme={null}
import httpx

response = httpx.post(
    f"{base}/agents/project/recall/changed-since",
    headers=headers,
    json={
        "since": "2026-05-01",
        "limit": 50,
    },
)
```

### 3. Latest Activity

Pull the most recent memories without a query:

```python theme={null}
import httpx

response = httpx.post(
    f"{base}/agents/project/recall/recent",
    headers=headers,
    json={"limit": 10},
)
# Returns the 10 newest memories, sorted newest-first
```

### 4. Time Series Analysis

Track how information changed over time:

```python theme={null}
import httpx

dates = ["2026-04-01", "2026-04-15", "2026-05-01"]

for date in dates:
    response = httpx.post(
        f"{base}/agents/project/recall/as-of",
        headers=headers,
        json={"as_of": date},
    )
    memories = response.json().get("memories", [])
    if memories:
        print(f"{date}: {memories[0]['content']}")
```

### 5. Regression Detection

Find when something changed:

```python theme={null}
import httpx

test_dates = ["2026-04-20", "2026-04-25", "2026-05-01"]

for date in test_dates:
    response = httpx.post(
        f"{base}/agents/support/recall/as-of",
        headers=headers,
        json={"as_of": date},
    )
    memories = response.json().get("memories", [])
    if memories:
        print(f"{date}: {memories[0]['content']}")
```

## Memory Versioning

Memories carry a `status` field — Memanto's conflict resolution flow can mark older memories as `superseded` when newer information replaces them. `recall/as-of` reflects the state that existed at the queried timestamp, regardless of later supersession.

```
Memory A
  └─ Created: 2026-04-20
     Content: "Project deadline: April 30"
     Status: superseded (after the resolution below)

Memory B (created during conflict resolution)
  └─ Created: 2026-04-25
     Content: "Project deadline: May 15 (extended)"
     Status: active

"As of" Queries:
  └─ Before April 25: returns Memory A as it was — active
  └─ After April 25:  returns Memory B
```

## Best Practices

### <Icon icon="check" /> DO

* Use ISO 8601 timestamps for precision
* Resolve conflicts explicitly via [Resolve Conflict](/api-reference/data/resolve-conflicts)
* Use `/recall/recent` to surface fresh context quickly

### <Icon icon="xmark" /> DON'T

* Delete old memories — let conflict resolution mark them superseded
* Ignore temporal information when results look ambiguous
* Mix old and new data without checking `created_at`

## Next Steps

* [Memory Operations](/guides/memory-operations)
* [Recall As Of](/api-reference/search/recall-as-of)
* [Recall Changed Since](/api-reference/search/recall-changed-since)
* [Recall Recent](/api-reference/search/recall-recent)