Meet Nx IDE.
An AI engineering team inside the editor you already use. You choose the AI models, including fully local ones. It works under your approvals, your budgets and your repo’s rules.
What Nx IDE is — and isn’t.
You don’t need to write software to understand it. Three sentences cover it. The rest of this page shows the detail.
An AI assistant for the people who build your software.
It lives inside their code editor. They ask in plain English: fix this bug, add this feature, explain this old program. It reads the code, proposes the change, and makes it once they approve.
Most software work is reading, checking and repeating.
Nx IDE takes on that load: finding its way around a large codebase, writing and testing changes, keeping documents current. Your engineers spend their time deciding, not typing.
It is not an autopilot.
Nothing is changed, run or sent without a permission you gave. Every change can be undone. And the AI models it uses are the ones you choose — including ones that run only on your own machines.
Ask, check, approve, keep.
The same four steps whether the job is a one-line fix or a month-long modernization.
Ask in plain language
Describe the outcome you want. Attach a screenshot, a PDF, a spreadsheet or a ticket if it helps.
See the plan first
For bigger jobs it writes a plan you can read and comment on before any code changes.
Approve what it does
Reading files, editing files, running commands, calling other tools. You decide which of these need your approval.
Keep it, or undo it
Every change is saved as a snapshot as it happens. Compare before and after, and roll back in a click.
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·StudioAny model. Your choice.
Connect the AI models you already trust: 26 providers are supported out of the box. Each kind of work can use the model that suits it best. That includes models that run entirely on your own machines, so your code never has to leave your building.
Fully local, if you choose
Run private and on-device models — your code never has to leave your building.
Right model for each job
Give each role its own model: a stronger one for planning and review, a faster one for routine edits. Switch any time.
Standards as files in your repo
Your standards live as files in your repo, not as settings on our servers. They are versioned, compared and reviewed like any other change.
Keys kept safe
Your model credentials are held in your editor's encrypted secret storage — not in project files.
A specialist for every task.
31 built-in roles, each limited to the tools its job needs. Ten are core roles such as Architect, Code, Debug, Tester, Reviewer and Shipper. The other 21 are ready-made specialists for work like refactoring, security review and dependency upgrades.
31 built-in roles
From planning and architecture to coding, testing, reviewing and shipping — a focused expert for every step.
Write your own in a text file
Describe a new specialist in one file in your repository: its job, its rules, its permissions. The whole team then has it.
Reusable skills & commands
Bundle your team's routines into commands anyone can run in one keystroke. A built-in marketplace offers ready-made skills.
Clear boundaries
Each role's permissions are enforced by the tool itself: the planner can only write documents, and the tester and reviewer are given no editing tools.
A team, not a lone assistant.
Choose how much help a task gets: one AI agent, a chain of agents with independent checks, or several agents working side by side. You can see and stop them all from one place.
Build, test, review, ship
The orchestrator hands work to an implementer, then to an independent tester and reviewer. It asks you before anything ships.
Many agents, one console
The Agent Manager runs several conversations at once across your projects, with an inbox for the questions that need you.
Split big jobs safely
A large change is divided into tasks that run in parallel, each on its own isolated copy of the code. They come back as separate changes to review.
Agents that talk to each other
Small teams of two to five agents share a task list and message one another while they work.
You set the boundaries.
Detailed controls let the agents move fast inside boundaries you set: approved actions, blocked actions and spending limits. Every change they make can be undone.
Detailed approvals
Decide exactly which kinds of action run automatically and which need your sign-off — all behind one master switch.
Allow, ask, deny
Write rules for commands and files: always allowed, always asked, never allowed.
Limits that stop the work
Set a cost and request limit per task. When it is reached, the agent stops and asks before going further.
A snapshot at every step
Every change is saved as a snapshot automatically, separate from your own version history. Restore any earlier state in a click.
It maps your code first.
Before it changes anything, Nx IDE builds a map of your code on your own machine: what calls what, and what depends on what. That map, and a memory of your project, keep its answers grounded in how your system really works.
A map of your whole codebase
Cortex maps the code and its connections on your own machine, with no account and no upload. It keeps itself current as the code changes.
Remembers your project
Decisions and conventions are saved as project memory and recalled in later sessions. Past conversations are searchable.
Reads more than code
PDFs, Word documents, spreadsheets, notebooks and screenshots can all be read as part of a task.
Connects to your tools
Link issue trackers, source control and internal services through an open connector standard, with permissions per tool and a built-in marketplace.
See the system before you change it.
Most mistakes in software come from not knowing what else a change touches. Cortex answers that before the change is made — for people and for the agents alike.
What breaks if we change this?
Pick any piece of code, or a set of pending changes. See everything that depends on it, the tests that cover it, and how risky the change is.
How does a request travel through the system?
Flows trace each entry point, such as a web request or a scheduled job, step by step, down to the database write or the reply.
Where is the system fragile?
Hotspots show the code everything else leans on. Checks find circular dependencies and breaches of the layering rules you set.
How do the parts fit together?
Subsystems are worked out from how the code actually connects, not from folder names. You also get a readable architecture report.
Can we rename this safely?
Renames follow the map, so every caller is updated, and you see the impact before you confirm.
Does it understand our older systems?
Alongside modern languages, Cortex reads COBOL, JCL, ABAP, PL/I, Visual Basic 6 and Perl — the code many modernization programs start from.
The map is built on the developer’s own machine, from the code itself. Nothing is uploaded, and no AI model is needed to build it.
Built like change control, because it is.
The controls your change-management process already trusts — enforced in the agents themselves.
Human approval is on by default.
Commands and files are checked against allow, ask and deny rules you define.
A task can carry a cost limit. When it is reached, the work stops and asks.
The files that steer the agents — their rules, roles and settings — ask for your approval even when other edits run automatically.
An agent that starts repeating itself is stopped and has to ask.
The agents that test and review a change are given no editing tools.
Change control isn’t a policy we ask the AI to follow. Each role’s permissions are enforced by the tool itself.
Speed is not enough.
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 it didn't ship. Approval is on by default and you decide exactly which actions run automatically. In orchestrator mode an independent reviewer reads the change, and the agent asks you before anything is shipped.
What did it cost?
What you allowed it to. A task can carry a cost and request limit. When it is reached, the work stops and asks. A usage dashboard shows spend by day, model, project and role, with budget alerts.
Who was allowed to touch the code?
Only the agents you permitted. Allow, ask and deny rules control commands and files. Each role has a fixed set of tools, and the roles that test and review are given no editing tools.
Every guardrail is a concrete policy. Your security team can map each one to the controls they already run.
Visit the Trust CenterOne task. The whole team. Your decision.
Hand a task to the orchestrator and it is built by one agent and checked by two others. These are checks a single pass would miss. Only then does the question of shipping reach you.
Independent tester & reviewer
Separate agents verify and review the change. The tester works from the requirement, the reviewer from the change itself, and neither has editing tools of its own.
Retries, then escalates
If the tester or reviewer rejects the work, it goes back for another attempt — twice at most. After that, it comes to you.
One Stop button
Stop halts the whole chain at once — not just the agent that happens to be working.
The orchestrator runs only when you pick it. In every other mode a single agent does the work directly. Ask for a separate review whenever you want one.
As hands-off as you want — never more.
Move the agents up the ladder one step at a time. Every level stays inside the boundaries you set, with your approvals and limits in force.
Chat
Answers questions and explains your code. Never makes a change.
Read-onlyPlan
Designs the approach and writes it up as a plan you can comment on before anything is touched.
You approve the planBuild
Writes, edits and refactors code — within the approvals and limits you set.
Approvals & spend limitsOrchestrate
Builds, tests and reviews independently, then asks before shipping — inside the same approvals and limits.
Independent checks + rollbackMeet the specialists.
Each specialist focuses on one part of the job, and they work together so nothing gets missed.
Architect
Plans and designs before any code is written.
Code
Writes, modifies and refactors your code.
Chat
Answers questions and explains how things work.
Debug
Diagnoses and fixes problems, step by step.
Orchestrator
Coordinates the whole team across a task.
Tester
Independently verifies every change it is given.
Reviewer
Gives an independent code review.
Shipper
Commits and ships approved changes.
Spec Bootstrap
Writes the documentation for a new project.
Spec Sync
Keeps existing documentation in step with the code.
Plus 21 ready-made specialists for everyday work
New since the summer.
Nine additions since this page was last updated — all available in the product today.
Cortex code map
A local map of your codebase: impact of a change, request flows, fragile spots, architecture report.
Agent Manager
A full-screen console for running several agents at once across your projects.
Agent teams & parallel batches
Agents that collaborate, and large changes split into isolated, parallel tasks.
Plan review
Plans arrive as a document with a review card. A comment rewrites only the part it is on.
Project memory
Conventions and decisions are remembered between sessions; past chats are searchable.
Permission rules, hooks & plug-ins
Allow / ask / deny rules, your own checks at key moments, and plug-ins that add to what the agents can do.
Usage & cost dashboard
Spend by day, model, project and role, with daily and monthly budget alerts and export.
Connector & skill marketplaces
Browse and install connectors and skills without editing configuration by hand.
Document reading
PDF, Word, spreadsheet and notebook files can be read directly in a task.
From first idea to shipped software.
Nx IDE handles every part of building software — and keeps you in control the whole way.
Plan & design
Think it through before a single line is written.
- Turn requirements into a written plan you can comment on
- Draft the architecture up front
- Create project documentation and keep it in sync with the code
Build & modernize
Write, improve and bring your code up to date.
- Write, modify and refactor code
- Modernize older interfaces and translate code between languages
- Upgrade dependencies with the impact worked out first
Test & verify
Catch issues before your users do.
- Generate tests for existing code
- Re-check its own work and run your build and tests after each task
- Independent testing in orchestrator mode
Review & ship
An extra review, then it ships.
- Independent code review, with several reviewers in parallel if you want
- Security review, with fixes on request
- Commit and ship only when you say so — never straight to your main branch
Understands your code
Takes your whole project into account.
- A local map of the whole codebase, kept up to date automatically
- Shows what a change would affect before it is made
- Stays focused in long sessions by summarizing as it goes
Connects to your tools
Works with the systems your team already runs.
- Connect issue trackers, source control and internal services
- Per-tool permissions you control
- Reads web pages you point it at, and errors from your editor
Works as a team
More than one pair of hands.
- Run several agents at once from one console
- Split a large change into isolated parallel tasks
- See every agent's status and cost, and stop any of them
Stays in control
Speed inside boundaries you define.
- Approve actions automatically or one by one
- Allow safe actions, block risky ones
- Cost and request limits that pause the work
- Spend dashboard with budget alerts
Recover anytime
Move fast without fear.
- Automatic snapshots at every step
- Roll back any change in a click
- Compare any two points to see exactly what changed
On, optional, or on the way.
We would rather you knew now. Here is how each capability stands in the product today.
On from day one
Ready the moment it is installed.
- 31 built-in roles and your own custom roles
- Orchestrator, Agent Manager, agent teams and parallel batches
- Cortex code map and project memory
- Approvals, permission rules and automatic snapshots
- Usage and cost dashboard
- Connector and skill marketplaces
There when you switch it on
Included, but off until you choose it.
- Meaning-based search (needs a search index you host)
- Web search and a built-in browser panel for your own app
- A locked-down sandbox for commands — macOS and Linux only
- Type-ahead code suggestions
- Voice dictation, spoken read-out and sound alerts
- Chat in a browser tab on your own machine
Still being built
In the code, not yet something to rely on.
- A command-line edition (preview)
- Offline security scanning of changes as they are written
- Predicting your next edit
- Image generation and custom tools (experimental)
Ask us the hard questions.
Short answers, no hedging.
Will it act without my approval?
No. Approval is on by default, and you choose exactly what to delegate.
Can it go over budget?
Set a cost limit on a task and the work stops and asks when it is reached. A dashboard tracks spend and alerts you against the budgets you set.
Which models can we use?
Yours to choose — 26 providers are supported, including fully local models, so your code never has to leave your building.
Do we have to change how we work?
No. It runs inside the code editor your developers already use, and your standards stay as files in your own repository.
Start with the workforce. Extend with the IDE.
Nx·Studio generates the digital workers that run your business, delivered as source code you keep. Nx IDE is what your engineers use to build and extend the software around them.
You generate it. You preview it. You own it. You run it.