Home Industry Ecosystems Platform Nx·Studio Flagship Nx IDE Trust Center Pricing Capabilities About Us Leadership Team Careers Contact Us
The Owned Digital Workforce Platform

You generate it. You preview it. You own it. You run it.

Nx IDE For engineers

An AI engineering assistant inside your code editor.

Nx IDE is a code editor built on VS Code, with the Nexgile Code AI agent built in. Describe a task in plain English. It plans the work, edits files, runs commands and tests, and checks the result, asking you before anything risky.

Book a demo See how it works
  • Works with 26 AI providers
  • Asks before it acts
  • No usage telemetry
How it works

A task, from request to finished change.

You stay in the loop at every step. The agent does the typing, and you make the calls.

  1. Step 1: Describe the task

    Type what you need in plain English, or paste a screenshot or an error. New chats start in Code mode, or you can pick another mode.

  2. Step 2: Agree on the plan

    For bigger jobs, Architect mode writes a plan first. Comment on any part and only that part is rewritten, before any code changes.

  3. Step 3: Watch it work

    It edits files and runs commands, with a live to-do list. By default it asks before every edit, command and tool call.

  4. Step 4: Check and ship

    It checks its own changes and runs the tests. For an independent check, use /review or Orchestrator mode. You decide what ships.

31 built-in modes

A specialist for each kind of work.

Each mode is the same agent with a focused job and the tools to match. Switch modes by typing /, or let Orchestrator mode hand work to the right one.

  • Code

    Writes and changes code. The default for new chats.

  • Architect

    Plans the work and writes a plan document before any code changes.

  • Chat

    Answers questions about your code without changing anything.

  • Debug

    Finds the root cause and confirms it with you before fixing.

  • Orchestrator

    Takes one task through build, test, review and ship.

  • Tester

    Writes its own test plan to check a change. It can't edit code.

  • Reviewer

    Reads the diff and gives a verdict. It can't edit code.

  • Shipper

    Commits to a feature branch and pushes, once you say ship.

  • Spec Bootstrap

    Interviews you and writes a linked wiki for your project.

  • Spec Sync

    Keeps that wiki up to date with new commits, through a plan you approve.

Plus 21 specialists

  • Refactor
  • Test Gen
  • Doc Gen
  • Security
  • API Mod
  • Dep Upgrade
  • Translate
  • Issue Fixer
  • PR Fixer
  • Merge Resolver
  • Issue Investigator
  • Issue Writer
  • Docs Extractor
  • DB Migrator
  • DB Architect
  • Code Architect
  • DevOps
  • API Tester
  • Code Reviewer
  • UI Designer
  • Dev

You can add your own modes and agents with files in your project.

Bigger jobs

From one change to thirty at once.

When a task needs more than one pair of hands, Nx IDE can run it as a team, or split it into many tasks that run side by side.

  • /review

    Reviews your uncommitted, staged or branch changes, or a commit or pull request. Findings are rated Critical, Warning or Suggestion, and nothing is fixed unless you pick it.

  • /batch

    Splits one large change into as many as 30 tasks that run side by side, each on its own git branch, then merges them into one.

  • Agent Manager

    One screen to run and supervise many AI tasks across your projects, with an inbox of anything waiting on you.

  • /goal

    Set a finish condition, and a separate judge model keeps the agent working until it's met.

You stay in control

Careful by default. Faster when you say so.

Nx IDE asks before it acts until you decide otherwise, and some decisions always stay with you.

  • Permission rules

    Allow, ask or deny rules for what the agent may do. Project rules can only make things stricter.

  • Protected and ignored files

    Mark files the agent must not change, or must not read at all.

  • Command allow and deny lists

    Pre-approve the safe commands and block the risky ones.

  • Hooks

    Run your own checks at eight points, for example a linter before a task can finish.

  • Cost and request limits

    Per-task limits pause the work and ask you before it goes further.

  • Checkpoints

    Restore files, or files and the conversation, from any step. They don't undo side effects such as installed packages or database changes.

Large and legacy codebases

Understands code you didn't write.

Cortex is a private map of your codebase. It runs offline, with no network or API key, and it's on by default.

  • See who calls what, plus subsystems, execution flows and routes
  • Check the impact and risk of a change, from Low to Critical, before you make it
  • Find unused code and import cycles
  • Rename safely across the whole codebase
  • Reads 35+ languages, including COBOL, JCL, PL/I, ABAP, VB6 and PL/SQL

Translate mode

Converts code one file at a time, keeping the structure and marking every difference for review.

Modernization modes

API Mod, Dep Upgrade, Refactor and DB Migrator for the rest of the job.

One-click commands

Translate Code, Refactor Code, Generate Tests, Generate Documentation, Security Remediation, Modernize API and Upgrade Dependencies.

Your models, your data

Use the AI models you already trust.

Nx IDE works with 26 AI providers, including models that run on your own machine. It needs models that support tool calling.

  • Anthropic
  • OpenAI
  • Google Gemini
  • Amazon Bedrock
  • Google Vertex AI
  • Mistral
  • xAI
  • DeepSeek
  • OpenRouter
  • LiteLLM
  • Any OpenAI-compatible endpoint
  • Ollama (local)
  • LM Studio (local)
  • and more

No Nexgile cloud in the middle

Your code goes only to the AI provider you choose, and there's no usage telemetry.

Costs you can see

Live cost per task, plus a dashboard of spend by day, model, project and mode, with budget alerts and CSV export.

Licensed offline

Your license key is checked offline, on your machine. You pay your AI provider directly for model use.

A TAA edition

For organizations that need it, an edition that leaves out China-based providers and models.

Also built in

  • MCP servers, plus an MCP Marketplace
  • A Skills Marketplace
  • GitHub modes through the GitHub CLI
  • Project memory across sessions
  • Reads PDF, Word, Excel and Jupyter files
  • A browser panel for your local app (optional)
  • Inline completions (optional)
  • Voice dictation (optional)
FAQ

Questions about Nx IDE.

Can't find yours? Ask us directly.

Is Nx IDE the same as VS Code?

It's built on VS Code, so it looks and works like the editor many engineers already use, with the Nexgile Code AI agent built in. Inside the product, the assistant is called Nexgile Code.

Will it change our code without asking?

Not by default. It asks before every edit, command and tool call. You can give it more freedom with the Delegation Dial, but it never answers questions about committing, pushing, deploying or deleting for you.

Which AI models can we use?

Any of 26 providers, including Anthropic, OpenAI, Google Gemini, Amazon Bedrock and Google Vertex AI, or local models through Ollama or LM Studio. It needs models that support tool calling.

Does our code go to Nexgile?

No. There's no Nexgile cloud in the middle and no usage telemetry. Your code goes only to the AI provider you choose, or stays on your machine if you use a local model.

Can it work on legacy code like COBOL?

Yes. Cortex reads more than 35 languages, including COBOL, JCL, PL/I, ABAP, VB6 and PL/SQL, and Translate mode converts code one file at a time, marking every difference for review.

Do we need Nx·Studio to use it?

No. Nx IDE works on any codebase. If you also use Nx·Studio, it's a natural place for your engineers to maintain the worker code you export.

Explore Nx·Studio

See Nx IDE work on your codebase.

Book a demo and bring a real task. We'll show you the plan, the edits and the checks, with you approving each step.

Book a demo Explore Nx·Studio

Nx·Studio designs the digital workers that run your business processes. Nx IDE gives your engineers an AI assistant for the software around them. See how they fit together.