Use case · Coding agent
Stop teaching your AI the same conventions every Monday
Code conventions, refactor history, architectural decisions. Saved once by the agent. Read back on the next session. Across Cursor, Claude Code, Continue, and any MCP-aware editor.
The pain
Monday morning, same explanation, third week in a row
You open Cursor. The agent suggests let
on the first variable it writes. Your team committed to
const
two months ago. You wrote it in .cursorrules.
You wrote it in AGENTS.md.
You wrote it in the PR template. The model still drifts.
The reason is structural. The agent sees the rules file at the top of the context window. Then it sees fifty file imports, the relevant module, your in-progress diff, and forty messages of you negotiating with it. By the time it generates the next line, the rule has been pushed out of the window in everything but the literal token sense.
Pasting more rules in is the wrong fix. The session is the problem. Every Monday is session one. You don't have a "convention" problem, you have a memory problem.
The shape of the fix
The agent writes down what it learns, reads it back next time
Session 1 — Monday
You set the convention
- You: "we use const here, not let"
- Agent acknowledges and learns
Korely vault
Agents/Cursor/conventions.md
- Plain Markdown on your disk
- Indexed for hybrid search
Session 2 — Friday
Agent shows up informed
- Reads the convention before writing
- Suggests const, not let
One vault, one folder per agent. The same convention file is re-read by every coding agent you plug in.
How Korely fits
One agent_id per repo, one folder per editor
You connect Korely to your editor once. The MCP server exposes
two write tools, save_note
and create_task,
and five read tools, including hybrid search and graph
traversal over the vault.
When the agent learns something durable, like a naming rule, a
file-layout convention, or a decision someone made on a PR
comment, it calls save_note
with the client_name
it identifies as (Cursor, Claude Code, n8n, whatever). The note lands in
Agents/<ClientName>/
in your vault. Plain Markdown. You can open it in any editor.
You can grep it. You can rewrite it when the agent records
something wrong.
On the next session, the same agent searches the vault before it writes the next line. The relevant note surfaces. The suggestion lands correctly.
Show me the code
A minimal two-session flow
# ── Monday: Cursor encounters a new convention ──────────────────
from korely_memory import Korely
korely = Korely(api_key="kor_live_...")
# Reviewer comments on PR: "we always use const, never let"
korely.add(
"Team convention: use `const` for all variable declarations "
"in TypeScript. `let` is only allowed inside short-lived "
"loop counters.",
agent_id="team-acme-typescript",
client_name="Cursor", # lands in Agents/Cursor/
)
# ── Friday: new feature branch, agent recalls the rule ─────────
context = korely.search(
"variable declaration convention",
agent_id="team-acme-typescript",
)
# context → "Use const. let only inside short-lived loop counters."
# The agent prepends this to its system prompt before generating
# the next line. No more drift between sessions.
The same vault is reachable from Claude Code, Continue, n8n, and any other MCP client.
Different client_name
values keep each editor's notes in its own folder, so you can audit who recorded what.
When conventions change
The agent tracks the timeline, not just the latest fact
Conventions evolve. The team rewrote the rule six months ago.
The agent learned the new version. The temporal layer keeps the
old fact too, marked as superseded, so an audit trail exists if
someone needs to retrace why a decision changed.
timeline.py python korely.add(
"We format with Prettier defaults.",
agent_id="team-acme-typescript",
valid_at="2025-09-01",
)
# Six months later, the team switches
korely.add(
"We format with Biome now, Prettier is removed.",
agent_id="team-acme-typescript",
valid_at="2026-03-15",
)
korely.search("formatter", agent_id="team-acme-typescript")
# → "Biome" (current). Prettier marked superseded.
korely.search("formatter", agent_id="team-acme-typescript", include_history=True)
# → full timeline: Prettier (2025-09 to 2026-03), Biome (2026-03 to now)
Frequently asked
Coding agent memory, common questions
Why does my AI coding assistant keep forgetting my project conventions? +−
Most AI coding assistants run inside a single chat session. When the session ends, every preference, rule, and learning resets. Adding memory means writing facts to a persistent store the agent can re-read at the start of the next session.
How is Korely different from .cursorrules or AGENTS.md files? +−
Rules files are static and global. Korely is dynamic and conversational: the agent itself decides what is worth remembering and writes it. The agent_id parameter scopes memory per repo or per team, so different projects don't bleed into each other.
Does Korely work with Cursor and Claude Code? +−
Yes. Korely ships an MCP server that Cursor, Claude Code, Continue, Cline, Zed, and any other MCP-aware client can connect to. One config snippet per client, then the agent reads and writes to the same vault.
Where is the data stored? +−
Plain Markdown files in a folder on your machine. You can grep them, edit them in any editor, commit them to a private repo, or move them to a USB stick. The Pro tier adds optional cloud sync between machines.
Can I use Korely for free? +−
The local MCP server and the desktop vault are free forever. The Python SDK and the cloud-hosted multi-tenant version are in early access — join the cohort to get them at launch.
Plug Korely into your editor, stop teaching the same lesson
The desktop app and local MCP server are free today.
The Python SDK and cloud MCP for multi-machine teams are in early access.
Looking for a different shape?
See the other five use cases →