# Try Dense-Mem in 5 Minutes With the Hosted Demo

**Summary:** A quick tutorial for using the hosted Dense-Mem test instance, connecting Claude Code and Codex to the same temporary memory, and seeing how shared context helps AI work smarter.

- Canonical: https://markhuang.ai/blog/dense-mem-hosted-demo-test-instance
- Language: en
- Author: [Mark Huang](https://markhuang.ai/about)
- Published: 2026-05-31
- Section: Tutorials
- Tags: dense-mem, mcp, ai-memory, claude-code, codex, tutorial
- License: https://creativecommons.org/licenses/by-nc/4.0/

---

![Two AI assistant sessions sharing one temporary Dense-Mem demo memory key](https://cdn.markhuang.ai/blog/dense-mem-hosted-demo-test-instance/hero.webp)

*Two AI assistant sessions sharing one temporary Dense-Mem demo memory key*

## Quick Answer

Use the hosted Dense-Mem demo when you want to test the idea before running your own server:

```text
https://demo-dense-mem.markhuang.ai
```

The fast path:

- Open <https://demo-dense-mem.markhuang.ai>.
- Copy the temporary API key it generates.
- Connect one MCP client to `https://demo-dense-mem.markhuang.ai/mcp`.
- Connect a second AI client with the same key.
- Ask one client to remember something disposable.
- Ask the other client to recall it.

That is the point of Dense-Mem: different AI sessions can share one memory layer. The AI still does the talking and reasoning, but Dense-Mem gives it durable context so it can work with more information instead of starting cold every time.

## Where This Fits

| Goal                                      | Use this                                                                                                               |
| ----------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
| Try Dense-Mem without installing anything | This hosted demo tutorial                                                                                              |
| Run your own local memory server          | [Dense-Mem Quick Start: Give Claude Code and Codex the Same Memory](/blog/dense-mem-personal-server-claude-code-codex) |
| Host Dense-Mem on a public HTTPS server   | [Secure Dense-Mem on Vultr with Traefik](/blog/secure-dense-mem-vultr-traefik)                                         |

## What The Demo Shows

The hosted demo creates a temporary isolated team for you. The generated key lasts 24 hours and points at one private demo memory space.

![Multiple AI client sessions sharing one temporary Dense-Mem demo key through one hosted memory hub](https://cdn.markhuang.ai/blog/dense-mem-hosted-demo-test-instance/shared-memory-flow.webp)

*Multiple AI client sessions sharing one temporary Dense-Mem demo key through one hosted memory hub*

If both sessions use the same generated key, they can read and write the same temporary memory. If you generate a new key, you create a new isolated team with separate memory.

This lets you test Dense-Mem's core capability: many AI instances can use one memory service, so every linked session can work with richer context.

Dense-Mem is not a replacement for Claude, Codex, or another assistant. It is the memory layer behind them. It stores evidence, creates typed claims, promotes safe facts, searches memory later, and returns clarification tasks when memory conflicts instead of silently rewriting facts.

## Before You Start

The hosted demo is for disposable test data only.

| Limit                  | Demo value             |
| ---------------------- | ---------------------- |
| Session lifetime       | 24 hours               |
| Authenticated requests | 300                    |
| Write attempts         | 75                     |
| Save attempts          | 30                     |
| Content stored         | 128 KiB                |
| Claims                 | 30                     |
| Verifier attempts      | 10                     |
| Promoted facts         | 5                      |
| Recall calls           | 50                     |
| Rate limit             | 20 requests per minute |

Do not store secrets, passwords, credentials, personal data, production notes, or anything critical. Expired demo teams and graph data are deleted.

## Step 1: Generate A Demo Key

Open the hosted demo page:

<https://demo-dense-mem.markhuang.ai>

The page creates a temporary key automatically for the current browser tab. You can also click **Generate New Key**.

Copy the key and save it in your shell:

```bash
export DENSE_MEM_API_KEY="dm_..."
```

Use the same key for every AI client you want to link during the test.

## Step 2: Check The MCP Endpoint

Run a direct MCP tools check:

```bash
curl -s "https://demo-dense-mem.markhuang.ai/mcp" \
  -H "Authorization: Bearer $DENSE_MEM_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list","params":{}}'
```

The response should include tools such as:

```text
remember
recall_memory
reflect_memories
confirm_memory
save_memory
list_recent_memories
list_facts
```

If this fails, check the key first. The most common mistake is copying an expired key or generating a new key in another tab and mixing them up.

## Step 3: Connect Claude Code

Set the key in the terminal where Claude Code runs:

```bash
export DENSE_MEM_API_KEY="dm_..."
```

Add the hosted demo MCP server:

```bash
claude mcp add --transport http dense-mem-demo \
  https://demo-dense-mem.markhuang.ai/mcp \
  --header "Authorization: Bearer $DENSE_MEM_API_KEY"
```

Ask Claude Code:

```text
Use Dense-Mem to remember that this demo project codename is river-lamp and I prefer concise answers with concrete commands.
```

Use harmless fake data like this. The demo is public infrastructure with temporary storage.

## Step 4: Connect Codex To The Same Memory

Use the same environment variable:

```bash
export DENSE_MEM_API_KEY="dm_..."
```

Add this to `~/.codex/config.toml`:

```toml
[mcp_servers.dense_mem_demo]
url = "https://demo-dense-mem.markhuang.ai/mcp"
bearer_token_env_var = "DENSE_MEM_API_KEY"
tool_timeout_sec = 60
enabled = true
```

Restart Codex after changing the config.

Now ask Codex:

```text
Before answering, use Dense-Mem to recall what you know about my demo project codename and response style.
```

Expected result: Codex should call Dense-Mem and find the memory that Claude Code saved, because both clients used the same demo key.

## Step 5: Test A New Session

Start a fresh AI session with the same key still configured.

Ask:

```text
What do you remember from Dense-Mem about this demo?
```

The assistant should not rely on the old chat transcript. It should recall memory from the Dense-Mem server.

This is the workflow Dense-Mem is built for. One session gives the memory layer useful facts. Another session starts later and can work smarter because the context is already available.

## Step 6: Test A Conflict

Ask your client:

```text
Remember that I prefer long narrative explanations in this demo.
```

If your client uses the high-level memory workflow, Dense-Mem can return a clarification instead of silently replacing the earlier concise-answer preference. The assistant should ask which memory to keep.

That behavior matters. Useful AI memory is not only recall. It also needs guardrails for old facts, new facts, and corrections.

## Step 7: Open The User UI

Return to the demo page and click **Open UI**, or open:

```text
https://demo-dense-mem.markhuang.ai/ui
```

The demo page stores the generated key in the browser tab, so the UI can use it after you generate a key. The user UI is for checking your temporary session and key actions. It is not a production admin portal.

## What You Should Notice

Dense-Mem makes AI instances more useful in three practical ways:

| Capability            | What it means in the demo                                                                            |
| --------------------- | ---------------------------------------------------------------------------------------------------- |
| Shared memory         | Claude Code, Codex, and other MCP clients can use the same key and see the same memory.              |
| More context for AI   | The assistant can recall previous preferences, decisions, and project notes instead of asking again. |
| Evidence-first memory | Dense-Mem stores source fragments before claims or facts, so memory has provenance.                  |
| Conflict handling     | New claims that conflict with active facts can become clarification questions.                       |
| Team isolation        | A new demo key creates a separate temporary team, so tests do not mix unless you reuse the key.      |

This is why Dense-Mem helps AI work smarter. It does not make the model magically correct. It gives the model better context, shared continuity, and a safer memory workflow.

## When To Move Past The Demo

Use the hosted demo to prove the concept. Then run your own server when the memory matters.

Use these next:

- [Dense-Mem Quick Start: Give Claude Code and Codex the Same Memory](/blog/dense-mem-personal-server-claude-code-codex) for a local Docker setup.
- [Secure Dense-Mem on Vultr with Traefik](/blog/secure-dense-mem-vultr-traefik) for a public HTTPS server you control.
- [Dense-Mem wiki](https://github.com/markhuangai/dense-mem/wiki) for the full reference.