# How to migrate from OpenClaw to open-source Kortix

description: Move the skills, memory and connectors you built in OpenClaw into one git repo you own, where open-source Kortix runs the company's agent work.

To migrate from OpenClaw, you re-home what you built on one machine into a git repo a company owns: Kortix is the open-source AI Operating System that runs that repo as the company's agent work, and it puts a human review gate in front of every change. OpenClaw is a self-hosted open-source AI assistant that runs on your own computer and meets you in the chat channels you already use; it is MIT licensed and stewarded by the [OpenClaw Foundation](https://openclaw.ai), an independent nonprofit. Both projects agree that you should own your agents and your data. They differ on scope: OpenClaw is built around one Gateway serving a personal or shared-team assistant, while Kortix is built around a project repository whose agents, skills, memory and connector config are files, with each session running on its own isolated machine.

Kortix is open source (Elastic License 2.0): self-host, read and modify the code. That matters for a migration because everything you move in lands in a repo you can clone, grep and diff yourself.

A migration from OpenClaw to Kortix is mostly a re-homing. Skills are markdown on both sides, memory is markdown on both sides, and the tools you wired up become connector entries. You gain version control over the configuration and a review step between an agent's work and the main branch.

## What carries over, and what changes

| In OpenClaw | In Kortix | What you do |
|---|---|---|
| Skills and plugins | `skills/<name>/SKILL.md` | Move the markdown in and grant it to an agent. |
| Agent personas and prompts | `agents/<name>.md` plus a manifest entry | Move the prompt and declare the agent's access. |
| Memory files | `memory/` in the repo | Copy `MEMORY.md` and the dated notes across. |
| Channels and tools | Connectors in `kortix.yaml` | Reconnect chat apps and declare the apps you use. |
| Model access | Per agent, session or message | Add your provider key or ChatGPT plan. |
| One local Gateway | One sandbox per session | Sessions run isolated, each on its own branch. |

A few shape changes are worth knowing before you start. OpenClaw keeps its settings in a local file, `~/.openclaw/openclaw.json`, and its state on your own hardware. Kortix keeps the equivalent in a `kortix.yaml` manifest plus files in the repo, so a configuration change is a commit someone reviews. OpenClaw connects chat apps through channel plugins; Kortix routes chat through channel connectors and reaches the rest of your tools the same way.

## Migration steps, in order

1. Create the project repository. Install the CLI with `curl -fsSL https://kortix.com/install | bash`, then run `kortix login`. `kortix init my-app` scaffolds a directory with a `kortix.yaml` manifest and starter `agents/` and `skills/` folders, and `kortix ship` creates the cloud project and pushes the code. If the repo already exists, `kortix projects link <project-id>` attaches it instead. The [Kortix quickstart](https://kortix.com/docs/quickstart) shows the full loop.

2. Move skills first. A Kortix skill is a markdown file at `skills/<name>/SKILL.md`, and an agent's `skills` grant in `kortix.yaml` controls which skills it may load. OpenClaw skills are markdown too, so the work is placing the file in the repo and granting it to the right agent. Move skills before agents because the agent entry names the skills it uses. The [agents and skills reference](https://kortix.com/docs/project/agents) covers the layout.

3. Move agents and prompts. A Kortix agent is a markdown file, `agents/<name>.md`, whose frontmatter sets the model and tools and whose body is the system prompt. The manifest's `agents:` block sets governance only: which connectors, secrets, skills and Kortix permissions each agent may touch. Version 2 of the manifest is deny-by-default, so grant every permission an agent needs by name. The [manifest reference](https://kortix.com/docs/project/manifest) lists the fields.

4. Move memory. OpenClaw remembers by writing plain markdown in its workspace, including `MEMORY.md`, `USER.md` and dated notes under `memory/`. Kortix stores the project's memory in a `memory/` directory in the repo, so the same markdown moves across with little change. What changes is that the company's memory is now shared and versioned, and edits to it land through review like any other file. OpenClaw's [memory overview](https://docs.openclaw.ai/concepts/memory) documents its files.

5. Reconnect channels and tools as connectors. Connect Slack, or Microsoft Teams where the operator enables it, and declare the apps you use in `kortix.yaml`. Kortix reaches 3,000+ apps plus any MCP, OpenAPI, GraphQL or HTTP API through one scoped token, with credentials brokered server-side so they never enter the sandbox. The [connectors overview](https://kortix.com/docs/connect/connectors) explains the model.

6. Set models and keys. Kortix resolves a model per agent, per session or per message, so you can bring your own provider key or connect the ChatGPT plan you already pay for. OpenClaw's model configuration becomes a provider key or a managed model here. If OpenClaw's scheduled tasks were doing real work, recreate them as cron or webhook triggers in the manifest, where a trigger starts a session with nobody present. The [models page](https://kortix.com/docs/project/models) and the [triggers page](https://kortix.com/docs/connect/triggers) cover both.

## Turn on the review gate

The review gate is the part that changes how work reaches the company. Every Kortix session runs in a sandbox on a branch named after the session, and the agent commits there and pushes. When it is done, the agent opens a change request, and a change request is the only way work reaches the default branch. That rule covers code, agents, skills and the manifest.

Review runs from the terminal. `kortix cr ls` lists open change requests, `kortix cr diff <cr>` shows the unified patch, and `kortix cr merge <cr>` lands it. Merge is default-deny for agents, and a session can never merge a change request it opened itself, so the human decision to merge is built into the system. The [change requests reference](https://kortix.com/docs/work/change-requests) documents the contract.

## What to keep in OpenClaw

OpenClaw is good at the personal-assistant job and stays the right tool for it. If you still want an assistant on your own machine that answers in WhatsApp, Telegram, iMessage or Discord, keep OpenClaw for that. The two can run side by side: OpenClaw for personal work, Kortix for the company's work, with separate repos and keys. Keep OpenClaw where it earns its place, and let the company repo hold only what the company must own and review. The detailed [Kortix vs OpenClaw comparison](/kortix-vs-openclaw.html) covers where each one fits, and the [alternatives guide](/openclaw-alternatives.html) places both against the other options.

## Start

Three commands take you from nothing to a merged change request: `curl -fsSL https://kortix.com/install | bash`, then `kortix init`, then `kortix ship`. Create a project at [Kortix](https://kortix.com), or self-host the same stack with `kortix self-host start`; the [self-hosting guide](/self-host-openclaw-alternative.html) walks through it. If you want the side-by-side first, the [Kortix](https://kortix.com/blog/kortix-vs-openclaw) breakdown against OpenClaw lays it out.