Meet Nx IDE.
Describe a coding task in plain English. Inside VS Code, Nx IDE plans it with you, writes it and checks it. With the Orchestrator (a team-lead mode), other specialists test and review it. Use the AI provider you choose, or a fully local model. By default, nothing changes without your approval.
Inside VS Code, Nx IDE appears as the Nexgile Code extension. Activated with a Nexgile license key.
Nx·Studio designs the digital workers that run your business. Nx IDE helps engineers build and extend the software around them. The Cognitive Engine takes over routine decisions once it has proved it gets them right.
See how the platform fits togetherAn AI engineering team in your editor.
You describe a task in plain English. Nx IDE reads your project, plans the work, edits files, and runs commands and tests. By default, it asks before it changes anything.
AI speed, without losing control.
Many AI assistants hand you suggestions to check yourself. Nx IDE splits the job between specialists. With the Orchestrator, one writes the change and two others test and review it. The agents are built to stop and ask before anything ships.
Teams that answer for their code.
Software teams in regulated or security-conscious organizations, and teams modernizing older systems. They get AI help with approvals, controls an auditor can check, and no lock-in to one AI vendor.
From request to reviewed change.
Here is what happens when you give Nx IDE a task, step by step. You decide how much it may do on its own.
Describe the task
Type what you need in plain English. Chats start in Code mode. Type / to switch to Architect, Debug, Chat or any of the 31 specialists. Type @ to point it at files, errors, terminal output, PDFs, or Word and Excel files.
Review the plan
For bigger work, switch to Architect. It writes a plan document. Comment on any part and the AI rewrites just that part. Nothing is built until the plan is approved, either by you or, at higher dial levels, after a countdown.
Approve, or let it run
By default, every change and command waits for your approval. The Delegation Dial (a five-step autonomy setting) and rules you write can let some actions run on their own. Before committing, pushing or deploying, the agents are built to stop and ask. For a hard stop at every dial level, add deny rules, which block an action completely.
Every step is saved
It saves checkpoints (snapshots of your files) as it goes. Compare or restore an earlier checkpoint in a click. A live meter shows the estimated cost and how full the AI's working memory (context) is.
It checks its own work
By default, when a task has changed files, it reviews its own changes and runs your build and tests. It then reports back with a summary of what it changed.
Any model. Your choice.
Connect the AI you already trust. Pick from 26 providers, from the major AI clouds to open-model hosts. Or run models entirely on your own machine. Switch at any time, with no lock-in.
Fully local, if you choose
Run models on your own hardware with Ollama, LM Studio or any compatible server. Your code never has to leave your building.
Use what you already pay for
Sign in with an existing chat-assistant subscription, or use the AI models that VS Code already provides.
Right model for each job
Each specialist remembers its own model, so planning, coding and reviewing can each use the best fit.
Keys kept safe
Your AI provider keys are kept in your operating system's secure vault, not in settings files.
Nothing is sent to Nexgile.
Your code goes straight from your editor to the AI provider you picked. There's no Nexgile cloud in the middle. The extension sends no usage data back to us, and even the license check happens offline.
No telemetry
Nx IDE sends no usage reports (telemetry). Nexgile never receives your code, your prompts or your usage data.
No middleman
Requests go directly to your chosen provider, or stay on your machine with a local model.
An edition for US government buyers
A separate TAA edition (for the US Trade Agreements Act) leaves out restricted providers and model families when it is built. They cannot be switched back on.
Ignore what's private
List files and folders in an ignore file (.nexgileignore) and the agents won't read them.
It knows how your code fits together.
Cortex builds a private map of your code on your machine. It shows which code calls which services, what a change might break, and how risky that is. The map updates as you work and covers older languages such as COBOL.
A map of your code
See flows, routes, subsystems and a change's impact before you make it. Built on your machine, with no network.
Legacy code, too
Reads COBOL alongside modern languages, so older systems appear on the same map.
Remembers your project
Keeps notes on your project between sessions and can look up what was decided in earlier chats.
Reads what you read
PDFs, Word and Excel files, and web pages. When enabled, it can also research other code repositories.
Guardrails that run underneath.
Beyond approvals, Nx IDE refuses unsafe writes and can limit where agents write. When enabled, your computer's own security stops their commands from changing anything outside your project.
Checkpoints
Checkpoints are saved as the agent works, and are on by default. Restore an earlier state in a click.
Clear boundaries
Rules can limit where agents may edit. Tasks started by automation can be locked to specific folders, enforced by the tools themselves.
An operating-system sandbox
Optional on macOS and Linux. Commands may change files only in your project and folders you allow, and can be cut off from the network.
No half-written files
It won't save a half-finished file. Writes that were cut off, or that skip code with “rest of the file unchanged”, are refused.
A specialist for every task.
31 built-in specialists, from Architect and Code to Tester, Reviewer and Shipper. Each one focuses on one part of the job. Add your own agents, skills and commands as simple files. Install skills and tool connections from built-in marketplaces.
31 built-in specialists
Ten core roles plus 21 ready-made experts for everyday work, from refactoring to database migrations.
Your own agents, as files
Define a custom agent in a short Markdown file. Your team tracks and reviews it like any other code change.
Skills & tools in one click
Install skills (reusable instructions) and tool connections from built-in marketplaces. Or write your own once and reuse them.
Follows your project's rules
Instruction files in your project (like AGENTS.md) tell every specialist how your team works.
One task. The whole team. Your sign-off.
Choose the Orchestrator and a coding task becomes a team effort. One specialist, or a small team, writes the change. Two others check it independently. A person decides whether it ships.
Independent checks
Tester and Reviewer start fresh. They get only the requirement and the changed files, never the writer's reasoning. Neither has file-editing tools.
Bounded retries
If tests fail or changes are requested, a fresh implementer tries again, up to twice. Then the decision comes back to you.
One Stop for everyone
One Stop button ends every agent in the chain at once. The agent map shows who is doing what.
Agent Manager
One screen to run several AI chats at once and watch each agent's progress, cost and questions.
Agent Teams
For larger jobs, 2–5 agents split the work, for example back end and front end. They message each other and share a task list while you watch.
/batch
Break a large change into up to 30 small tasks. Several run at once, each in its own copy of the code. If you choose, each becomes a draft pull request (a proposed change) on GitHub.
/review
A read-only review of your changes by up to five reviewers at once. Fixes start only when you pick them.
Shipper is instructed to save the work on a separate branch and never overwrite anyone else's. “Ship?” is an approval question. At Supervised and Trust Reads it always waits for you; at higher dial levels, add a deny rule if shipping must always wait for a person.
Built to work like change control.
The controls your change-management process already relies on, built into the agents themselves.
Human approval is on by default.
You write rules that allow, ask about or deny an action. Anything a rule allows shows which rule allowed it.
Before committing, pushing, deploying, migrating or deleting, the agents are built to stop and ask. Deny rules make it a hard stop at every dial level.
Your own scripts run at set moments. For example, one can require the linter to pass before a task counts as done.
No agent can edit your permission, hook or plugin files. The main agent asks before editing its own rule files.
The agents that test and review code have no file-editing tools.
Tool access, rules, hooks and the sandbox are enforced by the software. They are not just instructions the AI is asked to follow.
Speed alone isn't enough.
Your CISO (head of security) will ask three things. Who approved that change? What did it cost? Who was allowed to touch the code? Nx IDE answers all three.
Who approved that change?
A person did, or it ran under a setting or rule a person chose. Approval is on by default. Written rules and the Delegation Dial set what may run alone. Before commits, pushes or deployments, the agents are built to stop and ask.
What did it cost?
You see an estimate in real time. A live meter shows each task's cost. A Usage & Cost dashboard breaks spend down by day, model and project, with budget alerts. Optional limits pause an agent's work until you decide.
Who was allowed to touch the code?
Only what your settings and rules allowed. Your rules decide what is allowed, asked or denied, and deny rules bind sub-agents too. No agent can edit your permission or hook files. The tester and reviewer have no file-editing tools.
Most guardrails are settings or rule files. Your security team can read them, keep the rule files in your code repository, and map each one to the controls they already run.
Visit the Trust CenterAs hands-off as you want — never more.
One dial, right under the chat box, sets how much the agents may do on their own. Raise it one level at a time as your trust grows.
Good to know: checkpoints are on by default at every level. Above Supervised, sub-agents (agents started by another agent, such as the Orchestrator's specialists) run with every auto-approval switched on. Your deny rules still apply to them.
Supervised
You review every action before it happens.
Trust reads
Reading files inside your project runs on its own. Edits and commands still ask.
Trust edits
Reads and edits run on their own. The agent's routine questions, including plan approval, get their first suggested answer after a 60-second countdown. Commands still ask.
Trust execution
Reads, edits and commands run on their own, as do tool connections you have marked as always allowed. Starting sub-agents, edits to protected or outside-project files, and a few always-ask actions still ask. Deny rules still block.
Autonomous
Everything runs without asking, with three exceptions. Your deny rules still block. Edits to protected or outside-project files still ask, as do a few actions like fetching web pages.
Meet the specialists.
Ten core roles, each focused on one part of the job. The Orchestrator can bring several of them together on one task.
Architect
Plans and designs before any code is written.
Code
Writes, changes and refactors your code.
Chat
Answers questions and explains how things work.
Debug
Diagnoses and fixes problems, step by step.
Orchestrator
Runs a team: writer, tester, reviewer, shipper.
Tester
Independently verifies a change.
Reviewer
Gives an independent code review.
Shipper
Commits and pushes approved work.
Spec Bootstrap
Interviews you and writes a project wiki.
Spec Sync
Keeps the wiki in step with new commits.
Plus 21 ready-made specialists for everyday work
To add another, write your own in a short Markdown file and it appears in the list, for one project or for all of them.
From first idea to shipped software.
Nx IDE helps at each stage of building software. You decide how much it does on its own.
Plan & design
Plan the work before any code is written.
- A plan document you can comment on, part by part
- Draft the architecture up front
- Build and maintain a project wiki
Build & modernize
Write, improve and update your code.
- Write, change and refactor code
- Modernize older APIs, upgrade dependencies, translate code
- Work with older code, including COBOL
Test & verify
Catch issues before your users do.
- Generate tests for your changes
- Self-review and test run when a task ends
- An independent tester in every Orchestrator run
Review & ship
Independent review, then a controlled release.
- /review — up to five reviewers in parallel
- Every edit shown for your approval, by default
- Asks before it ships — to a feature branch
Understands your code
Context across your entire project.
- Cortex: a private map of flows, routes and impact
- Memory between sessions, and search across past chats
- Search by meaning, after a one-time setup
Connects to your tools
Works with the systems your team already runs.
- Add tool connections to other systems
- One-click tools and skills from built-in marketplaces
- Optional: opens the app it built on your machine to check it works
Stays in control
Speed inside boundaries you define.
- Approval on by default; the Delegation Dial for the rest
- Written allow / ask / deny rules, and hooks
- An optional operating-system sandbox
- A Usage & Cost dashboard with budget alerts
Works at scale
From one chat to many agents at once.
- Agent Manager: many chats side by side
- Agent Teams of 2–5 that coordinate
- /batch: up to 30 tasks, each in its own copy of the code
Works your way
Fits how your team already works.
- A checkpoint at every step — restore in a click
- Optional autocomplete and voice dictation
- Plain English → terminal command
- Chat in VS Code, or open it in a browser tab
What's new in Nx IDE.
- Teamwork
Agent Teams, Agent Manager and /batch
Run many agents at once and let small teams coordinate. Split big changes into parallel tasks, each with its own draft pull request if you choose.
- Planning
Plans you can review, and /review
A plan document you can comment on before anything is built, and a code review by up to five reviewers at once.
- Control
Written rules, hooks and a sandbox
Allow, ask and deny rules, your own checks at key moments (hooks), and an optional operating-system sandbox on macOS and Linux.
- Context
Memory, research and a cost dashboard
Project memory between sessions, reading web pages and documents, and a Usage & Cost dashboard with budget alerts.
- Models
Recent AI models
New models from the major AI providers, ready to choose from the model list.
What's on, what's optional.
Optional — off until you turn it on
- Operating-system sandbox (macOS and Linux)
- Per-task request and cost limits
- Web search and research in other code repositories
- Opening the app it built in a browser to check it (needs Chrome or Edge)
- Automatic note-taking for project memory
- Autocomplete, read-aloud, and voice dictation (dictation needs FFmpeg and a transcription key)
Needs a one-time setup
- Meaning-based codebase search
- Tool connections — add the ones your team uses, or install them from the marketplace
Ask us the hard questions.
Short, direct answers.
Will it act without my approval?
Not unless you let it. Approval is on by default. The Delegation Dial and your written rules set how much it may do alone. Turn the dial up and sub-agents (agents started by another agent) run without asking too, within your deny rules.
Can it run up a bill?
You see the estimated cost in real time. Daily and monthly budget alerts warn you but don't stop work. Optional per-task limits pause an agent until you decide.
Which models can we use?
Your choice of 26 providers (21 in the TAA edition), including fully local models. Your code never has to leave your building.
Does our code go to Nexgile?
No. There's no telemetry and no Nexgile cloud in between. Your code goes only to the AI provider you choose.