Design the process. Own the execution.
Give each process an owner and a plan before anything goes live. Nx·Studio drafts designs with estimated run cost, your managers place rules and approval checkpoints, and trial runs on generated test cases show how the worker behaves. Your team then takes delivery of the code and runs it.
Before a team is committed, your engineers can review sample export files through the Trust Center.
Brief for review
“Process new-hire onboarding requests, check each against HR policy, and route exceptions to the team lead.”
One workspace for process teams and IT.
Each digital worker takes one business process from the first request to the final result. AI agents do the routine steps, named approvers make the calls your policy keeps for people, and connections link it to your systems. It is designed jointly by your people and Nx·Studio. Every option lists the run cost the AI estimates and the hours it would return, with payback projected in the plan.
From a scoped process to a running worker.
Start from the procedures and policies your teams already follow. Choose a design, trial it with your approvers, then hand the code to IT, who finish the connections and validate it on your live systems.
A named owner for every stage of the work.
The process owner answers for results, approvers for the decision at each checkpoint, and IT for hosting and upkeep. All of them work on one shared design in the studio.
Six stages, start to finish.
Define scope and owner
Your process owner describes the work in a 10-step guided form, in pasted notes or in one paragraph. Eight starter packs and document uploads speed up the first draft.
Weigh up to five designs
Five designs at most come back, each scored, spanning a cautious option to a bold one, and one is marked as recommended. Your managers compare them and pick the one to take forward.
Configure the controls
Adjust the chosen design on the canvas, assign each step to a person, team or system in the swimlane view, and name the approver at every checkpoint.
Trial on test data
Run generated test cases one step at a time or end to end. Approvers answer the same pauses they will meet in live operation, and every run is scored.
Take delivery of the code
The export screen lists every item your organization will receive and produces a PDF summary for stakeholders. IT then downloads the complete project, starter integration code included.
Operate on your systems
IT hosts the worker in your environment with the model vendor you contract with, and the process owner tracks its results. Nxgyle adds no software, license check or usage charge.
Controls your team works with.
Model quality is converging, so a rollout succeeds or fails on how the worker is controlled. Each Nx·Studio worker carries the Foundation's four mechanisms, and every one leaves evidence that operations, IT and risk staff can check for themselves.
Run trials your approvers take part in.
Nx·Studio builds realistic test data for the specific process a worker covers and stands in for outside systems. Your team runs trials step by step or end to end, and each run stops at every approval checkpoint until an approver responds. Joint trials of several workers run on compressed time. Every trial earns accuracy, safety and cost scores; no production data is needed.
Turn team policy into fixed checks.
Thresholds and limits from your procedures become fixed rules inside the worker wherever the AI analyst can encode them. The process owner accepts each rule, and anything that could not be encoded is listed for the team to resolve. A fixed rule settles identical inputs identically and never calls an AI model. Routine judgments that live only in people's heads are better suited to the Cognitive Engine: its own product, connected through its own Studio and learning from confirmed outcomes.
See who decides at every step.
A readable blueprint, not a pile of prompts, sets out each worker. It names every step, each approver, the hand-off points and the systems involved. Every save creates a version that your team may compare with others, branch or merge under change control. Managers follow the same design as swimlanes, one lane per team, person or system. At export, an itemized list shows the delivered contents, and the blueprint remains your organization's property.
Check the package before handover.
The export screen lists the full package before anything downloads. Its signed, tamper-evident AI bill of materials names each software and AI part, and your engineers verify it offline using the verifier shipped alongside. A security threat model comes with it, along with EU AI Act documentation in template form. After handover the worker runs without Nxgyle: no runtime from us, no license check, no metering and no calls home.
Your approvers keep the final say: at each approval checkpoint the worker waits for an authorized person. Exports that contain checkpoints also carry a reviewer inbox application; your engineers hook it up to the worker. Approvals in Slack are optional. Team leads can also set confidence thresholds: by default a low score raises a warning, and such cases can be routed to a person.
Turn your procedures into a working design.
Nothing comes from a fixed catalog. Your team describes the current process: who handles it, which systems it touches, where it stalls and which rules apply. The AI analyst then designs workers around that picture, each with roles, steps, approval checkpoints and estimated economics.
-
Pick how to brief it
Business analysts and project managers can start in guided mode with the 10-step form, while engineers open the canvas directly. Eight starter packs range from month-end close to IT incident triage.
-
A shortlist your managers rank
Designs run from cautious to bold, plus a compliance-led and a lowest-cost variant. Each one is rated on fit, safety, compliance, cost, simplicity and scalability, next to its estimated run cost and monthly hours saved.
-
Repaired before review
Each design is critiqued and corrected before it reaches your reviewers. A deeper pass on the chosen design runs only when someone requests it and accepts its cost estimate.
-
Rules your team accepts
List the policies your staff follow. The analyst turns them into fixed checks wherever it can, each arriving as a draft your team accepts or edits, and it flags any it could not encode.
Agree the design before anyone builds.
Every function involved can read and edit the worker on one drag-and-drop canvas. The swimlane view lays it out the way a manager thinks about the work: by team, person and system.
-
Editing without code
Forty step types cover rules, approvals, agents, loops and integrations, and starter patterns help each team begin. Nobody on the business side has to write code.
-
Lanes for each team
Each step is placed in its owner's lane, so ownership gaps are easy to spot.
-
Readiness, tracked
Mistakes and missing policies are flagged during editing, and a readiness score tells managers how far the worker is from handover.
-
A version for each save
Saving creates a version your team can diff, branch or merge, so each change leaves a trace.
Read the trial before going live.
Nx·Studio generates test data shaped like each worker's process. Your process owner and approvers watch it work through realistic cases before live operation, and production data never has to be shared.
-
Test cases made for this worker
Synthetic (computer-generated) records follow the worker's own data model, and teams may also load samples of their own, capped at 200,000 rows.
-
Inspect each step
Step through the run one stage at a time or pick up from any point, with inputs, outputs and logs recorded for each.
-
Approvers take part
Trials pause at every approval checkpoint until a person answers. Approvers work through a list of runs awaiting a decision, approving or declining each simulated action, and nothing touches a live system.
-
Workers tried together
In the simulation lab, groups of workers run together in accelerated time, with stand-ins unless real workers are chosen, and the lab reports record conflicts and broken handoffs.
Each trial is scored on accuracy, coverage, robustness and speed. The scores form an evaluation report your steering group can review, and run history exports to CSV for status reporting.
Request a sample trial reportWhat IT receives and runs.
IT receives working software, not just a diagram. Connector code starts from a catalog listing thousands of APIs. Each worker routes approvals to the people you named and runs on your own cloud under the model vendor contract you hold.
-
Connections your IT team completes
Starter connector code covers Salesforce, SAP, ServiceNow, Workday and Oracle EBS, and the wider catalog lists thousands of APIs. IT fills in each system’s details and tests the connection, so plan their time for it. Standards-based web APIs and MCP servers (the open protocol AI agents use to reach other systems) can be called too.
-
Approvals once live
Exports with approval checkpoints ship with a reviewer inbox that IT must connect to the worker. Each checkpoint gets approvers by role or by team, and no one may approve a request they raised. Slack is optional, and email goes through a single supported provider.
-
Where IT deploys it
IT can deploy with optional infrastructure files for Azure, AWS, Google Cloud, Databricks, Snowflake or Kubernetes. Eleven model vendors are supported, including fully local models.
-
Day-to-day oversight
Available at export if you want them: dashboards, alerting, drift notices, and runbooks (generated operating guides) for whoever keeps it running. You pick which to enable.
Set the budget before the rollout.
“A rule step makes no AI call, so it adds nothing to the AI bill.”
A cost forecast for each design
Every design comes with an AI forecast of its monthly running cost and the staff hours it would free; a payback projection appears in the plan. Managers get numbers for the business case before choosing.
Rules that cost no AI
Your stated rules run as fixed checks wherever possible. Nx·Studio shows the share of each worker that is deterministic (the part that gives the same answer every time) and suggests ways to raise it.
Flat as volumes grow
The worker runs on your systems under your own model-vendor accounts. Nxgyle meters nothing, so busier months leave Nxgyle fees flat; model usage still grows with volume.
Check every rule and approver in advance.
A blueprint lays out each digital worker: its roles and agents, routing, rules, integrations and approval checkpoints, all in one readable place. Nothing important is buried in AI instructions or locked inside a vendor platform.
Each save is a new version that engineers compare and merge like code, while managers read the same worker as swimlanes of who does what. At export the screen itemizes what was built, so the asset your organization holds is documented rather than left as a setting in someone else's platform.
- New-hire request — checked against HR policy
- Standard laptop order — fixed rule, same result each time
- Access requests of any level — team lead approves
- Incomplete forms — returned to the hiring manager
- New-hire request — checked against HR policy
- Standard laptop order — fixed rule, same result each time
- Admin-level access — the security team approves
- Incomplete forms — returned to the hiring manager
An illustrative change from one version of a worker to the next, in plain words. In Nx·Studio, the version history marks it on the design itself.
Start from the automation you already run.
Your teams already hold useful material: event logs, automation already built and the software bots in daily use.
Find candidates in logs
Optional module: point it at process-mining exports from tools like Celonis or UiPath, and it ranks the processes worth automating next.
Bring existing automation
Optional module: supply Python agent code you already have, or BPMN diagrams of a process, and receive an editable worker built from it.
Work alongside your bots
Flag the steps your software bots (RPA) already perform in Power Automate, UiPath or Automation Anywhere. At those steps the worker sends your team a hand-off request to route; Nxgyle supplies no bot.
Log discovery and the code and BPMN converters are optional modules, switched on only where your team decides.
Keep changes under control once it runs.
Improvements accumulate in designs and code your organization holds. Every change gets a version and a review trail, and proposed improvements wait for your approval.
Reviewer fixes that stick
Optional: corrections your reviewers make during trials feed the knowledge base that ships with the worker, so the learning stays inside your organization.
Change records per version
Diff or merge versions, start a branch from any past version, and tie each trial score to the version that produced it.
Local edits carried forward
Optional: include an upgrade baseline at export, and later regenerations will keep your team's code changes and flag any conflicts.
Proposed refinements
After trials, Nx·Studio suggests changes such as a cheaper model, a fixed rule in place of an AI step, or steps run in parallel. None applies until you approve it.
What your team does at each stage.
Each area below covers what your team can do, from the initial brief to a worker in daily use.
Scoping and design
Briefed by your team, then designed to fit.
- Guided form, notes, one paragraph or a starter pack
- Up to five scored designs with cost and hours estimates
- Each design corrected before your review
- Policies turned into fixed checks where possible
Reviewing together
One canvas that managers and engineers both read.
- Forty step types to build with
- Swimlanes that name each step's owner
- A readiness score and live error checks
- Version history with branches and merges
Knowledge it relies on
What each worker draws on to do the job.
- A data model for each worker
- Generated test records or your own samples
- Reference documents, knowledge maps, seed memories
- Bundled with the worker on export
Trials and their results
What the trials show before anything goes live.
- Single steps, or reruns from any point
- Approvers accept or reject at each pause
- Several workers trialed together
- Scores, A/B tests and an evaluation report
Connections IT completes
Connection starters for common systems; the catalog lists thousands of APIs.
- Starters for Salesforce, SAP, ServiceNow, Workday and Oracle EBS
- Calls to open web APIs and MCP servers
- Hand-offs to RPA bots already in use
- Starter triggers: timers, webhooks, event streams
Decisions and owners
Your approvers keep the decisions policy reserves for people.
- A reviewer inbox your IT team connects; Slack optional
- Approvers named by role or by team
- Low-confidence results warn by default, or go to a person
- Guidance to require approval before irreversible steps
Policy and security safeguards
Controls considered from the first draft.
- Redaction of personal data, when enabled
- STRIDE threat analysis in each package
- Policy steps, when enabled, refuse disallowed actions
- An optional governance console and rule packs
How it is delivered
Delivery formats that fit how your teams work.
- Served as an MCP server, chat widget or API
- Optional templates for Azure, AWS, Google Cloud, Kubernetes, Databricks, Snowflake
- Eleven model vendors, fully local ones included
- Opt-in dashboards, alerts, runbooks
Owned and run by your team
Source code your IT team hosts in a supported environment.
- You own every file it generates
- A line-by-line ownership report at export
- A signed manifest your engineers verify offline
- No Nxgyle software required to run
Nine differences to weigh.
Check each one against your process, integration and governance requirements during a demonstration.
Designed around how your team works, not picked from a shelf
Five scored designs at most, every one corrected before review
Policies become fixed checks wherever possible, with no AI call
Test data made for each worker, so trials need no production data
Approval checkpoints that really pause the worker, practiced in trials
A full version trail per worker: compare, branch and merge
Existing logs, agent code, BPMN files and RPA bots put to use, some through optional modules
Your cloud and your model vendor, with fully local models supported
A signed manifest of AI components and an itemized ownership report with each export
Added in recent releases.
- Knowledge
Data of its own for each worker
Each worker has a data model, generated test records and your uploaded samples; reference documents, knowledge maps and seed memories can travel with it.
- Drafting
Designs that fix themselves
A Rules & Decisions step joins the intake form, and designs now review and repair themselves, deepen on request and show a readiness score.
- Oversight
Approval pauses inside trials
Trials that pause for approval and then resume, a studio list of runs waiting on a decision, and simulated actions held until an approver accepts them.
- Operations
A lane for every function
Lanes by system, team and role, plus an itemized list of everything your organization receives at export.
- Connections
Working integrations
Integrations now execute within exported workers, which can call any standard web API or MCP server and use secure sign-in methods for enterprise systems.
- Delivery
Deploy to your environment
Optional deployment files for Azure, AWS, Google Cloud, Databricks and Snowflake, serving the worker as an MCP server, chat widget or API. Your IT team wires the starter trigger code to event streams, timers and webhooks.
Switch on only what you need.
Optional modules your team can enable
- Red-team testing (scorecard only)
- Voice and chat intake
- AI-suggested design edits
- Governance console with rule packs
- Process-log discovery; code and BPMN import
- Formal checks of the workflow graph and data lineage
Default-off export options
- Slack approvals; email via the single supported service
- Redacting personal data
- Upgrade baselines for future regenerations
Every exported worker is currently a Python project.
The roles behind each worker.
From the sponsor who sets priorities to the team that runs it.
Process sponsors
COO, heads of operations
Set priorities and approve the rollout order
Architecture review
CTO, solutions architects
Check each design against architecture standards
AI engineering
ML engineers, data scientists
Adjust agents and rules after each trial
Platform team
DevOps and SRE teams
Host and monitor workers day to day
Portfolio management
Product and program managers
Decide what gets automated next
Process owners
Analysts, department leads
Shape and maintain their department's workflows
“Is this genuinely our code?” Verify it yourself.
Before anything downloads, the export screen lists every item your organization will receive and produces a PDF summary you can circulate to stakeholders. It also contains a digitally signed AI-BOM, the tamper-evident manifest of each model, agent and dependency that your engineers can verify offline on hardware they control. A threat model for the security review and a draft EU AI Act documentation pack (not a conformity assessment) are included as well.
Once exported, the worker runs independently of Nxgyle: no Nxgyle software, license check, metering or phone-home. Hosting, dependencies and upkeep become your team's responsibility, so name an owner for each before handover.
Does Nxgyle keep any access after export?
No. The exported worker carries no Nxgyle key, license check or phone-home. Your organization keeps the credentials and the code, and runs both where it chooses.
What exactly does your IT team receive?
The complete project: code, tests, optional deployment files and, if selected, runbooks for the people who run it. One command starts a local run; IT promotes it to your cloud once the rollout is approved, with no proprietary platform involved.
Who operates it after handover?
Your team does: IT for hosting and upkeep, process owners for results and approvers for decisions. No Nxgyle runtime is involved. A self-hosted Studio can be licensed, and air-gapped sites still need private model endpoints.
For an independent check, request a sanitized export file tree, the project README and sample trial results through the Trust Center.
What your team keeps.
Each count is calculated from the portal and worker records listed on this site. A digital worker is an operational asset in code: it runs one defined process under your rules and approval checkpoints, and your organization holds the full source.
Nx·Studio is where your process teams design, trial and hand over digital workers. Nx IDE helps your engineers build and extend the systems those workers connect to. The Cognitive Engine decides routine cases only after its rules pass an exam on cases they never saw.