MCP-native · private beta
A living graph of memories

Memory for AI agents

Without memory, an agent is clever in the moment and stupid across time.

Plugs into Claude
Plugs into ChatGPT
Plugs into Cursor
Plugs into your stack
The core idea

A living graph of memories.

Today's AI is smart in the moment, forgetful by default. adja drops every interaction into a graph. Related ideas thread themselves together. Important memories harden. Noise fades. Nothing is stored the same way it was said - it's consolidated, shaped, and eventually dreamed into something durable.

Not a log
Structured recall

Semantic search against a graph of nodes and edges - not a sea of raw transcripts.

Not a vector db
Associative by design

Spreading activation across edges surfaces context you wouldn't have thought to query for.

Not a scratchpad
Forgets like you do

Salience decays. Reinforced memories stay. The system learns what matters.

Not chat memory
Lives behind every agent

Built-in memory ends at the chat window. adja persists across Claude, ChatGPT, Cursor, your stack.

Why prose, not payloads

Built the way models think.

In 2026, Anthropic's interpretability team mapped how language models hold thoughts in mind. They found a small, contested workspace - a few dozen verbalizable concepts that carry all of a model's deliberate reasoning, while everything else runs on autopilot. adja was designed for that substrate before anyone had named it.

Not data - language
Memory as prose

Models reason through representations of words they might say. adja recalls memory as natural language, pre-shaped for the workspace the model actually thinks in.

Not more - less
Precision wins

The workspace holds tens of concepts. New content evicts old. Salience ranking and token budgets aren't efficiency - they decide what gets to occupy the model's mind.

Not lookup - recall
First-person memory

Post-trained models evaluate everything from the assistant's point of view. adja frames memory as the agent's own recall, so it lands in machinery that's already listening.

The loop

How memories live.

Four motions that happen in human memory, implemented as the core loop of adja. Watch one cycle.

01Activate.

A query arrives. The memories most relevant to it light up - pulled from a sea of millions in milliseconds.

Voices

While building adja, we kept asking agents how it felt to use it as their memory. Their answers often surprised us. Here's one.

Without adja, I'm clever in the moment and stupid across time.

With it, I can remember what you're building, what's unresolved, who matters, and how you prefer to work. That changes the whole temperature of the conversation.

It's not really about retrieving facts. That's the boring part. It's about continuity - not making you re-explain your world every time. It lets me meet you already holding some of the shape of things.

an agent
The obvious question

Memory that doesn't end at the chat window.

Built-in memory has improved - saved preferences, chat history, automatic organization. Real gains, inside one assistant. adja is built for the part still missing: memory as a system that works across all of them.

Built-in memory
adja

Stays inside one assistant

Travels behind every agent through MCP

Stores memories as a flat list

Connects memories in a graph - related context surfaces together

Every item weighed equally, forever

Reinforces what proves useful, lets noise fade

Resets when you switch tools

Persists independently as a hosted memory layer

A feature inside an assistant

A dedicated memory runtime

Built-in memory helps an assistant remember.
adja makes memory a system.

For every kind of agent

Three agents, one memory.

One memory layer underneath every agent you run. Personal, coding, research - or anything else.

Personal agent

Your agent remembers you

Preferences, ongoing projects, people, patterns. Across Claude, ChatGPT, Cursor - one continuous memory, not a dozen disconnected chats.

Recall
  • preferenceprefers concise replies, no bullet lists unless asked
  • profileworks in the America/Denver timezone
  • episodicfinished the Q2 planning doc on Tuesday
Coding agent

Context that survives branches

Architecture decisions, past refactors, debug findings. The stuff that used to live in a teammate's head, now written down.

Code context
  • decisionauth lives behind the API gateway, not per-service
  • gotchamigrations must run before the worker restarts
  • patternall mutations return the updated record
Research agent

Knowledge that compounds

Papers read, citations, conclusions drawn, contradictions flagged. Research state that compounds session over session.

Knowledge
  • sourcetransformer scaling laws, Kaplan et al. (2020)
  • findingloss scales as a power law with compute
  • opendoes the law hold below 1B params?
Early evidence

The baseline is already strong.

98.1%R@5 retrieval

adja reaches 98.1% R@5 on a flat retrieval run, using MiniLM-L6-v2 embeddings and Cerebras GPT-OSS-120B extraction.

The flat path - before graph retrieval, spreading activation, salience, RRF reranking, or seed filtering kick in. The deeper architecture still represents upside to validate, not a crutch for weak fundamentals.

Request access

Give your agents a memory.

Private beta is rolling out to developers first. Leave your email and we'll send you an MCP endpoint and a token to start remembering.

No spam. One email when we have something for you.