AmpUp 推出 Enterprise Brain,為企業AI 助理提供可版本控管的共享記憶
Enterprise Brain – Memory that learns from work
AmpUp 推出 Enterprise Brain,讓AI 助理使用能根據工作結果改善的共享記憶,並將記憶版本與任務軌跡連結,以供評估與準備訓練資料。
AI 伴隨問答
針對這篇報導有疑問?可直接點選快捷問題或向 AI 追問背景脈絡與技術細節:
頁面以多項基準比較 Enterprise Brain 的記憶功能,並揭露成本變化與表現落差,可據此瞭解其適用任務與限制。
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.
For Claude Code, Codex, Gemini CLI, Cursor and Copilot.
Enterprise Brain
Versioned memory
Context v12
Learned guidance
Governed access
What makes Enterprise Brain 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.
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 Enterprise Brain (+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 Enterprise Brain (+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 Enterprise Brain (+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 Enterprise Brain (+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 Enterprise Brain (+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 Enterprise Brain (+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 Enterprise Brain (+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 Enterprise Brain (+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.
Agent trajectory Memory v12
Task Handle a return
Context Pinned memory
Steps Check, apply, respond
Outcome Feedback recorded
Shared cloud storage
Agent memory
Trajectory records
Evaluate the system
Through your control plane
Train custom models
From the same pinned records
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
$ memstore workspace snapshot orca_goal
Export memory’s model-call log
$ memstore train-log export <scope> --out FILE
In our benchmarks, every Enterprise Brain 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.
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
$ memstore workspace branch orca_goal oncall
Compile guidance
$ memstore compile team:acme/support --branch arm1
Pin memory
$ memstore 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 Enterprise Brain in your own AWS account.
Databricks is not yet available.
Enterprise Brain, 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?
Wherever the server runs. On a laptop it stays under ~/.memstore. In Snowflake nothing is sent to AmpUp. On Google Cloud, setup scripts put the tables in your catalog and bucket. During the preview a team can also use a server AmpUp runs, and then AmpUp stores that team's memory. 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 Enterprise Brain tie on LongMemEval (82.2% vs 79.7%). Enterprise Brain 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 AmpUp's preview server, 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.
Already invited? Set up your deployment
Preview teams get the CLI with their invite. Setup pairs your machine with the wizard, then applies the plan in your account. Use the control-plane URL from your invite in place of the example below.
terminal
$ memstore init --control-plane https://setup.example.com
# prints a pairing code; an admin finishes setup in the browserBenchmark methods and raw runs are available on request during the preview.