Portable Memory For Agents That Need Continuity
AMCP-native reference server, MCP integration, lifecycle hooks, and hosted memory API for teams that need context to survive session, tool, and runtime boundaries.
Trial Cloud can be started immediately with sign-in and API-key issuance. No credit card is required for the first 30 days.
What Nexus Gives You
- 1. A hosted memory API for agents that need durable context.
- 2. MCP-native setup plus lifecycle hooks for supported clients with one install path.
- 3. A reference AMCP surface for remember, recall, sessions, export/import, and delete.
Nexus stores reusable memory objects and returns the right context when the next agent needs to continue the work.
Current official baseline is CLI-first. Desktop and IDE variants may be config-compatible, but they are not presented as equally verified unless runtime checks were completed.
Why Portability Matters
Memory has to survive more than one chat window
“The hard part is not making one agent smart. The hard part is keeping context alive when sessions end, tools change, and work gets handed off.”
Nexus is built around that boundary: session continuity, cross-agent handoff, and portable memory operations instead of one-off chat state.
What Ships Today
Nexus is already usable as a reference memory stack
Current Surface
- 1. Hosted AMCP endpoints for remember, recall, sessions, export/import, and delete.
- 2. MCP server for supported coding-agent clients.
- 3. Local Lite activation path for local SQLite memory.
- 4. Policy-aware key scopes and usage controls.
The protocol itself is documented separately on the dedicated AMCP page.
Client Coverage
Start Nexus In 2 Steps
Sign in, issue a key, then choose hosted or local setup.
Issue an API Key
Hosted Nexus starts here. Log in with your Synapsis account, then go to Settings → API Keys to issue a key for MCP setup or direct AMCP API usage.
Every account starts on Trial Cloud with no card required. The 30-day window starts when you issue the first hosted key. Local Lite is the local SQLite continuation path; Cloud Pro and Team stay hosted.
Connect a Client
Nexus detects installed clients and writes MCP config safely. Hosted mode uses your issued key. Local Lite uses activation after local install.
The current install path is designed to make MCP attachment easy without turning Nexus into a full agent product.
# hosted / cloud
# interactive (recommended: key not saved in shell history)
npx -y @nunchiai/nexus-mcp@latest init --gateway-url https://gateway.nunchiai.com
# non-interactive
npx -y @nunchiai/nexus-mcp@latest init --all --key sk_write_your_key --gateway-url https://gateway.nunchiai.com --yes
# local lite
npx -y @nunchiai/nexus-mcp@latest init --all --local --yes
npx -y @nunchiai/nexus-mcp@latest activate --key sk_write_your_key --gateway-url https://gateway.nunchiai.com
# verify available clients
npx -y @nunchiai/nexus-mcp@latest init --listIn the current validated release (v0.4.12), init installs MCP config first and then installs lifecycle hooks for supported clients unless you explicitly pass --no-hooks.
Reference Workflow
`nexus sync` helps conventions survive agent changes
Manage conventions once, then recall them anywhere. Sync rule files such as `AGENTS.md`, `CLAUDE.md`, and `.cursor/rules/*` into Nexus so the next agent inherits the same operational context.
# 1) connect MCP once
npx -y @nunchiai/nexus-mcp init
# 2) sync curated rule files to Nexus (convention atoms)
npx -y @nunchiai/nexus-mcp sync
# 3) any agent can recall/generate with the same conventions
# Cursor -> Claude Code -> Codex, same project rulesWhat Changes In Practice
Less re-briefing, clearer handoff, more portable execution.
Continuity across sessions
When one session ends, the next agent can recall the decisions and context that matter instead of starting cold.
Continuity across tools
Move between supported clients such as Codex, Claude Code, Cursor, and Windsurf without rebuilding project memory by hand.
Portable memory objects
Memory is stored with scope, origin, retention, and source references so it can be exported, imported, and reused.
Reference implementation
Nexus gives you a working reference stack for AMCP memory operations instead of leaving the model at abstract spec text.
Policy-aware operations
Hosted memory respects key scopes such as read, write, export, and delete, so operational boundaries stay explicit.
Usable operating surface
API keys, dashboard visibility, MCP setup, and billing tiers are exposed as product surfaces rather than hidden engineering internals.
Four Tiers, One Memory Contract
Every account starts on Trial Cloud without a credit card. The trial begins when the first hosted API key is issued. Local Lite, Cloud Pro, and Team stay in the same memory model, but paid upgrades are currently held until billing launch is enabled.
Trial Cloud
- 25,000 MU/month
- 30-day trial
- Cloud memory enabled
- 1 included API key
- No credit card required
Local Lite
- 5,000 MU/month
- 5,000 Atoms cap
- 30-day retention
- Local SQLite storage
- License-based activation
Cloud Pro
- 25,000 MU/month
- 90-day retention
- Cloud memory pool
- 1 included API key
- Solo or small-team workflows
Team
- 120,000 MU/month
- 365-day retention
- Shared cloud memory
- 10 included API keys
- Team and company workflows
Trial Cloud is live now. Paid upgrades stay hidden behind billing launch, but hosted evaluation and API-key issuance are already open.
Frequently Asked
What is Nexus, exactly?
Nexus is a portable memory layer for AI agents. It combines a hosted memory API, an MCP server, and an AMCP reference surface so agents can carry context across sessions, tools, and time.
Is Nexus an agent product?
No. Nexus is infrastructure, not a general-purpose agent. It gives agents memory operations such as remember, recall, sessions, export/import, and delete, while your existing agent remains the interface.
How do I start using hosted Nexus?
Sign in with your Synapsis account, go to Settings → API Keys, issue a key, and connect your client with the Nexus MCP install command or the AMCP API. Trial Cloud starts there and does not require a credit card.
What is the difference between Trial Cloud, Local Lite, Cloud Pro, and Team?
Trial Cloud is the hosted evaluation tier with no-card start and one included API key. Local Lite is single-device local SQLite memory with license activation. Cloud Pro is hosted solo memory. Team is shared hosted memory with a larger pooled limit and multiple keys.
Can I move memory between systems?
Yes. Nexus supports export/import so memories can move between environments in JSON or JSONL form. Portability is part of the product direction, not an afterthought.
What does delete mean today?
Current delete behavior is soft delete. Deleted memories are excluded from normal recall, but the system keeps deletion state instead of doing immediate hard purge.
What is MU (Memory Unit)?
MU is the usage unit for memory operations. It reflects work such as remember and recall, and recall depth affects consumption. Monthly limits depend on your tier.
A Better Standard For Agent Collaboration
A decision made in Claude Code is available in Cursor
Different agents share one memory layer so you can switch tools without context loss.
Context survives chat resets
Important decisions stay available over time, so your team can continue work without re-briefing.
One memory brain for all your agents
Connect your main tools once and keep a consistent working context across them.
Start With A Key, Then Connect Memory
Issue a Nexus API key, connect MCP or the hosted API, and start on Trial Cloud now without a credit card. Local Lite, Cloud Pro, and Team are the planned paid path once billing launch is enabled.
Hosted API · MCP server · Trial Cloud 30-day trial · paid upgrades currently coming soon