Nx·Studio designs and rehearses digital workers, then exports each as a complete codebase you build and host. Nx IDE runs 31 permission-ruled AI modes within the VS Code editor and, by default, holds each editor action for approval. The Cognitive Engine, a separate prototype, decides a routine case only after a rule clears its exam.
Each export is a ZIP with the worker's agents, tools, tests, a container definition, README and workflow definition, plus the runtime source it needs. Your team builds and runs it; Nx·Studio itself never runs production workloads.
Each design carries an AI-estimated monthly run cost, and the cost view prices every step per run and per case. Rehearsal traces then record actual token and cost totals.
Exported workers have no license check, no metering and no phone-home. Outbound calls go only to the AI providers and connections you configure, and export to your own monitoring stack is disabled unless you switch it on.
Optional deployment templates, including container orchestration, and CI scaffolding are off by default. Deploy targets only generate infrastructure code; Nxgyle never applies it or holds your cloud credentials.
Plan, Code, Debug, Orchestrator, Tester, Reviewer and Shipper anchor the 31 built-in modes. The Tester and Reviewer receive just the requirement and file list, and the Shipper commits to a feature branch, never to main.
Point each mode at hosted, private or local models, including your own compatible endpoints. Code and prompts travel straight to that provider; Nxgyle runs no proxy, and license validation happens offline.
By default every editor action pauses for approval, and allow, ask or deny rules can only be tightened per repository. The command-line version auto-approves unless approvals are explicitly required.
Cortex indexes the repository on the workstation with no network calls or API key, and grades each change's impact from LOW to CRITICAL.
Sign-off gates, confidence thresholds and hand-off points sit in the blueprint before launch, each routed to reviewers chosen by role, team or variable. Paused runs persist and resume exactly once.
Every execution writes a run log with its token and cost totals. A tamper-evident audit log and field-level lineage are opt-in, and auditors may request the audit-trail specification.
The signature covers every exported file's hash and verifies offline. Without your own signing key, the Studio signs with a temporary one.
Mock mode answers tool and connector calls from happy-path, empty, error and timeout packs with no network. It ships with the worker for your own test runs.
A written brief becomes source code your own pipeline builds and runs. Each stage below states what it produces and how your engineers can verify it.
Start from a paragraph of text, the 10-step wizard, uploaded documents up to 25 MB or a dataset of up to 200,000 rows. Optional intake also reads process-mining logs, process diagrams and code from agents you already run. Uploads serve worker design only; the terms for handling them are settled before work starts.
Uploaded context is flagged for prompt-injection patterns, and no stage requires production records: every rehearsal can run on synthetic data.
The AI analyst proposes one design per archetype (conservative, balanced, ambitious, cost-optimal and compliance-first), scores each on six weighted criteria from fitness to scalability, and flags its recommendation. Failed designs are re-prompted or dropped. Integration draws on a reference catalog spanning thousands of APIs; curated entries for SAP, Oracle EBS, Workday, Salesforce and ServiceNow arrive as starter code your engineers complete. Any system with a documented web API, or one that exposes an AI tool server, can be called directly.
Eight sector starter packs give a head start, and every design opens as a full blueprint on the canvas, with 100-step undo and named checkpoints, before any run.
Each worker gets a synthetic dataset generated for its own process, and mock mode answers every tool and connector call. Run one step or the full flow; sign-off steps pause the run until someone answers on the Studio's actions page. The simulation lab runs a group of workers concurrently on accelerated virtual time, and an optional red-team module returns an attack scorecard without blocking export.
Golden-dataset, A/B and benchmark harnesses evaluate runs, and a single scenario can pit up to three versions against each other. Deterministic replay of a run is available as an opt-in.
Export streams a ZIP that contains the entire codebase, but only once the always-on build check passes. Build the container from the included definition and deploy it on your own cloud or on-premises hardware. It runs on any of eleven supported AI providers, including models you host yourself. The code carries no license check, no meter and no phone-home.
What each export containsThe signed AI bill of materials lists model IDs, agents with prompt hashes, connectors and dependencies, and a bundled verifier checks the signature offline. The same ZIP holds a threat model built per component and an ownership manifest.
Nx·Studio is design-time only: it dry-runs each worker, then exports a complete code project with the workflow runtime inside. Nx IDE is a VS Code extension under allow, ask and deny rules. The Cognitive Engine is a standalone engine; applications call it via the Cognitive Studio. The Foundation is the evidence in every export. Each runs on its own, with no coupling between them.
A design-time studio. Its AI analyst turns a process brief into up to five scored designs, dry-runs the chosen one against mock systems, then exports a buildable project.
A VS Code extension with 31 modes on 20+ model providers. In the editor each action waits for approval by default, while the CLI approves automatically.
A standalone engine. Rules learn from host-verified outcomes, need six reasoning checks to concur, pass a 400-plus case held-out exam, then answer without a model call.
Four mechanisms in every Nx·Studio export: mock-backed dry runs, coded rules, a versioned blueprint and a signed AI bill of materials your team verifies offline.
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.
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.
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.
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.
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.
Most agent stacks buy a model call for every decision, including the repeat ones. The Cognitive Engine runs beside those agents and trains solely on outcomes your systems mark as verified. A rule is released only after a held-out exam of at least 400 unseen cases with zero mistakes and all six built-in reasoning checks in agreement. Released rules respond within milliseconds and make no AI call, and every decision returns its route, plan and checks.
External callers use the decision API exposed by the Cognitive Studio; the engine has no web API of its own and is not part of Nx·Studio. Every measurement so far is synthetic.
It learns from feedback your systems mark as verified; a teacher model's answers never count as proof.
Defaults require 400+ held-out cases with zero errors and six checks agreeing; hosts may raise them, never lower them.
Released rules respond in milliseconds, and the same release returns the same answer for the same facts.
Unfamiliar cases go to a person, missing facts prompt a request for more, and uncertain tool results stay blocked, never blindly retried.
Each worker's blueprint is the source of truth for its steps, connections, sign-off gates, routing and rules. Every save is a version you can branch, tag, diff or merge, and none of it hides inside prompts or a vendor runtime.
Illustrative: v12 to v13 changes one sign-off rule, stated in plain words. Engineers three-way merge blueprints as they would source files, process owners see the logic as swimlanes, and auditors get a written summary of what was built. The Studio lints each save, and export compiles the blueprint into the worker's code through the always-on build check. Nothing about it is rented.
In an exported worker, spend comes from its AI steps, fan-outs and loops. Rule and set-state steps cost almost nothing because they never invoke a model. Ahead of any build, the Studio's cost view prices each step from assumed token counts against a curated price list, per run, per case and per month. It also flags AI steps a plain rule could replace.
Each step can use its own model, with fallbacks and cheaper or stronger tiers you choose; local models record zero cost. Optional limits cap steps and time per run, though no token or dollar cap exists. Repeat decisions can move to the Cognitive Engine, which is sold separately and is not part of Nx·Studio workers.
The exported code contains no runtime license or usage meter, so volume moves only your own hosting and AI-provider bills. Each run records its token and cost totals for your own reporting.
Our pricing follows the architecture. We are paid for design and delivery, never per call. A usage-billed vendor gains as your dependence grows; we gain when your team can run the code without us. Support after hand-over is optional, on terms you set.
Rule and set-state steps evaluate in code, so they never reach a model or its bill.
Each design shows an AI-estimated monthly run cost and hours saved, with a payback figure only in the generation plan. Rehearsal traces then record each run's actual token and cost totals.
Exported workers contain no license check or usage meter, so scaling changes only your infrastructure and AI-provider bills.
Bring these to your architecture and security review. We publish them so your engineers can hold us to them.
Can your engineers read the worker's logic as a versioned artifact before it runs?
Which components stop running if the vendor's service or contract ends?
Do you receive the full source, tests and build files, or console access only?
Which costs scale with call volume, and which only with your infrastructure?
If the model provider changes or degrades, do rule-based decisions keep working?
How are crafted inputs and prompt injection screened, and is that on by default?
Can you verify that the package you deploy is the one you tested?
Can every external dependency be mocked so tests run with no live connection?
Does any evaluation step require production data?
Which approval gates are enforced in code, and which timeouts are only declared?
Can your engineers check for lock-in offline, on their own hardware?
Is each number in the bid tied to a stated measurement method?
We answer all twelve above.
Across this site, three words carry a precise technical meaning. This is how your engineers should read them:
A deployable web service that carries one business process from intake to outcome, under coded rules and sign-off gates.
The versioned definition of a worker's steps, rules, gates and routing, exported alongside the code.
A ZIP of the full project, with tests, a container definition, README, threat model and signed AI bill of materials.
See a sample export's file treeFull business applications, engineered end to end and delivered for rebranding.
Each automates one defined process under set rules and ships as source code.
Led by finance, manufacturing and healthcare, with construction, energy and telecom.
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.
Nxgyle scopes, builds and exports the workers and can stay on for upgrades; your engineers receive repository-ready code, tests and evidence.
A dedicated team builds custom agent systems and the services around them, to your architecture standards.
Engineers and AI specialists join your squads and work in your repositories, under your review process.
