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` - provider-neutral intent or an exact concrete route pin, with explicit selected and serving route state
Extended thinking toggle	`/think off\|minimal\|low\|medium\|high` — five explicit levels
Custom slash commands (.md)	11 skills — specialized instruction sets loaded on demand (git, rust, python, security, OCI, etc.)
Conversation history	Sessions with explicit full, mixed, or legacy lineage. Full semantic history resumes exactly; imported history remains a labeled compatibility base followed by an exact suffix.
Anthropic only	Contribution-backed provider routing with provider-specific authentication and explicit compatibility boundaries
—	Design tree — a structured knowledge graph of architecture decisions, open questions, dependencies, and implementation status. Nodes follow the lifecycle `seed → exploring → resolved → decided → implementing → implemented` and bridge into specification and implementation work.
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 — 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

Codex CLI	Omegon
AGENTS.md	Project memory + AGENTS.md support (both formats recognized)
OpenAI models only	Multiple contribution-backed routes, including local and separately authenticated hosted paths when configured and executable
Cloud-dependent orchestration	Fully local orchestration — cloud is only used for inference, and even that is optional with Ollama
Sandbox execution	OCI-based isolation is available when the sandbox runtime is configured. Provider credentials can come from secure stores or environment variables; avoid plaintext project files.
Single-turn execution	Multi-turn semantic sessions with lineage-aware resume. Exactness is claimed only for authority-backed full history or the semantic suffix of mixed history.
—	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 — structured knowledge graph 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
—	11 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 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 requests cancellation immediately; terminal closure follows owned cleanup. --max-turns limits agent autonomy. Session records support later inspection.

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
Provider-neutral model intent, exact route pinning, and fallback only through explicit policy and directed compatibility
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

Project memory transfers directly. Schema-v1 session pairs remain readable as a compatibility import source. When Omegon opens a valid pair beside pre-boundary authority, it stores the model-facing legacy context once as a content-addressed block and establishes mixed lineage before new semantic work.

The imported base is labeled compatibility context, not reconstructed historical authority.
New committed work forms an exact semantic suffix; exact full-session transcript export remains unavailable.
After import, Omegon no longer requires or rewrites the pair. Existing files are left in place.
Old binaries must not write a reduced event set after the full-spine boundary. There is no rollback-to-old-writer mode.
Unsupported event, reducer, cursor, projection, or host-store schema versions require an explicit versioned migration rather than silent field reinterpretation.

See Sessions for resume and export semantics andRecovery for fail-closed store handling.