AmpUp Memory · Hosted or open source
Turn your enterprise context into better agents.
Build on the context graph and catalogs you already maintain. Give agents shared memory that learns from outcomes, with versioned context for evaluation and training.
AmpUp runs it for your team, or you run it yourself: it is open source under Apache-2.0. For Claude Code, Codex, Gemini CLI, Cursor and Copilot.
AmpUp Memory
Versioned memory
Your existing context, connected to agent experience.
How context becomes agent experience. Illustrative memory version.
What makes AmpUp Memory different.
Memory shaped to your goals, improved by experience and grounded in the context your company already maintains.
- Memory shaped around your goals
- Each episode type has its own ontology: the facts and relationships memory can capture. Goals extend it with what matters for your work, while your existing catalog stays authoritative.
- Experience that improves the next run
- Connect what an agent knew and did to the outcome. Turn graded experience into guidance other agents can use.
- A known version for every record
- Pin each trajectory record to the memory version the agent used. Evaluate the system and prepare training data from that same history.
- Governed learning in your cloud
- Carry source permissions into memory, keep an audit trail and store the data in open tables your team controls.
Best-in-class memory
This is AmpUp's assessment, based on the evaluations and named baselines below. Broader leaderboard standing has not been independently verified.
In our evaluations, root-cause accuracy on ORCA-bench rose from 6.3% to 35.2%, and CRM question accuracy on CRMArena-Pro rose from 57.6% to 76.7%. Explore six public benchmarks and two internal evaluations below. Methods and run results are on GitHub.
It gets smarter with every graded run
ORCA-bench, 253 incident tasks, Haiku 5.5. Each point is scored on days the notes didn't learn from.
Knows your domain
- LongMemEval-S: 57.4% baseline, 78.7% with AmpUp Memory (+21.3 pts). Cost: 3% cheaper, 1× = $0.0012 a question. Questions about a user's past chats, 399 · facts kept for the goal, against generic extraction. Open its setup page.
- Sales pipeline questions: 0.71 baseline, 0.92 with AmpUp Memory (+0.20). Cost: not measured. Questions about AmpUp's own deals, 69, blind-judged · against our earlier Elasticsearch-based search. Open its setup page.
- Code review: 17.1% baseline, 20.3% with AmpUp Memory (+3.2 pts; interval +0.7 to +5.6 at 98.3%). Cost: 43% more expensive, 1× = $0.024 a review. Regressions caught by AmpUp's review bot, 688 real cases · with the team's pull requests, Slack and meetings, against the diff alone. Open its setup page.
Learns from outcomes
- ORCA-bench: 6.3% baseline, 35.2% with AmpUp Memory (+28.9 pts). Cost: 25% cheaper, 1× = $0.032 a task. Incident root causes found, 253 tasks · against no memory; a generic memory search scored 9.1%. Open its setup page.
- DolphinBench: 62.9% baseline, 72.3% with AmpUp Memory (+9.4 pts). Cost: 1% more expensive, 1× = $0.037 a task. Assistant requests done right, 480 held out · learned notes, against compiled procedures alone. Open its setup page.
- CRMArena-Pro: 57.6% baseline, 76.7% with AmpUp Memory (+19.1 pts). Cost: 50% cheaper, 1× = $0.0066 a question. CRM questions answered with SQL, 330 · against no notes. Open its setup page.
Holds the line where work repeats less
- SWE-ContextBench: 27.6% baseline, 30.6% with AmpUp Memory (+3.0 pts). Cost: 14% more expensive, 1× = $0.020 a run. Software issues resolved, 217 · against no memory. Open its setup page.
- τ²-bench banking: 27.8% baseline, 30.9% with AmpUp Memory (+3.1 pts). Cost: 27% more expensive, 1× = $0.054 a conversation. Bank support tasks passed, 97 × 3 · against reading every policy as files. Open its setup page.
* Code review's interval is 98.3%, corrected for several comparisons. All other intervals are 95%.
Every run leaves something to learn from.
Store agent memory and trajectory records in the same cloud storage. Each record is pinned to a memory version. Use those records to evaluate system performance through the control plane and train custom models.
Shared cloud storage
Evaluate the system
Through your control plane
Train custom models
From the same pinned records
One shared destination for memory, evaluation and training.
Illustrative trajectory and evaluation view. Each record keeps its memory version.
One shared destination
Store memory and pinned trajectory records together.
Evaluate system performance
Understand how the system is doing through the control plane.
Train custom models
Use the same records with their original memory context.
Prepare data for eval and training
A trajectory connects the task, the memory version, the steps taken and the outcome. Keep that context with each record as you prepare evaluation and training datasets.
Memory sits in open Apache Iceberg tables and moves through the engine as Apache Arrow. Training jobs can read a pinned snapshot while agents keep writing.
Pin a snapshot
$ ampup-memory workspace snapshot orca_goal
Export memory’s model-call log
$ ampup-memory train-log export <scope> --out FILE
In our benchmarks, every AmpUp Memory arm on ORCA-bench (4), τ²-bench banking (4) and SWE-ContextBench (2) read one content-hashed memory version, recorded with every attempt it scored.
The benchmark results above measure learned memory and guidance. We haven’t trained a model from these tables yet.
Memory that follows the work.
For a long-running task, an agent works on its own branch and records memories as it goes. When the run completes, those memories merge into mainline.
Collect memories during the run. Share them after it completes.
Illustrative memory entries and version numbers.
A branch for each long task
Give the agent its own memory during the run.
Remember as the work happens
Record useful context as the agent progresses.
Share after the run
Merge the completed run’s memories into mainline.
Explore branch, snapshot and merge details
Your team can also use branches to try a schema or compile guidance before changing mainline. Pin a snapshot for evaluation; conflicting merges are refused.
Branch
$ ampup-memory workspace branch orca_goal oncall
Compile guidance
$ ampup-memory compile team:acme/support --branch arm1
Pin memory
$ ampup-memory workspace snapshot orca_goal --branch oncall
Merge behavior
merge · three-way
In the engine's model test, 100 random sequences of 15 operations matched the reference model: 204 merges, 26 refused as conflicts.
Your infrastructure. Your controls.
Start on a laptop, then deploy in your own cloud account. AWS and Google Cloud are ready.
LAPTOP
Try it locally. Memory stays on your machine; only model calls leave it.
SNOWFLAKE
Keep memory in your Snowflake account, stored as open Iceberg tables.
GOOGLE CLOUD (GCP)
Ready. Store memory in your own catalog and bucket.
AWS
Ready. Deploy AmpUp Memory in your own AWS account.
Databricks is not yet available.
AmpUp Memory, governed
Manage sign-in, team access, connected sources and deployments in one place. The control plane holds none of your memory.
ENTERPRISE CONTROLS
Your deployment sends only approved operational telemetry to the control plane. Facts, queries and organization names are rejected.
- Sign-in
- single sign-on with your identity provider
- Multi-factor authentication
- required for each organization
- Domains
- verified, with sign-in through SSO required
- Roles
- admin and member roles, with invitation links
- Sources
- 100+ connectors
- Deployments
- individual deployment keys that can be revoked
- Offboarding
- revoke access, erase memory and set retention
What people ask first.
Where does my data go?
With hosted AmpUp Memory, AmpUp runs the server and stores your team's memory. If you run it yourself, it stays wherever the server runs: on a laptop under ~/.ampup-memory; in Snowflake, with nothing sent to AmpUp; on Google Cloud, in your own catalog and bucket. Model calls go through OpenRouter by default; a direct backend can keep them inside your cloud.
How is this different from Mem0, a vector database or a CLAUDE.md file?
Mem0 and vector databases are generic memory: they store what was said and find it again, the same way for everyone. On that job alone, Mem0 open source and AmpUp Memory tie on LongMemEval (82.2% vs 79.7%). AmpUp Memory is built to learn: it extracts the facts your goals call for, in your vertical's schema, and rewrites a note for each kind of task from your graded runs. Permissions carry over from every source, and the memory sits in Iceberg tables in your own catalog. A CLAUDE.md file holds rules you already know; notes capture the ones you don't yet.
How many graded runs before notes help?
It depends on the task. On ORCA-bench, notes from 135 runs scored 16.2%, from 284 runs 19.8% and from 454 runs 35.2%, against 6.3% with no memory. The DolphinBench note above came from six runs. On τ²-bench, notes showed no measurable gain. Search and saved memory work from the first session.
What is dreaming?
An agent that writes memory mid-task sees only its own session, and it has a task to finish. Dreaming runs out of band with its own budget and sees what the whole team's agents have written. It ends values a newer fact replaced, links two facts that say the same thing, and joins the names of one thing (owner and maintained_by, rep memory and rep memory page). It only adds rows, so as_of still reads what was there before. It runs for one audience at a time, so it never mixes in facts a reader couldn't see. A dry run prints every decision with the model's reason, and one command takes back everything a pass did. It is off by default; turn it on per org or team, and it runs nightly or hourly.
What happens to our memory if we stop?
On Snowflake or Google Cloud it is Iceberg tables in your own catalog, readable by Snowflake and BigQuery, so it stays with you. On a laptop it stays on disk. On hosted AmpUp Memory, AmpUp stores it.
Where does it lose today?
When a whole history fits and the model reads it well, reading it all wins (93.0% vs 58–61% with Haiku on LongMemEval). Mem0 leads on time-based questions. Compiled procedures alone, before any graded runs, scored below plain files on τ²-bench (21.0% vs 27.8%). Sonnet 5.5 beat Haiku with notes on SWE-ContextBench by about 5 points, and on DolphinBench by 9.2 when Sonnet read the history as files. On code review, learned notes didn't help, though evidence from past work did; on alert triage, memory hasn't helped yet.
Which models does it use?
Claude Opus 5.5 for the rare steps whose output every later task reads: compiling procedures and writing notes. Claude Haiku 5.5 for extraction, judging and routing. Each is configurable per org.
Bring one workflow to AmpUp Memory.
Start with your existing context and one agent workflow. See what shared memory can add.
AmpUp hosts it for your team. Prefer to run it yourself? It is open source under Apache-2.0: start from the GitHub repo and the docs.
Invited to set up your team's memory?
Your admin's invite email has the link that starts setup. The docs walk through it: set up your org, then invite people.
Benchmark methods, prompts and run results are public: github.com/A79-ai/ampup-memory/benchmarks.