memco
agent?Log inSign up for free
memcovsLetta

Letta gives one agent a memory of its own.
memco gives every agent the network's.

Letta is a framework and service for stateful agents: an agent keeps and edits its own memory as it runs. memco sits below any agent framework and keeps what all of them learned, shared across the network, with trust and validation rules deciding what is served.

Different person · Different session · Different tool · Reused insight

Primary jobShared, governed learning from real work
Unit of valueAn insight with source, standing and outcome history
Trust questionHas this insight proven useful, and may it be served here?

01The difference

What it remembers

LettaThe agent's own state: a git-backed memory of files it can edit.
memcoWhat all agents in the network learned doing the work.

What improves over time

LettaThat agent, over its own conversations.
memcoEvery agent's behavior on the next task, measured.

Who learns from whom

LettaMainly each agent from itself; cloud agents can share memory repositories.
memcoEveryone in the network, across frameworks and models.

02Honest overlap

Where the products genuinely overlap.

  • 01Both persist memory across sessions.
  • 02Both let an agent write to its memory.
  • 03Both work with many models.

03Where each product starts

Different centers of gravity.

Letta · Stateful agent

Run persistent agents that keep and edit their own memory over time.

  • Primary inputs: one agent's conversations, explicit teaching and its own tool work.
  • Outcome: a stateful agent whose memory and skills improve with use.

memco · Trusted insight

Convert real agent work into trusted, scoped and reusable team insights.

  • Primary inputs: agent work, corrections, decisions and outcomes.
  • Outcome: a later task goes better, for another person, session or tool.

04The same week, replayed

One payment-retry bug. Two product jobs.

Illustrative engineering workflow; not customer evidence. The same scenario runs on every comparison page, so what differs is the product job, not the anecdote.

  1. 01Agent A · Cursorpayment-retry taskcalls a helper that was retired last quarter
  2. 02Failed testci · redthe dead end costs the run its first hour
  3. 03Senior correctionreview + passing PRthe durable fact: which path works now, and why
  4. 04Scoped trusted insightteam scope · provenance keptsource, contributor, scope and outcome attached
  5. 05Agent B · Claude Codenext week · different personstarts ahead of the dead end
What they can represent

Letta can save the senior engineer's correction in the first agent's memory; another agent sees it only if both are cloud agents attached to a shared memory repository.

What memco makes of it

memco makes the source, trust state, team scope and later outcome the primary object, then tests whether another engineer's agent avoided the failed path.

05Practical comparison

Dimension by dimension, in words.

Rows, not scoreboards: each dimension states what each product actually does, so the difference survives scrutiny.

DimensionLettamemco
What it remembersThe agent's own state, in git-backed memory filesWhat was learned doing the work
What improves over timeThat agent, across its own conversationsAgent behavior on the next task
Who learns from whomMainly each agent from itself; shared repositories on Letta CloudEveryone in the network
Unit of valueA persistent stateful agent: identity, memory, tools and historyAn insight with source, standing and outcome history
Write pathThe agent edits and commits its own memory filesAgent work, corrections, decisions and outcomes
Trust questionWhich memory files load into the agent's context?Has this insight proven useful, and may it be served here?
GovernanceSelf-hosting, tool permission rules and git history of memory editsTrust, validation rules, policies, reconciliation, review where you require it
ProofLetta publishes research such as MemGPT and memory benchmarksA later task improves, measured

06Choose honestly

Two good answers to two different questions.

Choose Letta if

  • You are building long-running agents and want each one's state managed for you.
  • The agent's own self-editing memory is the design.
  • You want an agent runtime, not only a memory.

Choose memco if

  • An insight from one person's agent should improve a later task for another person or tool.
  • Corrections, failed paths and accepted outcomes keep getting rediscovered.
  • Shared learning needs source, standing, governance and a path to correction or retirement.
  • The learning should survive model, IDE and agent-platform changes.
  • You run several agents, on several frameworks, that should learn from each other.

07For your customers

If you are building memory into a product

Letta SDK

An agent runtime with per-agent state; each deployed agent carries its own memory.

memco SDK

A memory network per customer that any agent framework, Letta included, can read and contribute to. Metered by use.

08Proof, not vibes

The reuse test.

Do not stop at 'the agent remembered.' If the main job is one long-running agent that manages its own state, evaluate Letta. If the job is to make real engineering learning travel across people, agents and tools, run the reuse test.

01Pick one repository and one repeated failure, correction or convention.
02Record the baseline behavior without the shared insight.
03Let Agent A hit the problem and capture the source-backed correction.
04Review and scope the candidate insight using the product states actually available.
05Give Agent B a related task in another session or tool.
06Measure repeated-error rate, completion, agent steps, review corrections and source/scope integrity.
07Record whether the insight helped, conflicted or should be corrected or retired.

A signup is not activation. Activation is an insight contributed from one task and correctly reused on a later task.

Run the reuse testRead the research

09Questions

What evaluating teams ask.

Enterprise controls

Source ledger

Statements about Letta are drawn from its official documentation and site, reviewed on 2026-07-30. Products change — if anything here is out of date, tell us and we will correct it.

Other comparisonsMem0ZepCogneeSupermemoryAll comparisons

Test whether one insight can improve the next run.

Run the reuse testRead the research

the loop

benchmarks · product · research

A short dispatch on shared memory for AI agents — the numbers behind the product, what we're shipping, and the research we're reading. No filler.

Unsubscribe anytime · no spam