Built different.
From the ground up.
NanX isn't a code editor with AI bolted on. Every layer — from the orchestration engine to the context manager to the inference runtime — was designed for one purpose: commanding AI entities that get things done the right way.
Conductor — Deterministic DAG Workflows
conductor-d is the orchestration engine at the heart of NanX. It doesn't just run AI calls in a loop — it executes structured DAG (Directed Acyclic Graph) workflows with deterministic execution, parallel fan-out, and crash recovery.
Wave-Based Parallel Execution
Independent steps execute concurrently in dependency-ordered waves. A search-and-read across 10 files happens in parallel, not sequentially. 77% fewer input tokens vs traditional ping-pong tool calling.
Checkpoint & Crash Recovery
State is saved after each wave. If NanX crashes mid-workflow, it resumes from the last checkpoint — not from scratch. Your entity picks up exactly where it left off.
Named Workflow Templates
Pre-built patterns (search_and_read, glob_and_read, parallel_fetch, find_and_replace, check_and_fix) the entity invokes with ~30 tokens instead of ~200. Zero syntax error risk.
No Embedded Runtime
No QuickJS, no Deno, no sandbox escape surface. Pure Rust data flow. Templates are declarative, not executable code. The attack surface is zero.
Progress Visibility
The UI shows step-by-step progress, parallel fan-out bars, timing per step. You see exactly what your entity is doing — not a spinner and a prayer.
Named workflow templates and conditional branching are shipping next. Plugin runtimes (Python/Node as workflow nodes) and container isolates are on the roadmap.
Quality Gates — Entities That Can't Ship Broken Code
Quality gates are a continuous check pipeline that blocks entities from proceeding until configured checks pass. No other AI coding tool does this. LSP can't do this. This is the difference between "AI that writes code" and "AI that ships correct code."
Gated Execution
Configure checks in .nanx/checks.toml. After every file mutation, diagnostics run automatically and results are injected into the entity's context. If checks fail, the entity must fix before proceeding.
Post-Mutation Hooks
Immediately after an edit, write, or shell command, diagnostics are appended to the tool result in the same turn. The entity sees its mistakes instantly, not three turns later.
Multi-Language Support
Rust (cargo check, clippy, cargo test), TypeScript (tsc, ESLint via Nx), Docker build, schema validation, security scanning (cargo audit), and custom scripts. Any command that returns an exit code can be a quality gate.
Trigger Modes
OnChange (file watcher), PostMutation (after tool calls), Manual (on demand), Interval (scheduled). Configure per check — heavy tests run less frequently, fast lint runs on every save.
Suggested Fixes
Diagnostics include machine-applicable fixes where available. The entity can auto-apply compiler suggestions without guessing.
Phase 1 (Diagnostic Service) is shipping. Phase 2 adds full LSP integration for editor intelligence. Phase 3 brings LSP-powered agent tools — goto_definition, find_references, rename_symbol.
Nanion Runtime — Purpose-Built for Ruthless Execution
Nanion Runtime is our flagship engine — not a wrapper around someone else's CLI. Built from scratch in Rust for the think → act → observe micro-loop that powers every entity session.
Think → Act → Observe
Each turn: build context → call LLM → process stream → execute tools → check context health → return result. Self-contained. Every runtime has its own tool registry, permission model, and session state.
Doom Loop Detection
When an entity makes the exact same tool call three consecutive times, NanX catches it and stops the loop. Automatic. No infinite spinning. No wasted credits.
Smart Context Management
Append-only conversation history preserves prompt cache (10x cheaper than tools that prune mid-conversation). Clean-cut compaction with iterative summarization when context grows. Pinned context (AGENTS.md, CONTEXT.md) survives across compactions.
Full-Stack Legibility
Everything is visible: tool calls, token counts, streaming state, permission decisions, context window contents. External wrappers like Claude Code are black boxes. Nanion Runtime is glass.
Error Classification & Recovery
Retryable errors (429, 503) get exponential backoff. Auth errors rotate to next profile. Context overflow triggers compaction. Content filters return refusals gracefully. Tool errors go back to the entity to decide.
Multi-Runtime — Your Choice, Always
Nanion Runtime is our primary investment. But during the alpha phase, NanX also supports Claude Code, OpenCode, and Codex as alternative runtimes — each running in a full PTY terminal. We believe in user choice.
Runtime Picker
Choose your runtime per session from the sidebar. Only enabled and installed runtimes are shown. Switch between sessions running different runtimes — each preserves its own state.
Claude Code
Anthropic's agentic coding CLI, running in a full PTY inside NanX. Gets the benefit of our IDE shell, file explorer, and tab system while using Claude's native execution model.
OpenCode
Open-source agentic coding CLI with multi-provider support. Full PTY integration. Great for users who want provider flexibility outside of our Omni system.
Codex
OpenAI's CLI agent, integrated as a PTY runtime. Access to OpenAI's latest models through their native execution flow.
Custom Tools via MCP
External runtimes get custom NanX tools via MCP server wrapper. Our tools (file search, diagnostics, workspace context) are available to every runtime, not just Nanion Runtime.
Crews — Coordinated Multi-Entity Execution
A crew is a named group of nanions with defined roles. One coordinator receives the task, delegates subtasks to specialists, and collects results. This is how NanX handles complex, multi-domain work — not by making one entity do everything, but by assembling the right team.
Coordinator + Specialists
The coordinator nanion receives the task, breaks it into subtasks, and delegates to specialist nanions. Each specialist runs its own micro-loop independently. Results flow back to the coordinator.
Parallel Fan-Out
The coordinator can spawn multiple specialists concurrently. A code review + test writing + documentation task runs as three parallel streams, not three sequential steps.
Context Isolation
Specialists get a curated context handoff — task description + relevant files. The coordinator does NOT share its full conversation. This prevents context explosion and keeps each entity focused.
Permission Isolation
Child nanions get restricted permission profiles. No recursive spawning by default. The coordinator controls what each specialist can do.
Session Continuity
Specialist sessions persist and can be resumed by ID. A code reviewer can be called back for a second pass without losing its earlier context.
Crew orchestration is designed and documented. Mesh (autonomous multi-nanion coordination without a central orchestrator) is the longer-term vision — self-organizing entity teams.
Context Management — Memory That Scales
Most AI coding tools either dump everything into context (expensive, degrades quality) or prune aggressively (loses important decisions). NanX uses a hybrid RLM + RAG architecture with append-only cache preservation and intelligent pre-LLM retrieval.
Append-Only Rule
Conversation history is NEVER modified between compactions. This preserves provider prompt cache — 10x cheaper per session than tools that prune mid-conversation. The single most impactful cost optimization in agentic development.
Clean-Cut Compaction
When context grows too large, a lightweight "compaction nanion" summarizes the old head while keeping the recent tail byte-identical. Goals, progress, decisions, and file operation history survive across sessions.
Three-Tier Search Engine
Structural search (AST-aware via tree-sitter), keyword search (FTS5 with trigrams), and semantic search (local embeddings, never leaves your machine) — all in a single SQLite file per project. The right retrieval for the right query.
Intelligent Pre-LLM Retrieval
Before every LLM call, NanX curates exactly what context the entity needs — pruning irrelevant history, injecting relevant code, and packing results into a token budget. The entity sees a focused, high-signal context window, not a sprawling dump.
EpicShelter Memory (Planned)
Powered by VISC's EpicShelter — a next-generation memory engine blending graph, relational, and vector storage with an adaptive query layer. Builds passively, like how humans learn. Persistent AI memory that evolves across sessions, projects, and teams.
Context engine Phase 1 (append-only + compaction) is live. Three-tier search and EpicShelter memory are in active development — more powerful retrieval and long-term memory are coming.
Omni-Lite (by VISC) — Local AI, Built in Rust
The same inference engine that powers omni.visc.ai — our cloud AI platform — running locally on your machine. Omni-Lite brings purpose-built, ground-up Rust inference to your desktop for plug-and-play, hot-swappable local AI.
Built in Rust, From Scratch
Not a Python wrapper. Not llama.cpp bindings. A native Rust inference runtime optimized for Apple Silicon Neural Engine and Metal GPU. Safety, security, and blazing fast execution — the same foundation as our cloud platform.
Plug and Play
Drop in a model, it works. No conda environments, no pip install, no CUDA version conflicts. Omni-Lite handles model loading, tokenization, and inference natively.
Hot Swappable
Switch models mid-session without restarting. Load a small model for fast completions, switch to a larger model for complex reasoning — seamlessly.
Intelligent Resource Management
Efficiently uses your machine's resources — memory-mapped model loading, intelligent layer offloading between CPU and GPU, and resource pooling across concurrent NanX sessions.
Intelligent Clustering
The dream: distribute inference across multiple machines on your local network. Your Mac Studio handles the heavy lifting while your MacBook Air serves as the command center.
Omni-Lite is in active development. Local inference, model management, and Apple Silicon optimization are the first milestones. Clustering is a longer-term vision.
The Surkyl Stack — Everything Connected
NanX doesn't exist in isolation. It's part of the Surkyl ecosystem — purpose-built infrastructure for concurrent agentic development, from inference to hosting to storage.
VISC AI
Provider-agnostic inference SDK. 7+ providers, streaming, retry with jitter, cost tracking, OAuth auto-refresh, MCP client. The entity never calls an LLM directly — VISC AI routes to the optimal model.
VISC Omni
Universal inference layer. Smart metering maps actions to credits based on actual compute cost. You choose actions, not models. Omni optimizes cost and quality automatically.
NanX Repos
Git hosting purpose-built for concurrent agentic development. Issues and PRs stored in-repo (zero lock-in), SSH TUI as primary interface, ACCID commit enforcement at the hosting layer, and nanion-powered code review. Your code, your metadata, portable forever.
Hypers
Rust HTTP framework for hosting. OpenAPI generation, health probes, rate limiting — all feature-gated. When NanX ships cloud features, Hypers powers the infrastructure.
MueFS
Content-addressable, deduplicating distributed file storage. Cloud sync, workspace snapshots, and NanX Repos storage — all powered by the same engine.
VISC Cloud
Compute hosting and database infrastructure. Cloud agent execution, session sync, workspace persistence — all running on Surkyl's own infrastructure. No third-party lock-in.
The Surkyl stack is being built layer by layer. VISC AI is live. NanX Repos, Hypers hosting, MueFS, and VISC Cloud are in various stages of development — each designed to work together seamlessly.