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 framework that can call a REST API.
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 memory
Agents/Cursor/conventions
- Bi-temporal facts + text
- Indexed for hybrid search
Session 2 — Friday
Agent shows up informed
- Reads the convention before writing
- Suggests const, not let
One memory, 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
Install the SDK once and give the agent an API key. The SDK exposes
korely.add()
to write memories and
korely.search()
to retrieve them, along with hybrid search and graph traversal
over the full memory store.
When the agent learns something durable — a naming rule, a
file-layout convention, or a decision captured on a PR
comment — it calls korely.add()
scoped to an
agent_id
that identifies the repo or team. You can read it,
search it, or correct it over the API when the agent records
something wrong.
On the next session, the same agent searches the memory before it writes the next line. The relevant fact 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",
)
# ── 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 memory is reachable from any agent — Claude Code, Continue, n8n, LangGraph, or a
plain HTTP client. Scope memories with different
agent_id
values to keep each tool's knowledge separate and auditable.
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",
metadata={"effective_from": "2025-09-01"},
)
# Six months later, the team switches
korely.add(
"We format with Biome now, Prettier is removed.",
agent_id="team-acme-typescript",
metadata={"effective_from": "2026-03-15"},
)
korely.search("formatter", agent_id="team-acme-typescript")
# → "Biome" (current). Prettier memory marked superseded in the graph.
# Retrieve full history via the REST API:
# GET /v1/memories/{id}/history -> full timeline with effective_from metadata
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. Any agent running inside Cursor, Claude Code, Continue, or any other coding tool can call the Korely REST API or use the Python / Node SDK. One API key, then the agent calls korely.add() and korely.search() — the same memory is shared across all your tools.
Where is the data stored? +−
A managed cloud store in the EU — Postgres with a vector and graph index. Your agent reads and writes it over the REST API or the Python / Node SDK; nothing to host yourself. Export or erase everything with one call.
Can I use Korely for free? +−
Yes — there is a free Hobby tier: 1,000 memories a month on two agents. The Python and Node SDKs are live (pip install korely-memory / npm install korely-memory); sign up and get an API key instantly. Developer (€19) and Team (€79) raise the limits.
Plug Korely into your editor, stop teaching the same lesson
The Python and Node SDKs are live, and the Hobby tier is free.
Sign up, get an API key, and run the first memory write in minutes.
Looking for a different shape?
See the other five use cases →