Describe it. Generate it.
Own it.
Describe how a part of your business works. Nx·Studio's AI business analyst designs digital workers — teams of AI agents, business rules and human approval steps — that you refine on a visual canvas, test on sample data, and download as a complete Python project you run on your own infrastructure.
Want to see exactly what an export contains? Sample export files are available on request via the Trust Center.
Your description
“Match invoices to purchase orders, route exceptions to finance, and escalate anything unusual.”
- 01 Describe
- 02 Generate
- 03 Shape
- 04 Preview & test
- 05 Export & own
From a business description to code you own, in five steps.
No coding needed to get from an idea to a tested worker — and your engineers can open up every step whenever they want to.
Describe
Tell Studio how the process works — with a 10-step guided wizard, by pasting notes, or in a single prompt — and add documents. A readiness score shows what's still missing.
Guided wizard · 10 steps
Generate
An AI business analyst proposes five alternative designs, checks and repairs them, scores the ones that pass and recommends the best fit. Pick one — and deepen it if you like.
Up to 5 designs · scored
Shape
Refine the design on a drag-and-drop canvas, or in a swimlane view written for the business. Write rules in plain English and add approval steps from ready-made gates.
40 step types
Preview & test
Run the worker on sample data with a real AI model and watch every step live. Approve or reject at each approval step, then build test suites and compare versions.
Live trace
Export & own
Download a complete Python project — workflow, runtime, tests and deployment files, with a threat model and a signed bill of materials — and run it on your own infrastructure.
worker.zip
What is a digital worker?
Software that carries out a business process the way a trained team would — reading what comes in, applying your rules, using AI where judgment is needed, and asking a person when it should. In Nx·Studio, every worker is a flowchart you can read.
- Input New invoice arrives
- Rule step Matches the order and receipt?
- AI step Explain the mismatch
- Approval gate Over the limit → finance approves
- Tool step Schedule the payment
AI agents
Read, reason and draft — for the steps that need judgment, on the model you choose.
Rules
Your fixed business rules, written in plain English. No AI call, same answer every time.
Tools & connectors
Call your systems through their APIs to look things up or get things done.
Gates & approvals
Check each case automatically — policy, confidence, risk, cost, deadline — or hand the decision to a person.
A digital worker is a generated, governed software worker delivered as owned source code — not a rebadged bot or script. Workers can also route between branches, search documents, remember past cases, call other workers and run guardrail checks — 40 step types in all.
Five designs to choose from — not one guess.
Every generation run proposes five alternative designs for the same goal. Studio checks them against around 70 validation rules and repairs what fails, then scores the designs that pass and recommends one — typically within a few minutes.
Conservative
Minimal automation, the fewest steps and the lowest risk — with more human checkpoints.
Balanced
The recommended default for most organisations.
Ambitious
Automates the most, for the biggest gain — with fewer approvals.
Compliance-first
The design a risk or compliance officer would sign off — heavy on rules and checks.
Cost-optimal
The lowest estimated monthly running cost that still meets the goal.
Then: Deepen
Add detail to the chosen design step by step — better prompts and checks — with a cost estimate before it runs, saved as a new draft.
- Fitness · weight 25% 8.6
- Safety · weight 20% 8.1
- Compliance · weight 20% 7.7
- Cost · weight 15% 7.2
- Simplicity · weight 10% 6.9
- Scalability · weight 10% 7.5
The Nexgile difference.
The Foundation is four principles built into every digital worker Nx·Studio generates — so you can read it, test it and run it yourself, instead of taking it on trust.
Prove it on sample data before anything real.
Nx·Studio generates realistic sample data for each worker, or imports the files you choose, and runs the worker on it with a real AI model. You watch every step, tool call and cost as it happens, approve or reject at each approval step, and rerun the same scenarios after every change. Studio doesn't need your production systems or your production data.
Fixed rules stay fixed. AI only where judgment is needed.
A digital worker mixes rule steps that apply your business rules — written in plain English — with no AI call and the same answer every run; AI steps for the genuine judgment calls; gates that check each case automatically for policy, confidence, risk, cost or deadline; and human-approval steps that hand a decision to a person. Every design's readiness score shows how much of it runs on fixed rules.
Your auditors can read it before it runs.
Every digital worker is a flowchart your teams can read — its agents, tools, rules and approval steps — with a swimlane view written for the business. Each change is saved as a version you can compare, fork, merge or return to, and a health check flags gaps before anything is exported. The same workflow file ships inside the export, so what was reviewed is what runs.
Download it. Run it without us.
An export is a complete, self-contained Python project: the workflow, its prompts and code, the runtime that executes it, sample scenarios and tests, and a Dockerfile to run it. Every export also includes a security threat model and an AI bill of materials with a signed attestation your team can verify offline. The code carries no licence keys and makes no calls to Nexgile.
Route low-confidence cases to a human-approval step and they wait for a person instead of proceeding on their own. Approval steps are assigned by role, team or variable — and every approval rehearses in the preview before anything is exported.
Design it like a diagram.
A drag-and-drop canvas makes the worker something anyone can see and shape — while engineers can open the code view for any step.
40 step types
Agents, tools, rules, routers, approval gates, retrieval, memory, sub-workers, guardrails and more — each with its own settings form.
16 proven patterns
One-click team shapes: sequential chain, parallel fan-out, router, hierarchical team, map-reduce, consensus voting, saga and more.
7 gate types
Policy, confidence, risk, cost, deadline, human-approval and fallback gates, ready to drop in.
Plain-English rules
Write a business rule in words and Studio turns it into a formal rule step.
Swimlane view
An editable, business-friendly view of the same workflow, lane by lane.
Health checks
Problems are flagged as you build, and a readiness check runs before every export.
Versions
Every change is a version: compare up to three side by side, fork, merge, or go back.
Test as you build
Run a chosen part of the workflow while you build — single-step testing can be switched on too.
Compare versions in plain language.
Every change is a version you can compare, fork, merge or return to.
- Intake — invoice matched against purchase order
- Routing — rule step, same answer every run
- Approval gate — every refund to one reviewer
- Low confidence — routed to human approval
- Intake — invoice matched against purchase order
- Routing — rule step, same answer every run
- Approval gate — only refunds above $10,000 go to finance
- Low confidence — routed to human approval
Illustrative — a version comparison of the same worker, readable in plain language.
Watch it work before it touches anything real.
Preview runs the same runtime that ships in the export, with a real AI model, on sample data made for the worker. Studio holds no credentials for your live systems.
- Intake invoice Input 0.2s
- Match to purchase order Rule 0.01s
- Explain price mismatch AI agent 3.4s
- Finance approval Gate paused Waiting for approval Approve Reject
- Schedule payment Tool —
Sample data, made for each worker
Studio derives a data model and generates realistic records — or imports your CSV, Excel or JSON files — for the worker to work on.
A live, step-by-step trace
See every step, tool call, input, output and cost as it happens — and step back through any run afterwards.
Approvals, rehearsed
Runs pause at approval steps. Approve, reject or edit from the Actions inbox, and the run carries on.
Evaluation suites
Scenarios, golden datasets, A/B tests and regression checks, scored on six dimensions.
Simulation & comparison
Run several workers over a dataset, compare versions side by side, and rerun your saved scenarios after every change.
Documents & knowledge
Give workers reference documents, a knowledge graph and memory to draw on — and inspect what they retrieved.
Don't start from zero.
Ground a new worker in the documents, processes and automations you already have — you choose what to share, and it's used only to design your workers.
Documents
Upload PDF, Word, Excel or Markdown files — policies, procedures, process notes — to ground the design. Scanned pages can be read with optional OCR.
Your existing RPA
An RPA-bridge step hands work to the RPA tool you already run, so a worker can sit alongside today's bots.
Process discovery
Mine event logs — XES or CSV, or exports from Celonis, UiPath or ABBYY — for processes worth automating.
Recover
Turn existing agent code (LangChain, CrewAI, AutoGen or custom Python) or a BPMN diagram into a draft worker.
What's in the box.
Every export is a self-contained Python project. Here's what arrives — and what you can choose to add when you export.
- main.py the worker's API — /run and /health
- dag.json the workflow you designed
- prompts/ agents/ prompts and agent code
- tools.py connectors.py tool code and API calls
- lib/agentic_template/ the runtime, included
- scenarios/ tests/ sample cases and tests
- sbom/ AI bill of materials + attestation
- THREAT_MODEL.md security threat model
- Dockerfile run.sh run it with one command
- README.md how to run and extend it
- The workflow, its prompts and its code
- The runtime that executes it — no Nexgile service required
- Sample scenarios and tests
- A Dockerfile and a one-command run script
- A STRIDE security threat model
- An AI bill of materials with a signed attestation
Put one AI provider key in a settings file and run one command — or use Docker. The worker runs with any of 11 AI providers, including local models through Ollama or vLLM.
If it has an API, your worker can use it.
Workers call your systems through their APIs, using a built-in REST connector — so anything you can describe with an OpenAPI file is within reach.
Your own APIs
Upload an OpenAPI description — or let AI draft one from documentation — and Studio creates a private connector for your workspace.
Connector catalog
Browse a catalog built from open API directories: thousands of public API listings to start from.
MCP tools
Call tools on any MCP server — or publish a finished worker as an MCP server other AI tools can use.
Credentials stay yours
Studio keeps only the names of credentials. The exported worker reads the secrets from your environment or your vault.
Catalog entries for systems such as Salesforce, SAP and Workday are starting points — your team adds the specific API details each worker needs. Triggers (schedules, webhooks, Kafka, JMS) are declared in the design and set up in the export, where your team runs them.
Know the running cost before you deploy.
“The cheapest AI call is the one that never happens.”
Rule steps cost nothing to run
Every decision that follows a fixed business rule runs as a rule step — no AI call, no tokens, the same answer every time. AI is used only for the steps that need judgment.
The rest is visible up front
Each design shows an estimated cost per run, and every preview run shows what each step cost. Once exported, AI usage is billed by your own provider at your rates — there is no Nexgile meter on a running worker.
Governance designed in — not bolted on.
The checks your risk team will ask for are part of the design: visible on the canvas, rehearsed in the preview, and shipped with the code.
Approval gates
Assign approvals by role, team or variable, with approval ladders generated from the roles you describe.
Flags on risky actions
The analyst is told to put a human gate before irreversible actions, and Studio flags any sensitive action left without one.
Readiness score
Six dials — context, determinism, tools, gates, evaluation coverage and deployment — show how ready a worker is.
Health check before export
Best-practice checks must pass, or be consciously overridden, before anything is exported.
Threat model in every export
A STRIDE analysis of the worker, with a data-flow diagram, generated automatically.
AI bill of materials
What's inside, with a signed attestation you can verify offline and an EU AI Act cross-reference.
Compliance & policy checks
Compliance rule sets, plus Cedar, OPA and Prolog policy steps — with HIPAA, GDPR and SOX packs.
Red-team testing
Adversarial attacks on the worker during preview, across six categories.
Formal verification
Mathematical checks of the workflow's structure at export time.
Inside the exported worker you can also switch on a tamper-evident audit log, personal-data redaction, guardrails and policy-based access rules.
“Is it really ours?” Check it yourself.
Every export includes an AI bill of materials that lists what's inside, with a signed attestation your engineers can verify offline — on your hardware, without trusting us.
Each export also carries a signed hash of its contents, so you can confirm the package you deploy is the one you reviewed. Nothing in it stops working if you stop paying us.
Can Nexgile still get in?
No. The export contains no Nexgile keys, accounts or calls home — you hold the code and the credentials.
Can we take it with us?
Yes. It's a complete Python project with the runtime included and a Dockerfile to run it — no proprietary runtime and no Nexgile service.
What if Nexgile goes away?
It keeps running. Exported workers have no licence keys and no dependency on us to stay alive.
Sample export files — a project tree, its threat model and its bill of materials — are available on request via the Trust Center.
Improvement you commission — not drift you discover.
Your team can edit the exported code freely. When the business changes, come back to Studio, improve the design and bring the changes across on your schedule.
Upgrade in place
Regenerate a worker later and Studio merges the new version into your team's edited copy — keeping their changes.
Optimize
AI proposals to improve a worker, applied as a new draft for you to review.
Opportunity scan
Point Studio at a dataset and get a backlog of proposed new workers.
Solutions
Group related workers into one solution, with a map of how they depend on each other.
Built for every stakeholder.
From the process owner to the platform team — each gets a view made for them.
Operations, finance, HR
Business analysts & process owners
Describe the process, review designs in the swimlane view, and write rules in plain English.
AI engineers, developers
Automation & AI engineers
Fine-tune steps, prompts and code, test parts of a workflow, and build evaluation suites.
Risk, compliance, security
Approvers & risk teams
Read the workflow, and check the readiness score, threat model and bill of materials.
COO, CFO, CIO
Sponsors & executives
Compare up to five scored designs, each with its estimated running cost, before committing.
DevOps, platform engineering
Platform & IT teams
Run the exported project on your own servers, containers or cloud.
IT administrators
Administrators
Organise tenants, workspaces, members, roles and folders.
What's available, what's optional, what's in progress.
We'd rather you know exactly what you're getting. Here is the current release, feature by feature.
Available today
Switched on in the current release.
- Guided context intake and document upload
- AI business analyst proposing five designs per run
- Deepen: step-by-step enrichment of a design
- Visual canvas, swimlane view and version history
- Sample datasets, imports, documents and knowledge
- Preview with live trace and approval pauses
- Evaluation suites, A/B tests and regression checks
- Export with threat model and bill of materials
- Deployment files chosen at export
- Workspaces, members and roles
Optional modules
Built in — switched on for your deployment.
- Real-time co-editing of the canvas
- AI copilots for the canvas and for intake
- Voice authoring
- Process discovery from event logs
- Recover: code or BPMN into a draft worker
- Compliance rule sets and governance console
- Red-team testing and formal verification
- Upgrade in place
- Present mode for guided walkthroughs
In progress
Partly built — we'll tell you exactly where each one stands.
- Reviewer inbox in the export: approving doesn't yet resume a paused worker automatically, and SMS and push alerts aren't active
- Audit and ROI dashboards in Studio — shown with sample data today
- Self-hosting Studio itself — Helm and air-gapped packaging built, not yet proven on customer clusters
- Marketplace — a starter set of worker packs
- Automatic deadline and escalation handling for approval steps — recorded in the design today
The questions buyers ask.
Short answers, no hedging.
Q Do we need developers to use Nx·Studio?
Not to design and test a worker. The wizard, canvas, swimlane view and plain-English rules are built for business teams. Engineers can open the code view for any step, and the export is ordinary Python they can extend.
Q Does Studio see our production data?
It doesn't need to. Preview runs on sample data generated for each worker, and Studio holds no credentials for your live systems. If you choose to upload documents or import files, they're used to design and test your workers.
Q Which AI models does it use?
Claude by default for designing workers, with 11 provider types supported. The exported worker runs on the provider you configure — including local models through Ollama or vLLM.
Q Where does the finished worker run?
On your infrastructure — a server, Docker, Kubernetes or your cloud. Nexgile never runs it, and the code makes no calls to Nexgile.
Q What happens if we stop working with Nexgile?
Your exported workers keep running. They're ordinary Python projects with the runtime included, no licence keys and no calls home.
Q Is a generated worker ready for production as-is?
Treat it as a strong first draft. Review the design, test it in preview, and have your engineers finish integrations, credentials and deployment before go-live — the export's tests, threat model and readiness checks are there to help.
Q Can several people work on one worker?
Yes. Workspaces have members and roles, every change is saved as a version, and real-time co-editing of the canvas can be switched on.
What you walk away with.
From business intent to software you own.
See a digital worker designed, tested on sample data and exported — live, in one session.
You generate it. You preview it. You own it. You run it.
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.