Nexus(Agent Memory)

Connect agent memory
through API keys and MCP.

Nexus stores and recalls the decisions, verification results, failure causes, and session history produced by coding agents.

The browser surface is a thin console for API keys, usage, and MCP/AMCP connection status. The actual memory is written and recalled by Engram, Circuit, and coding agents during work.

Issue API keys and check usage.

Connect Codex, Claude Code, Cursor, and other agents through MCP.

Use AMCP-shaped records that can be exported and imported.

Open dashboard ->Manage API keys ->Setup docs

Install Nexus MCPHosted setup needs a Nexus API key

npx @nunchiai/nexus-mcp init --client codex --key <YOUR_NEXUS_API_KEY> --yes

Install Nunchi Memory LocalFree single-device Agent Memory stored on this machine

npx @nunchiai/nexus-mcp init --all --local --yes

AMCP reference server · MCP-native · REST API · Export / import portable

Nexus has to be understandable before the user picks cloud or local.

The browser surface must serve both local-first individuals and hosted teams. Nunchi Memory Local keeps Agent Memory on one machine; hosted Nexus adds API keys, usage, sessions, team quota, and AMCP gateway operations.

Local

Nunchi Memory Local

A personal user can connect supported agents to a local SQLite Agent Memory without treating Nexus as a cloud-only product.

Cloud

Nunchi Memory Cloud Trial and Nunchi Memory Pro

A user who needs continuity across devices starts from API keys, MCP setup, and hosted memory visibility.

Team

Nunchi Memory Team

A team uses Nexus as the Agent Memory layer that can coordinate with Norfolk Human Memory while preserving the separation between the two.

Why Nexus is a memory gateway, not another chat app

Users do not need another chat UI.

The real surface is the coding agent and the terminal. Nexus stores and recalls memory behind that workflow.

Admins need keys and usage.

API keys, workspace status, monthly usage, and connection health need a browser console.

Memory must not be locked to one tool.

MCP and AMCP let multiple agents read and write the same durable memory.

Nexus is the Agent Memory container.

It does not try to own raw code. It records decisions, verification results, session flow, and recovery reports as durable memory events.

Capture

MCP and API entry points bring memory into the agent loop with minimal friction.

Structure

Context is normalized into portable memory objects with scope, origin, and retention.

Recall

Relevant context returns when the next agent, session, or tool needs to continue the work.

Keep only what belongs in the browser.

The Nexus app surface is organized around API keys, usage, MCP/AMCP setup, sessions, and admin status. It should not look like a standalone consumer app.

How it works

const nexus = new NexusClient({
  apiKey: process.env.NEXUS_API_KEY,
  agentName: "your-agent",
});

await nexus.remember("Auth flow uses PKCE", "decision", {
  scope: { kind: "project", id: "acme-web" },
});

const context = await nexus.recall("auth decisions", {
  scope: { kind: "project", id: "acme-web" },
});

AMCP-native · MCP-native · Hosted API · Export / import portability · Works with any agent framework

Benchmark Result

83.2% on LongMemEval_S, measured on the production memory pipeline.

This was not a leaderboard-only prototype. We measured the same Synapsis memory pipeline that handles real API traffic, then published the remaining failure cases and limitations.

Read the benchmarking note ->

Read the note for the production setup, failure cases, and why we think honest memory benchmarks matter more than vanity scores.

Current Nexus surface

API key issue and rotation

Usage and session visibility

MCP/AMCP setup documentation

Agent Memory recall from Engram and Circuit

Nexus is not another app.
It is an agent memory gateway.

Open dashboard ->Manage API keys ->Read docs Talk to us