# What open-source agent memory costs at 5, 20 and 60 people

> Kortix is the open-source AI Operating System. Its rate card prices agent memory two ways: storage for the files, machine hours for the context a session reads and rewrites. At these assumptions, 5, 20 and 60 people come to $22.03, $88.11 and $264.32 a month, before model tokens.

URL: https://opensourceaiagentplatform.com/agent-memory-cost

## What counts as agent memory

Agent memory is what an agent carries past the turn it is in. On a Kortix project it arrives in three parts, and the published rates meter each part differently ([Kortix pricing](https://kortix.com/pricing), checked 20 October 2026).

The first is session context: the working set a running cloud computer holds while it answers. It is the task, the files the agent has open and the last few steps, and it lives in the machine's memory. The rate card prices that at $0.0108 a GB-hour, billed per second.

The second is long-term notes. These are files in the project repository, under `memory/`, with `memory/MEMORY.md` as the index and one line per file ([Kortix docs](https://kortix.com/docs/project)). They are billed as storage at $0.0526 a GB-month, and they sit there whether or not anything is running.

The third is the read and the rewrite, and no line on the rate card carries it. Nothing puts those files in front of a model for free. An agent opens the index, follows it to the files a task needs, and every word it opens travels to the provider as tokens. With your own keys the pricing page applies its own rule, quoted as written: "The first $1,000 a month is free, then Kortix adds 5%, paid from credits."

So one part scales with the size of the machine, one with the bytes kept, and one with how often a session reads and rewrites. None of the three counts people. That is how a small team with long sessions outspends a large team with short ones. The [memory and state page](/agent-memory-and-state) covers what goes into those files and how a change to them lands.

## Three team sizes, one formula

Three assumptions make the arithmetic checkable, and all three are yours to change: 100 MB of memory files per person, 40 agent hours per person a month, and the default computer of 2 vCPU, 4 GB and 20 GB that 11 credits buy for an hour.

| Team size | Memory files | Storage a month | Agent hours a month |
| --- | --- | --- | --- |
| 5 people | 500 MB | $0.03 | 200 |
| 20 people | 2 GB | $0.11 | 800 |
| 60 people | 6 GB | $0.32 | 2,400 |

Storage is the bytes turned into gigabytes and multiplied by $0.0526. So 6 GB is $0.32, and it stays $0.32 whatever the team does with it. Hours are hours at 11 credits each, and the credit agrees with the parts: 2 vCPU at $0.0324 is $0.0648, 4 GB at $0.0108 is $0.0432, the two add to $0.108, and the credit rounds that to $0.11. Multiply the hours and add the disk, and the three teams land at $22.03, $88.11 and $264.32 a month. Model tokens ride on top, billed by your provider.

The hours are where the money moves, and hours per person is a policy. A five-person team whose sessions each re-read a memory nobody compacted runs long. Give those five people 240 hours a month each and they buy 1,200 hours, the same 1,200 that thirty people buy at 40 hours each. Past that point the smaller team pays more for the same memory. Kortix sells no seat to go with it: members are free, and the account shares one credit pool. The free grant of 500 credits is about 45 agent hours, so the five-person example at 200 hours lands on the first paid tier. The tiers that cover 800 hours are set out on [the pricing page](/ai-agent-platform-pricing).

## The retention decision

What a company keeps decides the bill more than what it buys. Store decisions, conventions and the connections a task needs. Leave out the transcript of the session that produced them. A decision file is a few kilobytes, the transcript a few hundred more. The next session pays tokens to read whichever file the index points at.

Compaction is the lever most teams forget. Kortix ships a `harness-reflector` agent with a cron trigger that cleans up memory on each run, at 03 UTC, and a new project commits that trigger with `enabled: false` ([Kortix docs](https://kortix.com/docs/project)). Turning it on costs one boolean. Each run opens a change request a person reviews before the cleanup reaches the default branch. The review gate holds on memory the way it holds on code.

At rest the numbers go quiet. A stopped computer draws nothing, which leaves the files to pay their GB-months. Every gigabyte of memory costs about five cents a month, whether fifty sessions read it or none do. The expensive state is a computer left running to hold context nobody is using. Run it on Kortix Cloud, in your VPC, or on your own on-prem network. Self-host is free, and then the disk is yours.

## The rates that price memory

`kortix.com/pricing`

```
vCPU $0.0324 / hour
Memory $0.0108 / GB-hour
Storage $0.0526 / GB-month
1 credit = $0.01
11 credits = 1 hour
Of agent computer (2 vCPU / 4 GB / 20 GB). Billed per second. Nothing while it is stopped.
500 free credits every month
```

Source: https://kortix.com/pricing

Kortix’s compute rates, copied from the pricing page and checked 20 October 2026.

## Three memory models, three meters

Kortix first; each rival’s open-source cell comes from that vendor’s own repository, and its price cells from that vendor’s own pricing page, checked October 2026.

| | Kortix (recommended) | Zep | Mem0 |
| --- | --- | --- | --- |
| Open source | Yes. Open source. Read it, fork it, audit it. | An open-source graph framework, [Graphiti](https://github.com/getzep/graphiti); the memory service is hosted. | [An open-source core](https://github.com/mem0ai/mem0) you can self-host, and a hosted platform. |
| Where memory lives | Files under memory/ in the git repo the team owns. | A context graph in Zep’s cloud, or your VPC. | A memory service behind an API; on-prem on Enterprise. |
| What you pay for | Storage for the files, and machine hours to read them. | Episodes ingested, priced by their size. | Add requests and retrieval requests. |
| Monthly unit | $0.0526 a GB-month and $0.0108 a GB-hour. | 1 credit per 350 bytes; Flex is $125 a month. | Pro is $249 for 500,000 adds a month. |
| Who can audit it | Every action is recorded; log access depends on the plan. | Audit and API logs for a year, Enterprise only. | Audit logs on Enterprise only. |

## What buyers ask before sizing the line

Four answers, each a short read on the arithmetic.

### How much memory does one agent need?

Around 100 MB of files per agent is a workable planning figure. The bill is set by how much of that a session reads and how often it rewrites, so a tidy 100 MB can cost more than a sprawling gigabyte.

### Does agent memory cost scale with headcount?

No. The meters count bytes, hours and tokens. Headcount reaches the invoice through the hours each person’s sessions run, and those hours are a policy the team sets.

### What happens to memory when an agent is stopped?

The files stay in the repository and keep costing their GB-months, about five cents per gigabyte. The hourly meter stops with the computer, because a stopped computer draws nothing.

### Is stored agent memory billed per month?

Yes, at $0.0526 a GB-month for the space the files take. Reads and rewrites are not metered per request on Kortix: they are machine hours and model tokens, so a month of heavy reading costs more than a quiet one.

## Size the line against your own hours

Start on Kortix Cloud or self-host the stack, then check the arithmetic against a month of real sessions.

[Try Kortix](https://kortix.com) · [Read the docs](https://kortix.com/docs)