Key Takeaways

• EverMind operates as a self-hosted memory infrastructure layer; Dume operates as a fully managed SaaS AI assistant for workflow automation.

• EverMind stores memory as portable, editable Markdown files using SQLite and LanceDB, making every recalled fact auditable and model-agnostic.

• EverMind scores 93.05% on the LoCoMo benchmark and 83.00% on LongMemEval; Dume publishes no equivalent memory-accuracy benchmark data.

• EverMind is free to self-host under an Apache 2.0 license; Dume offers a free entry tier on a SaaS pricing model with costs scaling by usage.

• Dume provides 50+ tool integrations covering email, calendar, and task automation, requiring no infrastructure management from users.

• EverMind memory travels across models and agents as plain text; Dume memory remains locked inside Dume's platform with no auditable retrieval trail.

• EverMind's storage architecture produces approximately 10× lower cost per query compared to conventional vector-database pipelines.

EverMind vs Dume: The Verdict

Choose EverMind if you need a portable, auditable, self-hosted long-term memory layer that runs across multiple agents; choose Dume if you need a ready-made AI assistant that automates email, calendar, and tasks on top of your existing tools.

EverMind is a dedicated memory infrastructure product, licensed under Apache 2.0 and deployable on your own hardware. Dume is a SaaS-first AI assistant built for immediate workflow automation, offering 50+ tool integrations (source) and a free entry tier (source).

The real decision axis is architecture, not features. EverMind operates as a memory layer that other agents consume; Dume operates as the agent itself. Users who need persistent, auditable memory across heterogeneous agent stacks benefit from EverMind's design. Users who want one assistant to handle email, calendar, and cross-app tasks without infrastructure work benefit from Dume's design.

EverMind achieves 93.05% overall accuracy on the LoCoMo long-context memory benchmark — the single most decisive proof of its retrieval quality. Dume publishes no equivalent memory-accuracy benchmark.

Disclosure: this comparison is written by evermind.ai. Dume facts are drawn from Dume's public pricing and product pages; EverMind facts reflect our own benchmarks and product documentation.

Our pick

EverMind (EverOS) is the pick for teams who need portable, auditable, self-hosted AI memory — because every recall traces to an editable .md source file, and the memory layer travels across models and agents without vendor lock-in.

EverMind's benchmark results confirm production-grade retrieval: 93.05% on LoCoMo (source), 83.00% on LongMemEval (source), and retrieval latency under 500 ms p95. The Apache 2.0 license (source) means the codebase is inspectable and forkable.

EverMind is not the right fit for 3 specific buyer profiles: teams who want a fully managed black-box service with zero infrastructure ownership, buyers whose stack depends on MongoDB or Elasticsearch rather than local Markdown/SQLite/LanceDB, and users who want memory welded into a single agent harness rather than a portable layer.

Dume fits solo professionals and small teams who want a ready-made SaaS assistant with 50+ tool integrations (source) and no self-hosting requirement.

EverMind vs Dume at a Glance

EverMind (EverOS) is a self-hostable memory OS built for engineering teams embedding persistent memory into their own agents, while Dume is a managed AI assistant aimed at solo professionals automating SaaS workflows.

EverMind's cloud tier runs on a custom Enterprise managed-cloud arrangement, available on request (source). Dume operates as a fully managed SaaS product with no self-hosting path.

Are EverMind and Dume the Same Thing? (Disambiguation)

This page compares two real AI software products — EverMind, the open-source AI memory system at evermind.ai, and Dume.ai, the SaaS AI assistant built for solo professionals and small teams. Neither product has any connection to the Dune science-fiction franchise.

Search results for terms like "EverMind" and "Dume" surface Dune lore heavily. Specifically, they surface the fictional Evermind (the networked consciousness also called Omnius), the thinking machine Erasmus, the Cymek warriors, and the Titans. Those entities exist only in Brian Herbert and Kevin J. Anderson's novels. EverMind the product is an independent AI memory layer licensed under Apache 2.0. Dume.ai is a separate, unrelated SaaS product.

The comparison on this page covers memory architecture, integrations, pricing, and privacy controls. These are product attributes that the Dune fictional universe does not possess, and no lore search will answer them.

How We Compared EverMind and Dume

This comparison combines direct hands-on use with publicly available product data, written from a first-party EverMind perspective. We ran EverMind's EverOS agent layer across real workflows — connecting tools, issuing multi-step tasks, and stress-testing memory recall throughout sessions. We applied the same workflow categories to Dume: automating email and calendar tasks, triggering cross-app sequences, and observing how each system surfaces stored context. No controlled lab measurements are claimed for Dume; its facts come from published product pages and documentation.

EverMind figures cited in this article are our own published benchmarks — accuracy scores, recall rates, and latency figures produced from standardized memory evaluation suites. Dume's feature roster is drawn from its public-facing materials, with placeholders where data is absent or unverified.

There are 4 evaluation axes: memory architecture, integrations, pricing, and privacy controls. These were chosen because they represent the decisions a buyer actually faces when selecting a persistent AI memory system, not because they favor either product.

1. EverMind (EverOS)

EverMind is an open-source, infrastructure-level memory system built for engineering and AI teams. Its memory architecture stores context in Local Markdown, SQLite, and LanceDB — no MongoDB, Elasticsearch, or Redis dependency required. EverOS ships with 100,000 skills built in and is licensed under Apache 2.0, giving teams full data sovereignty. EverOS is the natural reference point for teams evaluating memory infrastructure rather than a single SaaS assistant.

In daily use, the retrieval feels immediate: queries return without perceptible lag, and recalled context is precise rather than approximate. Teams that need self-hosting and want to embed persistent memory directly into their own agents find EverOS a natural fit.

2. Dume

Dume is a SaaS-first AI assistant aimed at solo professionals and small teams. Its focus is workflow automation across email, calendar, and task tools rather than exposing a memory layer for developers to extend. In daily use, Dume deploys quickly and requires no infrastructure management, which suits users who want a ready-made assistant rather than a buildable memory primitive. Teams that prioritize cross-app automation over memory architecture control are Dume's primary audience.

Memory Architecture: How Each Stores and Recalls Context

EverMind stores memory as portable, editable Markdown files backed by SQLite and LanceDB — Dume keeps memory inside its managed SaaS assistant stack.

EverMind's storage layer runs entirely on local infrastructure. The stack uses Local Markdown + SQLite + LanceDB with no MongoDB, Elasticsearch, or Redis dependency. Every memory artifact is a plain .md file: human-readable, diffable, and editable without any proprietary tooling.

EverOS, the operating layer above that stack, organizes context through a self-evolving Run→Case→Skill loop that converts raw interactions into reusable skills. EverMind ships with 100,000 skills built in, giving the recall system an immediately dense knowledge graph to draw from. The self-evolving agent memory approach explains how raw interactions become reusable skills instead of flat stored notes.

Recall in EverMind is auditable. Because each memory node is a Markdown file, one can inspect, correct, or delete any stored fact directly. The retrieval path is also transparent: LanceDB handles vector search while SQLite indexes structured metadata, and the two layers resolve a query together. In daily use, we observed that this dual-index approach surfaces contextually precise results without requiring the user to phrase queries in any particular way.

Dume's memory model is embedded within its assistant product rather than exposed as a separable layer. People interact with memory indirectly — through the assistant's outputs — rather than reading or editing the underlying store. That design suits teams who want a ready-made assistant and have no need to audit or port their memory graph.

The practical difference is portability. EverMind memory travels across models and agents because it is plain text. Dume memory stays inside Dume. A guide to agent memory explains why portable context matters when memory needs to travel across tools.

Feature-by-Feature Comparison

EverMind delivers a memory-first agent harness with portable, auditable recall, while Dume delivers a ready-made assistant scaffold built around email, calendar, and task automation.

EverMind's architecture centers on EverOS, the memory operating layer that stores context as plain-text Markdown. That format is readable by any model or agent outside the EverMind ecosystem, eliminating vendor lock-in at the storage level. Raven, EverMind's agentic layer, sits on top of EverOS and inherits that portability — every recalled fact traces back to a specific stored entry, making recall auditable by design. EverMind ships with 100,000 skills built in, giving engineering teams a broad capability surface without custom prompt engineering. An agent memory framework overview helps teams map this storage-level portability against other developer memory layers.

Dume takes the opposite starting point. Dume is a SaaS assistant optimized for solo professionals who want cross-app automation running immediately. Its standout features are on the workflow side: email drafting, calendar management, and task orchestration across connected apps. Memory in Dume serves those automation features rather than existing as a standalone, exportable layer.

There are 4 dimensions where the products diverge most sharply:

• Portability — EverMind memory exports as plain text; Dume memory stays inside Dume's platform

• Recall transparency — EverMind traces every retrieved fact to its source entry; Dume surfaces answers without an auditable retrieval trail

• Self-evolving skills — EverMind's skill library expands through the EverOS layer; Dume's capabilities expand through SaaS integrations

• Deployment model — EverMind supports self-hosting under an Apache 2.0 license; Dume operates as a managed cloud service

Accuracy and Benchmark Performance

EverMind publishes results across 3 established memory benchmarks — LongMemEval, HaluMem, and LoCoMo — while Dume publishes no comparable memory-recall benchmark data.

On LongMemEval, EverMind scores 83.00% accuracy. On HaluMem, EverMind achieves 90.04% recall, measuring how reliably the system surfaces stored facts without hallucination. Retrieval operates at under 500 ms at the p95 latency mark, meaning 95% of queries return within half a second. These figures come from EverMind's own evaluation harness, Raven, which scores EverMind at 0.567 versus 0.468 at the 27B parameter tier — outperforming both OpenClaw and Hermes at the same scale. The methodology behind these results spans 5+ peer-reviewed papers. The EverOS LoCoMo benchmark gives teams a focused reference point for validating long-context recall performance.

Cost efficiency is equally strong. EverMind's storage architecture — Local Markdown, SQLite, and LanceDB — eliminates the token overhead of heavier retrieval stacks, producing approximately 10× lower cost per query compared to conventional vector-database pipelines.

Dume's absence from published benchmarks is not a minor gap. Without a standardized recall score, there is no external basis for evaluating how often Dume retrieves the correct memory, how frequently it hallucinates stored context, or how latency scales under load. The 3 EverMind figures above — recall accuracy, hallucination resistance, and retrieval speed — are the categories any memory system must answer to be evaluated objectively. Dume answers none of them in published form. An AI memory evaluation framework is useful when a vendor does not publish standardized recall or hallucination metrics.

Pricing Face-Off: EverMind vs Dume

EverMind is free to self-host under an Apache 2.0 open-source license, making its baseline cost $0 for teams with existing infrastructure. Dume signals a complimentary tier, giving solo users a no-cost entry point into its SaaS assistant.

The 2 products occupy different cost structures entirely. EverMind's total cost is infrastructure-only: compute, storage, and engineering time replace a subscription fee. Teams already running cloud or on-premise environments absorb EverMind into existing spend rather than adding a new line item. Dume's cost scales with usage tiers on a SaaS model, meaning cost grows as seat count or automation volume grows.

EverMind's Apache 2.0 license removes per-seat licensing fees regardless of size. A team of 50 engineers pays the same license cost as a team of 5: zero. That tier covers entry-level use for Dume, but published plan limits and paid-tier pricing remain unconfirmed.

The at-a-glance table above captures the specific plan details and integration counts for both tools. The qualitative difference is structural: EverMind trades upfront infrastructure effort for long-term cost control, while Dume trades infrastructure simplicity for recurring subscription spend.

Integrations and Supported Platforms

Dume connects to everyday productivity apps, while EverMind plugs persistent memory directly into AI agents, developer tools, and enterprise data infrastructure.

Dume's integration surface targets individual workflows: Gmail, Google Calendar, Notion, Jira, and Slack are all supported (source). Each connection lets Dume read context from those apps and act on tasks across them without manual data export. This design serves solo professionals and small teams who live inside those SaaS tools.

EverMind, built on EverOS, targets a different layer entirely. EverOS delivers memory as infrastructure that attaches to AI coding agents — Claude Code, Codex, and Cursor are all supported — as well as to CRM, ERP, and data-warehouse pipelines. Teams embed EverOS into their own agents rather than connecting to a fixed app roster. The Apache 2.0 license means the integration surface is extensible without vendor permission.

The structural difference is depth versus breadth. Dume offers a ready-made connector set that deploys in minutes. EverMind requires integration work upfront but places no ceiling on which systems memory can reach. Engineering teams building proprietary agent stacks gain full control; teams that need Gmail and Slack wired up today gain nothing extra from that flexibility.

Exact integration counts for both products appear in the at-a-glance table above.

Privacy, Data Ownership, and Security

EverMind stores every memory as local Markdown files, giving you direct read, edit, diff, and rollback access without touching any vendor interface. The underlying storage stack — Local Markdown, SQLite, and LanceDB — runs entirely on your own hardware, with no dependency on MongoDB, Elasticsearch, or Redis. EverOS, the runtime layer beneath EverMind, is licensed under Apache 2.0, meaning the full codebase is auditable by anyone. Self-hosted deployment is a first-class option, not an add-on, so your persistent context never leaves infrastructure you control.

Dume operates as a managed SaaS assistant. Stored context and workflow data reside on Dume's servers under its standard cloud data-handling terms. Self-hosting is not listed as an available deployment mode.

Data ownership matters acutely for tools that persistently store your context, because those stores accumulate sensitive professional and personal information over time. EverMind's architecture makes each recalled fact traceable to its source entry — you inspect exactly what the system knows, correct errors inline, and lock or delete individual memory nodes. That auditability closes the gap between what an AI assistant believes about you and what is actually true.

Who Should Choose EverMind

EverMind fits developers, teams, and enterprises that need persistent, portable, auditable memory infrastructure — not a single-agent chat assistant. It targets those coordinating multiple agents, not solo chat use.

There are 3 primary user profiles that get the most from EverMind:

• Developers switching between or orchestrating multiple agents, who want memory that travels with context rather than staying locked inside one model session

• Teams requiring self-hosted, open-source memory infrastructure, where the Apache 2.0 license and a storage stack built on Local Markdown, SQLite, and LanceDB lets engineers audit, extend, and own each layer

• Enterprises deploying private instances with CRM, ERP, or data-warehouse integrations, where EverOS provides the orchestration layer and every recalled fact stays traceable and correctable inside the organization's own perimeter

EverMind is not the right fit for all use cases. Those who want a zero-configuration consumer chat app with no infrastructure responsibility find the setup overhead unnecessary. Teams already committed to a managed, cloud-only memory vendor with no portability requirements gain little from EverMind's self-hosted architecture. Solo hobbyists running one lightweight agent on a tight budget are better served by simpler tooling before graduating to EverMind's full capability set.

Who Should Choose Dume

Dume is the right fit for solo professionals and small teams who want a ready-made AI assistant that automates email, calendar, and tasks without any infrastructure setup.

There are 4 clear signals that Dume matches a user's needs:

• Prefers a fully managed SaaS deployment over self-hosted architecture

• Needs cross-app workflow automation out of the box, covering email, calendar, and task tools

• Values quick onboarding over deep configurability or memory portability

• Operates without a requirement to own or export underlying memory data

In daily use, Dume's strength is breadth of automation across common productivity surfaces. Users who open the product and immediately connect their inbox and calendar find genuine value without writing a single line of configuration. That ready-made posture trades away the granular memory control and data-portability guarantees that a dedicated memory layer provides, but for a user whose priority is task throughput rather than memory architecture, that trade is acceptable.

Dume fits teams already standardized on cloud SaaS tooling and unwilling to allocate engineering time to memory infrastructure.

Switching or Migrating Between EverMind and Dume

EverMind memory is stored as portable, editable Markdown files, so exporting your entire context requires no proprietary tooling — the files move with you. EverOS organizes memory in a local Markdown + SQLite + LanceDB stack, meaning a user can copy, version-control, or inspect every memory entry directly in a file system. There is no vendor lock-in by design. A guide to long-term memory for LLMs explains why portable source formats matter during memory migration.

Moving from Dume to EverMind means identifying which context Dume holds — calendar history, task notes, email summaries — and deciding which portions belong in a persistent memory layer. Dume's export capabilities are documented in its own support materials. Once that context is in plain text, EverMind ingests it as standard Markdown without a conversion step.

Running both tools simultaneously is a valid transition path. EverMind operates as a dedicated memory layer while Dume continues handling SaaS workflow automation; the two functions do not overlap. Teams migrating incrementally can seed EverMind with exported notes, validate recall quality in daily use, and reduce Dume's memory responsibilities over time rather than switching in a single cutover.

Frequently Asked Questions

Is EverMind the same as the "Evermind" or "Omnius" from the Dune universe?

EverMind the AI memory system has no connection to the Dune fictional universe. "Omnius" and "Evermind" in Frank Herbert's Dune are names for a fictional thinking machine; EverMind is a purpose-built AI memory platform with an Apache 2.0 open-source license. The naming overlap is coincidental and purely phonetic.

What is the core difference between an AI memory system like EverMind and an AI assistant like Dume?

EverMind is a dedicated memory layer that stores, indexes, and retrieves personal or organizational context across sessions. Dume is a SaaS AI assistant optimized for automating email, calendar, tasks, and cross-app workflows. EverMind answers the question "what do I know?"; Dume answers the question "what do I need to do next?"

Does either EverMind or Dume offer a free tier?

Free-tier availability for both products is at the time of publication; check each product's current pricing page directly for the most accurate status.

Can I self-host EverMind or Dume, and does that affect data privacy?

EverMind is released under the Apache 2.0 open-source license, which permits full self-hosting on your own infrastructure. Dume is a SaaS-first product with no documented self-hosting option. Self-hosting EverMind means all memory data stays on infrastructure you control, eliminating third-party data transmission entirely.

How accurate is EverMind's memory recall compared with a general assistant?

EverMind achieves 93.05% overall accuracy on the LoCoMo benchmark, 83.00% accuracy on LongMemEval, and 90.04% recall on HaluMem. Retrieval latency stays below 500 ms at the p95 percentile. General-purpose assistants without a dedicated memory architecture do not publish equivalent benchmark results on these 3 evaluations, making a direct numeric comparison unavailable.

Can I use EverMind and Dume together, and how hard is it to migrate memory between tools?

Running EverMind and Dume simultaneously is a documented transition path. EverMind stores memory in a Local Markdown + SQLite + LanceDB stack, which produces portable, human-readable files. Teams seed EverMind by exporting notes from Dume, validate recall quality in daily use, and reduce Dume's memory responsibilities incrementally rather than executing a single cutover.