Meet Nx IDE.
An AI software engineer that works where your code lives. Describe what you need — a fix, a feature, a migration — and Nx IDE plans it, writes the code, runs the tests and shows you every change. By default it asks before it acts, works with the AI model you choose, and follows the rules you keep in your repository.
- 01 Implement Code
- 02 Test in parallel Tester
- 03 Review Reviewer
- 04 Ship? You
- 05 Push to a feature branch Shipper
Nx·Studio generates the digital workers that run your business. Nx IDE is there when you want to build or extend the software around them. The Foundation makes both predictable, explainable, and yours.
Start with the flagship: Nx·StudioAn engineer in your editor. You stay the lead.
Nx IDE pairs a capable AI agent with the controls a team lead would want. It explains, plans, codes, tests and reviews — but nothing changes without the permissions you give it, and every step can be undone.
Windows · macOS · Linux
Nx IDE desktop editor
Nexgile's code editor, built on the open-source VS Code foundation, with the Nexgile Code agent built in. The familiar layout, extensions and shortcuts — nothing extra to set up.
The editor you have
Nexgile Code for VS Code
Prefer to keep your current editor? The same agent installs into VS Code, alongside your existing settings and extensions.
Terminal · scripts
Nexgile CLI
The same agent in a terminal: chat with it interactively, or run it headless with machine-readable output for scripts. macOS, Linux and Windows.
A Nexgile licence, plus an account with an AI provider — or a model running on your own hardware. Nexgile hosts no model and collects no telemetry.
From request to reviewed change, in five steps.
Say you ask for a CSV export on your invoices page. Here is what happens next — and where you stay in charge.
Describe it
Say what you need in plain words — typed, or spoken if you turn voice on. Point it at files, folders, errors or terminal output with @, and paste screenshots.
“Add a CSV export to the invoices page.”
Agree the plan
In Plan mode it studies your code and writes the plan to a file. Comment on any part and it rewrites just that part — nothing is built until you choose how to go ahead.
plans/invoice-csv-export.md
Watch it build
It edits files and runs commands, asking first unless you've chosen to trust that kind of action. Every step is saved as a checkpoint you can compare or restore.
Checkpoint saved · 3 files
Check the work
When it's done it reviews its own change and runs the related build and tests. Want a second opinion? /review sends independent reviewer agents over the diff.
/review · uncommitted changes
You decide to ship
In Orchestrator mode an independent tester and reviewer check the change, then it asks “Ship?”. Only after your yes does it commit and push — to a feature branch, by design.
Ship? · waiting for you
What's new in Nx IDE.
The biggest additions of the last few months — every one of them in the current release.
Agent Manager
Every agent in one inbox: what's running, what's waiting on your approval, and which files each one changed.
Agent teams
Two to five agents split one job — a server and a client, say — and coordinate through shared messages and a shared task list.
/batch for big changes
One large change becomes up to 30 planned tasks, each in its own isolated branch, each checked and returned as a draft pull request.
Plan review
Plans are saved as files you can comment on. The agent rewrites just the part you flagged, then waits for your go-ahead.
Cortex code map
A local map of how your code fits together — impact, flows, hotspots and routes — now covering 46 languages, COBOL and PL/I included.
Permission rules, hooks and sandbox
Allow, ask or deny by rule; run your own checks at key moments; and on macOS and Linux, confine commands in an OS-level sandbox.
Usage & cost dashboard
Spend by day, model, project and mode, with daily or monthly budget alerts and a CSV export — all kept on your machine.
Memory, voice and the latest models
Project memory and chat recall, voice dictation, inline completions, a browser preview — and new models including Claude Opus 5.5 and OpenAI's GPT-6 family.
Bigger jobs get a whole team.
One agent is right for one change. For larger work, Nx IDE coordinates several — each with a narrow job, and you in the loop for every decision that matters.
Orchestrator
One request becomes a chain: a fresh implementer writes the change, an independent tester and reviewer check it in parallel, and you decide whether it ships. Retries stop at two — then it asks you.
Agent teams
For work with separate parts, two to five agents work side by side in the same project, messaging each other and sharing one task list.
/batch
Split one large change into up to 30 tasks. Each runs in its own copy of the repository and its own branch, is checked by your validation commands and a reviewer agent, and comes back as a draft pull request — or merged into one local branch.
Agent Manager
See every agent at once — running, queued or waiting on you — answer approvals inline, stop, resume or retry, and open each one's changes.
- Add CSV export to invoices Code
- Test plan: invoice export Tester
- Review: invoice export Reviewer
- Run database migration DB Migrator Wants to run a command Approve Reject
- Upgrade the logging library Dep Upgrade
/goal
Keeps working until a condition you set is met — checked by a separate judge model.
/btw
Ask a side question without interrupting the task in progress.
Fork
Branch a conversation into a second, independent one instead of rewinding.
Reload-safe
Background agents pick up where they left off after a window reload.
It reads the map before it changes the road.
Cortex builds a map of your codebase — what calls what, and what depends on what — right on your machine. The agent uses it to find the right code fast; you use it to see what a change will affect before anyone makes it.
Selected symbol
calculateInvoiceTotal()
- Direct callers4
- Affected files9
- API routes reached2
Rename with Cortex updates every reference in one undoable edit.
Built on your machine
Cortex indexes your project locally — no API key, no upload — and keeps the map current as you save, commit, pull or switch branches.
Know the blast radius
Before a change, see what depends on it and how risky it is, from low to critical — and rename a symbol across the codebase in one undoable edit.
See how it fits together
Subsystems, API routes and message queues, execution flows, hotspots, import cycles and unused code — in one panel.
Better context for the agent
The agent pulls the relevant code and call paths from the map in a single step, instead of reading file after file.
46 languages indexed — modern and legacy alike
Built for the code nobody wants to touch.
Seven one-click commands open a specialist for the job — and Cortex's support for older languages means legacy systems get the same care as new ones.
Translate code
Move code to another language structure-first — one target file per source file, same names and order.
Refactor code
Structural improvements and modern patterns, verified as it goes.
Generate tests
Test suites for existing code, aiming for high coverage.
Generate documentation
Technical documentation, created and kept up to date.
Security remediation
Reviews code for security issues and fixes them on request.
Modernize API
Moves legacy APIs and services to modern patterns.
Upgrade dependencies
Upgrades libraries, including fixing what the upgrade breaks.
Translating a Delphi unit to Java: one Java file per source file, in the same order, with untranslated code, kept bugs, performance concerns and behaviour differences marked TODO(port), BUG(port), PERF(port) and DIFF(port) for review — then compiled and, where safe, compared.
Taking over an undocumented codebase? Spec Bootstrap interviews you and writes a project wiki and rules, and Spec Sync keeps them current from your git history.
Built like change control, because it is.
The controls your change-management process already trusts — enforced by the product around the agent, not left to its good behaviour.
In the editor, approval is on by default — the agent asks before it edits a file or runs a command.
Permission rules decide which commands and tools run, ask or are blocked — and a project's rules can only tighten yours.
The agent's own settings, rules and editor configuration need their own approval — and .nexgileignore hides files completely.
Set a cost or request limit per task. When it's reached, the agent pauses and asks before spending more.
Every change is saved in a separate history — compare it, or restore the files and the conversation in a click.
The Tester and Reviewer get no file-editing tools, and the Shipper is built to push to a feature branch — pair it with branch protection on main.
Built-in guards
AvailableIt can't edit its own hook or permission settings, or skip your git checks with flags like --no-verify.
Hooks
AvailableRun your own scripts at 10 points in a task — block an action, require approval, or stop a task finishing on a failing build — as soon as you add them.
OS sandbox
OptionalOn macOS and Linux, confine the agent's commands to your project folder, with network access blocked unless you allow it.
Change control isn't a policy we ask the AI to follow — it's built around the agent, in the product itself.
As hands-off as you want — never more.
A five-step dial in the chat box sets how much the agent may do without asking. Turn it one step at a time — the built-in guards and any cost limits you set stay in force at every level.
Supervised
You review every action before it happens.
The defaultTrust Reads
File reads run automatically; everything else asks.
Edits & commands askTrust Edits
Reads and file edits run automatically; commands still ask.
Commands askTrust Execution
Reads, edits and terminal commands run automatically.
Guards & limits applyAutonomous
Everything runs automatically, inside the built-in guards and any limits you set.
Checkpoints to undoSpeed is table stakes.
The questions your CISO will ask: who approved that change, what did it cost, and who was allowed to touch the code? Nx IDE has an answer for all three.
Who approved that change?
You did — or a rule you wrote did. In the editor, approval is on by default; approvals granted by a permission rule name the rule that allowed them; and checkpoints keep a restorable history of every change.
What did it cost?
It's on screen. Each task shows its tokens and cost as it runs, the Usage & Cost dashboard breaks spend down by model, project and mode, and optional limits pause a task before it spends more.
Who was allowed to touch the code?
Only what you allowed. Permission rules govern commands and tools, protected files need their own approval, the Tester and Reviewer have no file-editing tools, and on macOS and Linux an optional sandbox fences commands into the project.
Every guardrail is a concrete setting or file. Your security team can map each one to the controls they already run.
A specialist for every part of the job.
Modes are focused roles, each with its own tools and limits. Ten core modes cover the everyday flow and twenty-one specialists take on particular jobs. Switch from the / menu — or add your own.
Code
Writes, changes and refactors code. New chats start here.
Architect
Plans first: studies the code, then writes a plan file and a to-do list.
Chat
Answers questions and explains code without changing anything.
Debug
Weighs likely causes, adds temporary logs and confirms with you before fixing.
Orchestrator
Runs the implement → test → review → ship chain, and never edits itself.
Tester
Writes its own test plan and runs it — with no file-editing tools.
Reviewer
Reviews the change independently and rates each issue by severity — with no file-editing tools.
Shipper
Commits and pushes approved changes to a feature branch.
Spec Bootstrap
Interviews you about the project and builds a project wiki and rules.
Spec Sync
Keeps that wiki up to date from your git history.
Plus 21 specialists
Or build your own
Describe an agent in one Markdown file in .nexgile/agents/ — it appears in the list at once, for one project or for all of them.
Bring the AI you trust — even fully local.
Nx IDE works with 26 AI providers. Use the accounts you already have, give each mode its own model, or keep everything on your own hardware with a local model.
Model makers
- Anthropic
- OpenAI
- Google Gemini
- xAI
- Mistral
- DeepSeek
- Moonshot
- MiniMax
- Z.ai
Your cloud
- Amazon Bedrock
- Google Vertex AI
Gateways
- OpenRouter
- Vercel AI Gateway
- Requesty
- Unbound
- LiteLLM
- Poe
Open-model hosts
- Fireworks
- Baseten
- SambaNova
Sign in with a plan
- ChatGPT Plus / Pro
- Qwen Code
- VS Code LM API
Local or custom
- Ollama
- LM Studio
- OpenAI-compatible (incl. Azure)
Recently added: Claude Opus 5.5, Sonnet 5.5 and Fable 5.1, and OpenAI's GPT-6 family.
- Give each mode its own model — a careful one for planning, a fast one for edits.
- API keys stay encrypted in your editor's secret storage.
- Model usage is billed by your provider, at your rates. Nexgile hosts no model and sends no telemetry.
- A separate TAA build leaves out China-based providers and models, for organisations that require it.
Fits the way your team already works.
Connect your tools, teach it your standards, and turn on the everyday helpers you want. Your configuration lives in files in your repository — versioned and reviewed like everything else.
MCP tools & marketplace
Connect tools and data over the Model Context Protocol. Browse the official MCP Registry and Smithery in the product, and limit which servers each mode may use.
Skills
Package know-how as reusable skills — from the built-in store or any GitHub repository.
Custom agents & modes
Describe a new agent in one Markdown file in your repository. It joins the mode list at once — for one project or all of them.
Rules as files
Your standards live in your repository — AGENTS.md and rule files, versioned and reviewed like code. /init writes a starter AGENTS.md.
Slash commands
Save your team's prompts as commands, alongside built-ins such as /review, /goal and /batch.
Plugins
Add custom tools and adjust the agent's behaviour with typed plugins. A project's plugins run only after you approve them.
Everyday helpers
- Available
Project memory & chat recall
Remembers facts about your project (never secrets) and can search your past conversations.
- Available
Reads your documents
PDF, Word, Excel and notebook files can be added to a conversation as text.
- Available
Terminal help
Generate a command from a description, or explain and fix one that failed.
- Available
Learning mode
An output style that explains as it goes — or leaves small pieces for you to write.
- Optional
Inline completions
Ghost-text suggestions as you type, plus an optional “predict my next edit”.
- Optional
Voice
Dictate requests by microphone, and have answers read aloud.
- Optional
Browser preview
Open your locally running app; the agent sees a screenshot and the console, and you can point at an element.
- Optional
Web search
Fetching a web page is built in and asks first; web search works with your own search-provider key.
What's on, what's optional, what's next.
We'd rather you know exactly what you're getting. Here is the current release, feature by feature.
On from the start
Switched on in the current release.
- Chat and 31 built-in modes
- Approvals and the Delegation Dial
- Checkpoints and one-click restore
- Orchestrator, agent teams and Agent Manager
- /batch, /review and /goal
- Plan files and plan review
- Cortex code map
- Project memory and chat recall
- MCP and skills marketplaces
- Usage and cost tracking
- Custom modes, agents and rules
- Permission rules, hooks and plugins — once you add them
Switch on when you need it
Built in — turned on in Settings, some with your own key or tool.
- Semantic code search (with a Qdrant database)
- Web search (your own search key)
- Browser preview panel
- Inline completions
- Voice dictation and read-aloud
- OS sandbox (macOS and Linux)
- Cost limits and budget alerts
Early access
Pre-release — ask us about access.
- Nexgile CLI — the agent in your terminal
In development
Built, but not yet active in the current release.
- Security scanning of the code the agent writes, with a companion security pack
Ask us the hard questions.
Short answers, no hedging.
Q Is Nx IDE a new editor, or something I add to mine?
Either. The Nx IDE desktop editor for Windows, macOS and Linux comes with the agent built in. The same agent also installs into VS Code, and the Nexgile CLI brings it to the terminal (in early access).
Q Will it change things without asking?
Not in the editor, unless you let it: approval is on by default there, the Delegation Dial lets you trust reads, edits or commands one step at a time, and checkpoints let you undo any step. The early-access CLI is built for scripted runs, so it approves automatically unless you start it with --require-approval.
Q Does our code leave our machines?
Only to the AI provider you choose — and with a local model through Ollama or LM Studio, it can stay on your own hardware. Cortex builds its code map on your machine, and Nexgile Code sends no telemetry.
Q Which AI models can we use?
Any of 26 providers — Anthropic, OpenAI, Google, Amazon Bedrock, Azure through an OpenAI-compatible endpoint, OpenRouter, and local models among them. You bring your own account, and usage is billed by your provider.
Q Which programming languages does it handle?
The agent works with any language your chosen model understands. Cortex, its code map, indexes 46 languages — from TypeScript, Python, Java and C# to COBOL, JCL, PL/I and ABAP.
Q What do we need to get started?
A Nexgile licence and an account with an AI provider — or a model running on your own hardware. Optional features list anything extra they need in Settings.
Q Is the interface available in other languages?
The interface is in English. The agent replies in the language you write to it in.
Start with the workforce. Extend with the IDE.
Nx·Studio generates the digital workers that run your business — delivered as code you keep. Nx IDE is the AI coding agent your engineers reach for to build and extend the software around them.
You generate it. You preview it. You own it. You run it.