Readable logic. Runnable code.
Nx·Studio turns a written process brief into a workflow of AI agents, coded rules and approval gates. Your engineers review it as a versioned graph and rehearse it against mock systems before any live call. The export is a build-checked codebase with its workflow runtime, tests and a container definition, which your team runs in-house.
Engineering reviewers can request a sample file listing, README and test report through the Trust Center.
Input brief
“Three-way match each supplier invoice to its PO and receipt; hold mismatches and flag amounts over policy.”
The studio never runs production.
Nx·Studio generates workflows of AI agents, coded rules and approval gates, rehearses them and exports self-hostable source. Production traffic never passes through it: each exported worker runs on infrastructure you operate, under the controls you configure.
Nothing to license at run time.
Only the runtime template ships to you; the studio's own code never does. Exported workers contain no Nxgyle endpoints, no telemetry SDK and no license check.
Guided mode or graph first.
Analysts can take the guided path while engineers open the graph directly. Architects review structure and integrations; platform teams own hosting and observability after export.
Six stages from context to a deployable build.
Capture the context
Feed context through the 10-step wizard, chat or document uploads of up to 25 MB each, plus datasets of up to 200,000 rows.
Score candidate designs
The analyst agent proposes up to five workflow designs, one per archetype. A critique step scores each on six weighted dimensions and recommends one.
Edit the chosen graph
Refine the design on the canvas: 40 node types, live validation, 100-step undo and named checkpoints. Saves produce versions you can diff.
Test on mock systems
Rehearse on a per-worker synthetic dataset while mock mode answers every tool, connector and sub-worker call from happy, empty, error and timeout packs.
Export the project
Export streams one ZIP: a complete source project with its workflow runtime, tests, container definition and README. It adds a component-level threat model and a signed AI bill of materials, and export stops if the build check fails.
Deploy and operate
Build the image from the container definition or start it locally with one script. Point each step at any of eleven model providers, local models included.
Controls you can test.
Leading models now sit within a narrow band of quality, so the engineering beneath them decides the outcome. Every Nx·Studio worker inherits four mechanisms, and each one leaves an artifact your engineers can run, diff or verify themselves.
Mock every dependency before launch.
A synthetic dataset is generated per worker, shaped to its own process, and imported datasets of up to 200,000 rows work too. Mock mode answers every tool, connector and sub-worker call from happy-path, empty, error and timeout packs with no network. It ships inside the export, so your CI can rerun the same tests. Sign-off steps pause rehearsals just as they pause live runs, and production data is never required.
Policy enforced as code, not prompts.
Thresholds, SLAs and policies in your documents become typed rules with their source recorded, and each lands as a draft you accept or edit. Rule steps pass, halt, warn or branch with no model call, so the same input always gets the same result. An inverted-rule check catches conditions that point the wrong way. Repeat decisions that no written policy covers belong to the separate Cognitive Engine, reached through its own Studio's decision API.
Versioned logic you can diff.
Each worker's design lives in a blueprint rather than scattered prompts: steps, sign-off gates, hand-off points and touched systems are all explicit. Versions support branch, tag, diff and three-way merge, with a genealogy view; on the canvas, named checkpoints and 100-step undo protect edits. Process owners view that blueprint as swimlanes, and the export screen itemizes every generated component.
Attested files, verified offline.
Before download, the export view itemizes each file. The package carries a signed AI bill of materials covering models, agents, connectors and dependencies. The signature spans every exported file's hash, so any later change breaks it, and the bundled verifier runs offline. Without your own signing key, a temporary key signs instead. A threat model organized by standard threat categories and a template for EU AI Act technical documentation ship alongside, with no Nxgyle runtime, license or meter inside.
A sign-off step interrupts the run until the named approver answers, and any tool an AI step calls can be marked approval-required. Paused runs survive restarts and resume exactly once. Exports with sign-off steps include an approvals inbox application, which engineering wires to the worker; Slack approval messages work once enabled. Low-confidence scores warn by default or route to a person, and timeouts and escalation tiers are declared, not enforced.
Generated from context, not templates.
There is no predefined worker catalog. An AI analyst agent reads your teams, systems, constraints, objectives and rules, then proposes workflows that fit. Every design lists its roles, steps and gates, with an AI-estimated run cost.
-
Two entry modes
Guided onboarding for analysts, graph-first for engineers. Eight industry and department starter packs seed the context, and never invent approval roles for you.
-
Weighted scoring, stated openly
Fitness counts 25%, safety and compliance 20% each, cost 15%, simplicity and scalability 10% each. The critique step applies those weights to every archetype, then recommends one.
-
Validation before review
A design failing validation is re-prompted or dropped, against a floor of three valid options. An optional deepen pass runs only on request, with its cost shown first.
-
Rules become fixed checks
Thresholds, SLAs and policies become typed rules that run as fixed checks, each traced to its source document. Each draft needs your acceptance, and evaluating a rule never calls a model.
Every node is inspectable.
Each worker is a directed graph you edit visually. Engineers rewire nodes and bindings, and a swimlane view projects the same graph by team, person and system for business reviewers.
-
Forty node types
Agents, tools, rules, approval gates, web API and AI tool-server calls, loops and sub-workers, with stock workflow patterns as starting points.
-
Swimlane projection
Lanes map each node to the team, person or system that performs it, so reviewers outside engineering read the same graph.
-
Lint as you edit
A linter flags errors and inverted rule logic as you edit, a health analyzer lists broken tools and weak approvals, and a readiness score tracks export status.
-
Versions like code
Fork, branch, tag and diff any two versions, run three-way merges, and step the editor back with 100-step undo or named checkpoints.
Rehearsed against mock systems.
Each worker gets a synthetic dataset, generated or imported, and mock mode answers every tool, connector and sub-worker call; model calls still reach your provider. Test runs execute in a restricted process, and an optional hardened sandbox adds stronger isolation.
-
A dataset per worker
Generated records match the schema of each worker's data model, and imported samples can reach 200,000 rows.
-
Step-level traces
Run one node at a time, restart from any point, and read every input, output and token cost in the trace waterfall.
-
Gates in test runs
Test runs pause at each approval gate and wait on the studio's actions page. Governed actions only simulate execution, so nothing reaches a live system.
-
Multi-worker simulation
The simulation lab runs several workers on an accelerated clock. Lightweight stand-ins are the default; real workers can join to expose conflicting writes and malformed hand-offs.
Golden-dataset, A/B and benchmark harnesses score each run; LLM-as-judge stays off until judge models are configured. We can share a report produced from a simulated run.
Ask for an evaluation reportShipped as source.
The export is a runnable software project, not a diagram. Designs can draw on a reference catalog spanning thousands of APIs; at run time, outbound calls reach only the endpoints your team configures.
-
Starter code, not connectors
Catalog operations with a full request definition export as one call plus its auth flow. Seeded SAP, Oracle EBS, Workday, Salesforce and ServiceNow actions have no paths yet, so engineers finish each one.
-
Gates and the reviewer inbox
Gates save a paused run to a database you operate and resume it exactly once. The bundled inbox app still needs wiring by your engineers; Slack works, email runs through a single supported service, Teams is not live.
-
Targets and providers
Optional infrastructure-as-code covers Snowflake, Databricks, container clusters, Google Cloud, Azure and AWS; your team applies it. Eleven model providers, chosen per step, local models included.
-
Telemetry stays yours
Every execution writes a run log with token and cost totals. Export to your own monitoring stack is optional and off by default; drift detection and runbooks are export options.
Price every step before you deploy.
“Rule steps cost about zero. AI steps cost tokens.”
Estimates, then measurements
Each design carries AI-estimated monthly run cost and hours saved; payback appears only in the generation plan. Test runs then record actual token cost on every trace event.
A formula-based projection
The cost model prices each step from assumed tokens and a curated list of 13 models, per run, case and month. It also reports the share of steps that are deterministic.
No meter in the worker
Workers call your own provider accounts, and each run reports its own token totals. There is no Nxgyle metering, and self-hosted models record zero AI cost.
One versioned graph defines the worker.
The blueprint is the workflow definition, and it ships inside the export. Agents, tools, rules, gates, routing and integrations all live in it, so no logic hides in prompts or on a vendor's servers.
Versions fork, tag, diff and three-way merge like code, and a genealogy view traces their lineage. The manifest and ownership tab list each generated file, so reviewers can match the package they receive to the version they approved, file by file.
- Supplier invoice — matched to PO and goods receipt
- Standard cases — coded rule, identical every run
- Credit notes — one approver at any value
- Uncertain cases — held for a named reviewer
- Supplier invoice — matched to PO and goods receipt
- Standard cases — coded rule, identical every run
- Credit notes — controller sign-off above $25,000
- Uncertain cases — held for a named reviewer
Illustrative example in plain language. Inside Nx·Studio, a change like this shows up as a node-level diff between versions v12 and v13.
Start from existing assets.
Process-mining exports, process diagrams, agent code and API specifications can seed a design, and RPA bots can cover steps that have no API.
Process-mining intake
Optional module: import event logs from Celonis or a similar process-mining tool, and receive automation candidates ranked by opportunity.
Diagram and agent-code import
Optional module: convert process diagrams or existing agent code into an editable graph. API specifications can also be uploaded to generate call code.
RPA hand-off
Mark steps that UiPath, Automation Anywhere or Power Automate bots already perform. The worker emits a hand-off request your team routes to the bot; Nxgyle ships no bot runtime.
Discovery and import are optional modules, and your team decides which material enters the studio.
Iterate after export without losing edits.
Regenerations merge with engineer edits, reviewer corrections feed the worker's own knowledge base, and every behavior change traces back to a version.
Corrections as data
Optional: reviewer corrections from rehearsal are curated into the worker's knowledge base, which exports with the worker.
Version-linked scores
Diff and merge worker versions, return to a named checkpoint, and see which version produced each evaluation score.
Three-way regeneration
Optional: export with an upgrade baseline. A later regeneration is three-way merged with your engineers' edits, and conflicts are flagged for review.
Optimization proposals
After test runs, the studio proposes cheaper model tiers, rules in place of AI steps and parallel branches. Each proposal applies only after your approval.
Nine groups, design to deploy.
What engineering gets at each stage, from intake to the running container.
Graph generation
Context in; scored workflow designs out.
- Wizard, chat, uploads or a single paragraph
- Five archetypes, six weighted criteria
- Failed designs re-prompted; floor of three
- Rules mined from documents, then accepted
Canvas and versions
One graph for engineers and business reviewers.
- 40 node types with live validation
- Lanes for each team, role or system
- 100-step undo and named checkpoints
- Fork, tag, diff and three-way merge
Worker data
Each worker carries its own data layer.
- One schema per worker
- Generated or imported data, 200k rows
- Reference files and a knowledge graph
- Ships inside the export when used
Test and evaluation
Evidence produced before export.
- Single-node runs, restart from any point
- Mocks: happy, empty, error, timeout
- Simulation lab for several workers
- Golden-set, A/B and benchmark scoring
Integration code
Thousands of catalog entries, plus generated call code.
- Starter SAP, Oracle EBS, Workday, Salesforce, ServiceNow actions
- Generic web API and tool steps
- API-spec import, read-only queries
- Trigger scaffolding: schedules, webhooks and streams
Approval gates
Each gate holds the run for a reviewer's answer.
- Bundled inbox app; engineers wire it
- Reviewers by role, team or variable
- Maker-checker: no self-approval
- Per-tool approval inside AI steps
Security and secrets
Controls selected at design time.
- Optional PII masking module
- Component threat model per export
- Fail-closed policy steps (opt-in)
- Eight secrets-manager backends
Runtime surfaces
How callers reach the exported worker.
- Callable API with health checks
- Access sits behind your network controls
- Optional chat widget and tool server
- Infra code for clouds and containers
The package
A complete project with no tie to Nxgyle.
- Source plus workflow definition
- Manifest, ownership tab and PDF
- Signed AI-BOM with an offline verifier
- No license check, meter or phone-home
Nine claims to test in a session.
Bring your architects; we will demonstrate any of them live.
No template catalog: every worker is generated from your context
Five archetypes scored on six weighted criteria, one recommended
Policy compiled into fixed rule checks that make no AI call
Mock mode covers tool and connector calls; live systems stay out of it
Approval gates that persist state and resume exactly once
Fork, tag, diff and three-way merge for every worker version
Optional intake from event logs, process diagrams or agent code; API-spec upload
Eleven model providers, chosen per step, local models included
Every export: build check, threat model, signed AI bill of materials
Changelog highlights.
- Inputs
Per-worker data layer
A data model, generated or imported records, reference files, a knowledge graph and seed memories for each worker, every part able to ship in the export.
- Quality
Generation guardrails
Intake captures rules and decisions explicitly, failed designs are re-prompted, a rule-direction lint catches inverted logic, and a readiness score tracks progress.
- Approvals
Gates in test runs
Test runs that pause at gates and resume, an actions page listing every paused run, and governed actions that only simulate execution.
- Review
Review artifacts
Swimlanes by role, team and system, plus an ownership tab, a manifest and a stakeholder PDF generated before download.
- Connectors
Auth flows for connections
Connection code that ships inside exported workers, generic web API steps, and enterprise authentication: token-based client credentials, signed requests, client certificates and service accounts.
- Hosting
Deployment code
Optional deployment templates, CI pipeline files and cloud targets from AWS to Snowflake, plus API, chat-widget or tool-server delivery.
Disabled unless configured.
Studio modules, off by default
- Red-team scorecards that never block export
- Voice intake and a conversational assistant
- AI-assisted graph edits
- HIPAA, GDPR and SOX policy packs, plus a console
- Event-log discovery; diagram and code import
- Formal structure checks and lineage tracking
Export-time options
- Slack approval DMs; one supported email service
- PII masking (optional module)
- Upgrade baseline for regeneration
Exports come in one programming language only, for now.
Six roles, one graph.
Each sees the same versioned graph through a different view.
Business Strategist
VP Ops, COO
Choose which processes to automate first
Technical Architect
Enterprise architect, CTO
Approve graph structure, security and integrations
AI/ML Engineer
ML engineer, data scientist
Set models, prompts and evaluations per step
Platform Engineer
DevOps, SRE
Build, deploy and observe the exported code
Product Manager
PM, product owner
Plan releases across the worker backlog
Citizen Automator
Business analyst, ops lead
Draft workers through the guided path
“What exactly did we receive?” Verify it offline.
Each export carries a signed AI bill of materials: models and providers, agents with prompt hashes, connectors, tool-code hashes and dependencies. The signature covers a hash of every file, and the bundled verifier checks it offline. Model weights and datasets are not listed, and the signature proves integrity, not compliance.
The threat model lists bundled controls for your team to verify, and the EU AI Act file is a documentation template, not a conformity assessment. Neither blocks an export.
Does the code call Nxgyle?
No. It holds no Nxgyle endpoints, credentials or telemetry SDK, and outbound calls go only where you configure. Your team holds the keys and the source.
What is in the ZIP?
A standard web service, the workflow runtime, data models, agent and tool source, tests, a container definition, a sample environment file and a README. One script starts it locally; your team builds the image.
Can we host the studio?
Exported workers never needed us. Studio self-hosting is licensed on request, with container-cluster and air-gapped install options; it still requires model endpoints and offers no SSO.
For an architecture review, request an anonymized export file listing, the generated README and a sample test report from the Trust Center.
The package, in numbers.
Figures reflect the delivery catalog published on this site. A digital worker is software that carries one business process from intake to outcome, following your rules. You receive full source code, not a repackaged bot or script.
Nx·Studio generates, tests and exports the workers as source code. Nx IDE puts specialist AI roles inside VS Code for the surrounding code. The Cognitive Engine, a separate prototype, takes over routine cases only when its rules score perfectly on held-out cases.