Skip to content
eunomiaby
All posts

Projects: a small memory in every repo, linked to the big one

A small memory in every repo. Linked to the big one.

Coding agents are fast, but they forget. Every new session, they read the same files again, ask the same questions again, and miss the decision you made last month.

Projects fix that with two layers of memory.

A repository with a .eunomia folder, linked live to Eunomia Cloud

Coming soon. Projects and the .eunomia folder ship in an upcoming Eunomia release. Shared vaults, the code graph and MCP access for Claude Code, Codex, Cursor and others work today.

Layer one: the repo's own memory

Each repository gets a .eunomia folder. It holds the small, local memory for that codebase:

  • an index of its files and symbols, and how they call each other
  • the decisions and gotchas the team learned the hard way
  • a link to the team's vault in Eunomia Cloud

Agents working in the repo read this first. It is close, it is fast, and it is only about this code.

Layer two: the business's memory

Code is only half the story. Why does this service exist? Which customer asked for this flag? Who owns billing? That lives in Eunomia Cloud, the company's big, shared memory, split into vaults by team, project or client.

The live link between them

The .eunomia folder keeps a live link (a WebSocket) to Eunomia Cloud.

  • Decisions go up. When an agent learns something worth keeping, like "we pin this library because of a memory leak", it reaches the team vault. Every other agent and teammate sees it.
  • Context comes down. When an agent needs business context, like "what did the customer agree to?", it pulls it from the right vault, with access checked on every call.

So an agent in one repo can know what an agent in another repo decided yesterday. Without anyone copying notes around.

What is coming

Coming soon

  • One command per repo

    Run it in a repository. It makes the .eunomia folder, indexes the code and links it to your team vault.

  • How it works

    A live link joins the repo to Eunomia Cloud. Decisions go up to the team vault (yellow). Context comes down from every vault you can read (blue).

  • A code index

    Files, symbols and who calls what, so an agent finds the right place without reading the whole repo.

  • A decisions log

    What the team chose and why, written once. Every agent in the repo reads it before it starts.

  • Available today

    The agents you already use

    They connect over MCP today, each with its own token. Projects adds the repo memory on top.

What this looks like for a team

Without ProjectsWith Projects
Each session starts from zeroThe agent opens with what the repo already knows
Decisions live in Slack threads and headsDecisions are written once and found by every agent
Agents guess at business rulesAgents recall the rule, with where it came from
New starters ask the same questionsNew starters (and their agents) read the same memory

Works with the agents you already use

Eunomia speaks MCP, so Claude Code, Codex, Cursor, Windsurf, Gemini CLI, OpenCode and VS Code connect the same way. Each agent gets its own token, which can be limited to one vault and revoked on its own.

Running a software team on AI agents? Talk to us about Projects.