Migration Guide

Omegon can import configuration and context from other AI coding tools. Run /migrate auto to detect and import from all recognized sources, or specify a source directly.

From Claude Code

/migrate claude-code

Imports CLAUDE.md project instructions into persistent project memory facts.

Concept Mapping

Claude Code	Omegon
CLAUDE.md	Project memory — persistent facts with semantic search, knowledge graph, episodic recall. Not a flat file.
Model picker	`/model` — 10 providers with tier-based routing and automatic failover
Extended thinking toggle	`/think off\|low\|medium\|high` — five levels, agent self-adjusts per task
Custom slash commands (.md)	12 skills — specialized instruction sets loaded on demand (git, rust, python, security, OCI, etc.)
Conversation history	Sessions — auto-save, `--resume`, full replay with segment metadata
Anthropic only	10 inference providers — Anthropic, OpenAI, Codex, OpenRouter, Groq, xAI, Mistral, Cerebras, HuggingFace, Ollama
—	Design tree — a structured knowledge graph of architecture decisions, open questions, dependencies, and implementation status. Nodes have typed lifecycles (seed, exploring, decided, blocked, deferred) and bridge directly into the spec and implementation system. Not a TODO list — a design exploration space.
Subagents (shared working directory)	Cleave — each child runs in its own git worktree on its own branch. File scope enforcement, dependency-ordered dispatch waves, per-file conflict detection (never bulk-resolved), and adversarial review. See Cleave vs Subagents.
—	OpenSpec — spec-driven development lifecycle (propose, specify, execute, verify, archive)
—	Personas — cognitive profiles with dedicated organic memory that grows across sessions
—	Instrument panel and live web dashboard over WebSocket
—	Secrets management — system keychain, HashiCorp Vault integration, encrypted storage
—	OCI tooling — first-class Containerfile authoring, multi-arch builds, registry auth, security scanning

What Transfers

Your muscle memory — read, edit, write, bash tools are identical
Anthropic OAuth — same /login flow, same credentials
Your prompting style — the agent responds to the same kinds of instructions

What's Different

Memory is a knowledge base, not a markdown file. Facts persist, get superseded, get archived. Semantic search finds relevant context without loading everything.
The agent actively manages its own inference — switching models, thinking levels, and context classes based on task complexity. You set policy; it executes.
Multi-file changes can be parallelized across git worktrees instead of executing sequentially.
Design decisions are tracked in a graph with typed relationships, not just discussed in conversation and forgotten.
Skills are specialized instruction sets (git conventions, security checklists, OCI best practices) that load contextually — not static markdown files you maintain by hand.

Design Tree in Practice

The design tree isn't theoretical — it's how Omegon itself is built. At any point you can see the state of every design decision in the project:

Design Tree: 267 nodes
  207 implemented — 10 decided — 32 exploring
  60 open questions — 18 deferred

Every node is a markdown file with structured sections: overview, research findings, decisions with rationale, open questions, and implementation notes with file scope. Nodes have typed relationships (dependencies, related work) and a lifecycle that bridges directly into OpenSpec for implementation. When a node reaches decided, one command scaffolds the full spec-driven implementation pipeline.

Claude Code has no equivalent. Design decisions live in conversation history and are forgotten when context fills up. CLAUDE.md is a flat file — it can't track the state of 60 open questions across 267 nodes, or tell you which decisions are blocked on which dependencies.

Cleave vs Subagents

Claude Code's subagents run child agents in the same working directory. Two subagents editing the same file produce race conditions. There's no isolation, no merge strategy, and no conflict detection.

Omegon's cleave orchestrator creates a separate git worktree for each child on its own branch. File scopes are enforced at plan time. Dependencies between children are declared and the orchestrator dispatches in waves. Merge happens per-file with conflict detection — the system never silently overwrites one child's work with another's. An optional adversarial review gate catches bugs and security issues before the merge lands.

See Cleave Orchestrator for the full comparison table and architecture diagram.

From OpenAI Codex CLI

/migrate codex

Imports AGENTS.md instructions and codex.json configuration into project memory.

Concept Mapping

Codex CLI	Omegon
AGENTS.md	Project memory + AGENTS.md support (both formats recognized)
OpenAI models only	10 inference providers — including Ollama for fully offline operation
Cloud-dependent orchestration	Fully local orchestration — cloud is only used for inference, and even that is optional with Ollama
Sandbox execution	OCI-based isolation available via the OCI skill — Containerfile authoring, multi-arch builds, registry auth, and security scanning are first-class. Plus secrets management through system keychain and HashiCorp Vault, so credentials never touch environment variables or disk in plaintext.
Single-turn execution	Multi-turn sessions with auto-save and resume. The agent maintains context across turns and sessions.
—	Parallel execution — cleave decomposes tasks into isolated git worktree branches with file scope enforcement, dependency waves, per-file merge, and adversarial review. Not shared-directory subagents.
—	Design tree — 267-node knowledge graph (in the Omegon project itself) tracking decisions, dependencies, open questions, and implementation status. Bridges directly into spec-driven implementation.
—	OpenSpec lifecycle — specs define correctness before code is written, verified after implementation
—	Project memory — persistent semantic knowledge base, not a flat file that gets stale
—	12 skills — specialized instruction sets for git, security, OCI, Rust, Python, TypeScript, etc.
—	Instrument panel and web dashboard for real-time session telemetry

Security Posture

Codex CLI relies on a cloud sandbox for execution safety. Omegon takes a different approach: the operator controls the execution environment, with tooling to make that environment secure.

OCI skill — first-class support for building and running containers. Containerfile authoring, multi-arch builds, registry authentication, image tagging, and security scanning are built into the agent's skill set. You can run the agent's work inside containers as a matter of course, not as an afterthought.
Secrets management — credentials stored in the system keychain (macOS Keychain, Linux Secret Service) or HashiCorp Vault. Never in environment variables, never in plaintext on disk. The agent manages secrets through /secrets and /vault commands.
Signed releases — every binary is signed with Sigstore cosign (keyless OIDC), includes a CycloneDX SBOM, and carries GitHub Attestations for build provenance. You can verify the supply chain from source to binary.
Process control — Esc or Ctrl+C cancels any operation immediately. --max-turns limits agent autonomy. Session logs provide full audit trail.

From Cursor / Aider / Continue / Windsurf

/migrate cursor   # or: aider
/init

These are IDE-integrated tools. Omegon is terminal-native by design. They're not mutually exclusive — use your IDE tool for inline completions and GUI diffs, use Omegon for the heavy lifting: architecture, multi-file refactors, parallel execution, design tracking, spec-driven development.

What You Gain

Persistent project memory that survives across sessions and tools
Parallel task execution via git worktrees with automatic merge and conflict detection
Design tree for tracking architecture decisions across the life of a project
Spec-driven development lifecycle with verification
10 inference providers with automatic routing and failover
No IDE dependency — works over SSH, in tmux, in CI, on any machine with a terminal
Secrets management and OCI tooling for production-grade security posture

From Earlier Omegon Versions

If you were using an earlier version, the Rust binary is a superset of all previous functionality. Project memory transfers directly — same format, same location.