Coding agents

Codex

Give Codex memory that survives the session. One entry in config.toml connects the Korely MCP server over Streamable HTTP, no OAuth dance, no package to install, just your API key in a header.

Connect Korely's MCP server and, before answering, Codex can pull the active typed facts and relevant memories it has stored, and write new ones as it learns. The intelligence, entity and typed-fact extraction, contradiction resolution, bi-temporal validity, runs server-side. Codex just calls the tools.

Prerequisites

A Korely API key (kor_live_...). The hobby tier is free.
Codex CLI installed (codex --version). Remote Streamable HTTP MCP servers need a current build.

Add the Korely MCP server

Korely's agent memory is a remote MCP server at https://api.korely.ai/agent/mcp (Streamable HTTP), authenticated with your key in a header, no browser login. Codex reads the key from an environment variable at connect time, so export it first:

export KORELY_API_KEY=kor_live_...
codex mcp add korely \
  --url https://api.korely.ai/agent/mcp \
  --bearer-token-env-var KORELY_API_KEY

Or add it to ~/.codex/config.toml directly:

[mcp_servers.korely]
url = "https://api.korely.ai/agent/mcp"
bearer_token_env_var = "KORELY_API_KEY"

Then export the key in the same shell before launching Codex:

export KORELY_API_KEY=kor_live_...
codex

It's the env-var name, not the token. bearer_token_env_var takes the name of an environment variable, not the literal key. Codex reads that variable's value at connect time and sends it as Authorization: Bearer <value>. So export KORELY_API_KEY=kor_live_... must run in the same shell/session that launches Codex. The CLI command and the config.toml block are two ways to register the same server, use one, not both.

Save every session without asking. In the repository, run korely init --tool codex (korely-memory 0.1.26 or later): hooks hand Codex the repository's memory when a session starts and save the session to it as a memory of kind session. Trust the five korely hooks once in /hooks. It also writes a local [mcp_servers.korely] table to .codex/config.toml in the repository (~/.codex/config.toml with --global), replacing a korely table already there; with --no-mcp it removes that table and adds none. Without --global, that table goes into the repository's .codex/config.toml, which Codex reads ahead of ~/.codex/config.toml in a trusted repository, so there the local korely server takes the place of the remote one configured above. To keep the remote server, run korely init --tool codex --no-mcp. Codex loads the repository's .codex/ config and hooks only once you trust the repository. See Connect a coding assistant.

What Codex can do

Once connected, Codex has four memory tools:

Tool	What it does
`korely_get_context`	The recall path: assembles the active typed facts plus the most relevant memories into a prompt-ready block. Pure retrieval: the query is embedded once for the vector search, and no generative model runs on the read path.
`korely_add`	Store a memory. Typed `(subject, predicate, object)` facts are extracted server-side, and a model judge closes the earlier fact, with its end date, when it decides a new one replaces it.
`korely_search`	Semantic search over stored memories, ranked.
`korely_get_facts`	The typed bi-temporal facts known about a user, with point-in-time queries: `as_of` (what was true then) and `known_as_of` (what the store knew then).

Use it

Now Codex reaches for memory on its own. Tell it something durable and it calls korely_add; ask it something personal and it calls korely_get_context first:

You › Remember that this repo deploys to Hetzner, not Render.
      → korely_add("This repo deploys to Hetzner, not Render")

# next session, days later
You › How do we deploy this?
      → korely_get_context("deploy") → "This repo deploys to Hetzner..."
Codex › This repo deploys to Hetzner (you told me earlier), not Render. ...

Scoping

Every tool accepts an optional user_id so one key can serve many end users: a read that names "user-b" never returns a memory written for "user-a". Omit it on a write and the memory belongs to no end user (a key confined to one end user writes to that one). Omit it on a read and the read covers every end user the key can see.

Why this is more than a notepad. Korely keeps each memory's text as written and also extracts typed facts with bi-temporal validity from it. When something changes ("this repo now deploys to Hetzner, not Render"), the judge closes the old fact with its end date instead of overwriting it, so korely_get_context returns what's true now, and as_of can still replay what was true before. EU-hosted.

Server not detected? Upgrade Codex to a current build, then confirm KORELY_API_KEY is exported in the same shell that launches Codex.

Korely MCP, the full MCP surface and other clients.
Get context, the call behind korely_get_context.
Memory as a tool, the same pattern when you build the agent loop yourself.