# Use Korium with OpenClaw

Use OpenClaw to look up a decision, work from it and save what changed. Another authorized assistant can then find that learning in the same Korium workspace. Start with an explicit request before adding automatic runs.

## Start with one trusted agent {#before}

You need an OpenClaw installation, a working agent and a Korium account. We have tested OpenClaw with Korium. This guide uses OpenClaw’s native outbound MCP connection; the examples below are workflow ideas, not preinstalled automations.

The connection gives this agent access to your authorized Korium workspace. Decide who can ask it to use that access before connecting a shared channel. Keep customer secrets, personal data and unrelated conversations out of the demonstration.

## 1. Add Korium and sign in {#connect}

Check for an existing connection first:

```
openclaw mcp list
```

For a new connection, run:

```
openclaw mcp add korium \
  --url https://api.kyroco.ai/mcp \
  --transport streamable-http \
  --auth oauth \
  --oauth-scope "engram.read engram.write offline_access"
openclaw mcp login korium
openclaw mcp probe korium
```

Complete the browser sign-in, then check the probe for Korium tools. Inspect an existing connection instead of duplicating it. Read-only use needs `engram.read`; saving also needs `engram.write`.

This is OpenClaw acting as a client. `openclaw mcp serve` does the reverse; the separate `mcporter` registry is not this setup. See [OpenClaw’s MCP reference](https://docs.openclaw.ai/cli/mcp) for the installed client’s options.

## 2. Prove a memory can cross conversations {#verify}

Open a fresh OpenClaw conversation. Ask it to use `agent_search` and identify the returned source memories, then follow [Your first memory](getting-started.html) to save the labeled onboarding example and keep its receipt.

In a fresh Codex, ChatGPT or Claude conversation connected to the same Korium workspace, ask for that example without pasting its text. Check the returned memory ID and explanation. Repeat the correction step to make sure the next answer uses the changed rule.

This proves the shared-memory path. It does not mean OpenClaw’s local memory files or old chat history were imported into Korium. Save or import the useful material deliberately.

## 3. Give the agent a clear memory habit {#habit}

OpenClaw loads workspace skills from `<workspace>/skills` and project agent skills from `<workspace>/.agents/skills`. Put a reviewed Korium skill and its supporting files in the chosen agent’s workspace; do not replace its existing instructions. See [OpenClaw’s skill loading rules](https://docs.openclaw.ai/tools/skills) and [the Korium starter toolkit](skills.html#starter).

Start by adding this rule to the agent’s task instructions:

```
Before this task, search Korium for relevant decisions and lessons.
Show the sources and distinguish recorded facts from your inference.
After the work, propose only the durable learning worth saving.
Keep decisions, suggestions and approvals separate.
Save authorized changes with their sources and show the receipts.
If nothing useful changed, do not create a memory.
```

Use the exact tool names shown by your connection. Test the rule in a new task and inspect the calls. A skill being present is not a guarantee that the agent searched or that a capture succeeded.

## Three useful workflows to build from here {#ideas}

These are recipes to adapt after the connection works. They require the relevant sources, permissions and instructions; connecting Korium alone does not schedule or run them.

### Keep the decisions from a meeting

Give OpenClaw an authorized transcript and ask it to compare the meeting with earlier project decisions in Korium. Have it propose what was agreed, what changed and what is still a question. Review that list, then save the agreed changes with the meeting as evidence.

### Prepare a brief before a client call

Ask for the last agreed scope, unresolved questions and promises that need follow-up. Require a source for each item and a separate list of anything the agent could not verify. Use the brief to prepare, not to invent an account history from a client’s name.

### Hand an engineering task to another assistant

Ask OpenClaw to save the approved problem statement, constraints and open questions. In Codex or Claude Code, retrieve that handoff and use Korium:Code to locate the implementation. At the end, save the tested result and remaining work so OpenClaw can retrieve it later.

Start with manual requests. If you add a scheduled run in your host, define the exact scope, who receives the result and which actions need approval. A scheduled search should not quietly turn into permission to publish or message other people.

## When the code index is behind {#stale-index}

If an OpenClaw agent searches code with `code_locate` and the checkout’s index is missing or behind, the answer says so and names the fix: run `korium-cli index` in the checkout, which indexes the branch the checkout is on. The answer carries this in its `next_step` field as well as in its warning, and Korium also says it in the instructions it sends when a client connects. korium-cli runs on a Mac that holds the checkout, so the agent can only do this itself when it runs there; otherwise pass the step to whoever does.

## Keep the access boundary real {#access}

A different chat or scope name does not create a separate Korium permission boundary. A bot using one account can expose whatever that account is allowed to read. Authorize the people who can reach it, limit its tools and review proposed writes.

OpenClaw treats a Gateway as one trust boundary. For mutually untrusted users or organizations, use separately isolated instances and credentials; a channel name is not tenant isolation. See [OpenClaw’s hosting guidance](https://docs.openclaw.ai/gateway/multi-tenant-hosting) and [Korium sharing and access](security-and-access.html).

## Find the failing step {#trouble}

`openclaw mcp status --verbose` inspects configuration; `openclaw mcp probe korium` connects. If tools are missing from the agent, inspect its MCP filters and tool profile: the minimal profile hides MCP tools. See [OpenClaw’s MCP diagnostics](https://docs.openclaw.ai/cli/mcp).

If authentication fails, use the named OpenClaw connection’s OAuth flow. Do not copy another client’s credentials or use `korium-cli login` to repair MCP memory access. If search succeeds but misses a known memory, check the workspace, scope and processing before saving another copy.

For a save or search result from Korium itself, use [the Korium troubleshooting guide](troubleshooting.html).