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

What Transfers

• Your muscle memory — Omegon provides familiar read, edit, write, and bash operations, though schemas and permission behavior are Omegon-specific.
• Anthropic OAuth — use Omegon's /auth login anthropic flow; credential discovery and automation policy remain explicit runtime boundaries.
• 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: project-defined nodes
  seed → exploring → resolved → decided → implementing → implemented
  decisions, open questions, assumptions, dependencies, and implementation notes

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 cannot represent typed lifecycle state, unresolved assumptions, or dependency relationships across a project's design nodes.

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

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 configured through /secrets can be stored in supported secure backends such as the system keychain or HashiCorp Vault. Environment-variable credentials remain supported for provider and automation workflows; avoid plaintext project files.
• 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
• 16 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.