# How Hermes Agent memory works, and the open source way a team shares it

> Hermes Agent remembers through two small curated files, MEMORY.md and USER.md, that the agent writes itself. That works for one operator. For a team, Kortix is the open-source AI Operating System whose agents, memory and connectors live in one git repo you own.

URL: https://hermesalternative.com/hermes-agent-memory

## Where a project's memory lives

`project-tree`

```
kortix.yaml
AGENTS.md
agents/<name>.md
skills/<name>/SKILL.md
memory/MEMORY.md
tools/<name>.ts
harnesses/opencode/
```

Source: https://kortix.com/docs/project

Kortix keeps memory in the project repository, so a remembered fact is a file a person can read, diff and review.

## How Hermes Agent memory works

Hermes Agent's built-in memory is two small text files rather than a database. `MEMORY.md` holds the agent's own notes and is capped at 2,200 characters; `USER.md` holds a profile of you and is capped at 1,375. Both sit in the Hermes home directory and are injected into the system prompt as a frozen snapshot at the start of each session ([Persistent Memory](https://hermes-agent.nousresearch.com/docs/user-guide/features/memory)).

The agent manages its own memory with a memory tool that can add, patch or remove entries, and Hermes nudges it to persist knowledge as it works. The limits are deliberate. When a write would overflow, the tool returns an error and the agent consolidates or removes entries itself before retrying. Because the snapshot freezes at session start, a fact saved in one session appears only in the next.

## External providers, one at a time

Hermes can add an external provider for knowledge beyond the two files. RetainDB and ByteRover ship as plugins, and Honcho, Hindsight, Supermemory and others install from the plugin catalog. Only one external provider can be active at a time, and the built-in memory stays active alongside it ([Memory Providers](https://hermes-agent.nousresearch.com/docs/user-guide/features/memory-providers)). A provider syncs conversation turns and mirrors memory writes, so the authoritative record can live in a cloud service such as Honcho Cloud.

## The gap when a team shares one agent

Hermes memory is scoped per profile by design. Its documentation warns that pointing two agent processes at one Hermes home directory lets automatic writes compound into state neither of them authored. A shared team agent therefore runs one operator's curated notes, or mirrors them to a single external provider. There is no built-in way for a whole team to review a remembered fact, attribute it to a source, or roll it back.

## How Kortix stores team memory

Kortix is the open-source AI Operating System, and its memory is a folder in the project's git repo. `memory/MEMORY.md` is the index, with one line per file, and the memory tool reads and writes only inside `memory/`. Kortix does not inject memory into every prompt; an agent reads the index at the start of a task and then the files it points to ([Read the docs](https://kortix.com/docs/project)). A memory edit is an ordinary file change on the session branch, and other sessions see it only after a change request merges it into the default branch. The practical difference is memory the whole team can review and version like code.

For the wider switch, read [/migrate-from-hermes](/migrate-from-hermes) and [/hermes-for-teams](/hermes-for-teams).

## Kortix memory and Hermes Agent memory side by side

The Hermes column states what Hermes's own documentation says; the Kortix column states what Kortix's documentation says.

| | Kortix (recommended) | Hermes Agent |
| --- | --- | --- |
| memory model | A memory folder an agent curates, indexed by MEMORY.md | Bounded curated files, MEMORY.md and USER.md, written by the agent |
| where memory is stored | Files under `memory/` in the project git repo | Files in the Hermes home directory; optional external provider |
| who it is shared with | The whole project, once a change request merges | One profile; two writers compound each other's entries |
| how it is reviewed and versioned | Ordinary git commits and diffs, merged by change request | Per file; no review or versioning step |
| roles and permissions | Per-resource permissions for people and agents. Roles, groups, and an audit trail. | Per-profile isolation and command-approval modes |
| self-hosting | Run it on Kortix Cloud, in your VPC, or self-host free | Self-hosted by design on your own server |

## Questions about Hermes Agent memory

### Where does Hermes Agent store memory?

In two files in the Hermes home directory, `MEMORY.md` and `USER.md`, under the profile's memories folder. `MEMORY.md` is capped at 2,200 characters and `USER.md` at 1,375, and both are injected into the system prompt at the start of a session.

### Can Hermes Agent use an external memory database?

Yes. It ships with the RetainDB and ByteRover plugins and can install Honcho, Hindsight, Supermemory and others from its catalog. Only one external provider can be active at a time, and the built-in files stay active alongside it.

### What happens when a team shares one Hermes Agent?

Hermes memory is scoped per profile, and its docs warn that two agent processes on one home directory compound each other's entries. A shared agent can push memory to one external provider, but there is no built-in review, attribution or rollback.

### How does Kortix make memory shared by a team?

Kortix stores memory as files under `memory/` in the project git repo, which every session clones. A memory edit is a file change on the session branch and reaches the default branch only through a change request a person reviews.

## Give your team memory it can review.

Start with one agent and grow from there.

[Try Kortix](https://kortix.com) · [Hermes for teams](https://hermesalternative.com/hermes-for-teams)

Open source · Any model, your keys · Self-host, VPC, or on-prem