# Where an open-source AI agent platform keeps its memory

> Where an agent's memory lives decides what a team owns after the trial and what it pays at scale. Kortix, the open-source AI Operating System, keeps agent memory and state as files in a git repo you own, versioned and diffable.

URL: https://opensourceaiagentplatform.com/agent-memory-and-state

## The project repo, memory included

`the project repo`

```
kortix.yaml
AGENTS.md
agents/
  kortix.md
skills/
  my-skill/
    SKILL.md
memory/
  MEMORY.md
tools/
  lookup_order.ts
```

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

One repository holds the agents, the skills, and the memory files an agent reads.

## What an agent remembers, and what state means

Agent memory is what an agent keeps from earlier work: the current task's context, and the facts the company wants it to carry into the next session. Working memory holds the running conversation, the files a session opened, and the intermediate results it produced. Long-term memory holds what should still be true next week, such as a customer's preference, a project decision, or the way the company handles one job. State is the wider set around both: the agent's configuration, the branch its work sits on, and the memory it can read.

## Memory as files in a git repo, or memory in a tool's own store

Kortix keeps agent memory as plain files in the project repository. The folder is `memory/`, `MEMORY.md` is the index, and the managed `kortix-memory` skill tells an agent to read that index at the start of a task. 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 ([Kortix](https://kortix.com/docs/project)). Because the memory is text in a repository, a team can diff it, review it, and roll a change back the way it reviews code.

Other agent tools keep memory in a store the tool manages. CrewAI, a Python framework, gives each crew a `Memory` class with a hierarchical scope tree, ranked by similarity, recency, and importance ([CrewAI](https://docs.crewai.com/concepts/memory)). Dify keeps short-term context in Conversation Variables, which its own guide describes as temporary storage for multi-turn conversations inside a chatflow ([Dify](https://dify.ai/blog/dify-conversation-variables-building-a-simplified-openai-memory)). OpenHands keeps a conversation's workspace files and history with the session, so those files survive when the machine is replaced ([OpenHands](https://github.com/OpenHands/OpenHands)). The difference a buyer cares about is where the durable copy sits, in a repo the team holds or inside the tool that produced it.

## What a team still owns when the trial ends

A trial ends with a decision: keep the setup or rebuild it. When memory is a folder in a repository the team holds, the copy that stays is the same copy the agents used, so a new teammate clones the repo and reads the same memory. When memory lives in a framework's store or a vendor's workspace, what travels is whatever export that tool offers. The repository copy keeps its value while headcount, models, and vendors change.

## What agent memory costs at company scale

Memory is storage, and on Kortix the storage is the repository the team already keeps. Kortix prices seats and compute. The Free plan is $0 with 200 credits per month and 1 project; the team plan is $40 per seat per month with 2,500 credits pooled, and self-host is free ([Kortix](https://kortix.com/pricing), checked October 2026). A framework moves that cost to the team instead, because the team hosts the process, runs the store behind the memory, and pays for the compute that keeps it available. A buyer who compares the two is really asking who holds the durable copy and who pays to keep it.

## How a midsize team reasons about it

A team of a few dozen to a few hundred people can decide with four questions. Does the memory survive the tool that wrote it? Can a person read it without that tool? Can the team review a change to it before it lands? Who holds the copy if the team leaves? A repository of plain files answers all four, because the files, the history, and the review are the same objects. A store behind a vendor interface answers fewer, because the durable copy and the interface move together.

The [what an open-source AI agent platform is](https://opensourceaiagentplatform.com/what-is-an-open-source-ai-agent-platform) page defines the category this page assumes, the [self-hosting guide](https://opensourceaiagentplatform.com/self-hosting) covers where the repository runs, and [Kortix](https://kortix.com/blog/open-source-ai-agent-platform) keeps a running guide to the field on its blog.

_FAQ_

## Questions teams ask about agent memory

### Does an agent's memory survive a new session?

On Kortix, memory is files in the project repository, and an edit reaches other sessions only after a change request merges it into the default branch. A new session reads the memory that has merged, so it does not see edits still open on another branch.

### Where is open-source agent memory stored?

In a git repository the team owns. On Kortix the folder is `memory/`, indexed by `MEMORY.md`, and self-hosting keeps that repository on the team's own infrastructure rather than on a vendor's servers.

### Do we pay for agent memory separately?

Kortix prices seats and compute rather than a memory line. The Free plan is $0 with 200 credits per month, the team plan is $40 per seat per month with 2,500 credits pooled, and self-host is free, checked October 2026.

### Can we move the agents' memory to another tool?

Because the memory is text in a repository, a clone carries it, index and files together. A store inside a vendor's product exports only what that product's tooling allows.

## Run your agents on memory you own

Kortix is open source. Start free, or self-host the whole stack.

[Try Kortix](https://kortix.com) · [Self-host it](https://opensourceaiagentplatform.com/self-hosting)