We only ship what survives our own attacks.
Before a Nexgile digital worker is exported, its design can be read, its behavior is tested on made-up data, and its structure is checked against safety rules. This page says how you can verify that, and what we haven’t earned the right to claim yet.
- GDPR EU data protectionIn place
- CCPA California privacyIn place
- Encryption (TLS / at rest) In transit & at restIn place
- Human-in-the-loop Oversight & approvalsIn place
- SOC 2 Type II Security & availability Top of the roadmap — target date: being finalized.Roadmap
- ISO/IEC 27001 Information securityRoadmap
- ISO/IEC 42001 AI management systemRoadmap
- VPAT / WCAG 2.2 Accessibility conformanceRoadmap
You’ll notice some chips say Roadmap. That’s deliberate. We publish what’s true, not what’s aspirational — and every claim on this site is labeled the way we label these. Top of the roadmap: SOC 2 Type II — target date: being finalized. While certifications are in flight, here’s what we offer today instead: self-hosted deployment inside your existing compliance boundary, the audit-log specification, and sanitized export artifacts your security team can review on request.
“In place” reflects controls and protections active today. “Roadmap” marks formal third-party certifications we are actively pursuing — we do not claim a certification before it is awarded. Contact security@nexgile.com for current status and documentation.
Security, engineered into every delivery.
Every export comes with security documents generated from the worker's own design, and our own platform is operated to enterprise standards.
- Encryption in transit and at rest on our platform; you host the delivered worker under your own encryption
- Role-based access in the Studio; you place the delivered worker behind your own access controls
- A threat model, generated from the design, with every export
- Continuous monitoring, logging and a defined incident-response process
- Responsible-disclosure program for reporting vulnerabilities
Your data stays yours.
Nx·Studio is a design-time studio: workers are tested on made-up data, so no production data is required to evaluate them. After delivery you host the worker yourself: there is no Nexgile cloud in the loop.
- Test runs are designed for made-up data: the Studio generates fictional records, and anything else you add is your choice
- You self-host the delivered software on your own infrastructure
- Data residency across our Herndon, VA and Hyderabad, India operations
- GDPR and CCPA aligned; retention and deletion on request
- Sub-processor transparency available on request
AI you can explain — and defend.
For an agentic-AI company, governance is a first-class concern, not fine print. Our foundation is built to make automated decisions accountable.
- Readable designs and fixed rules, not “the model decided”
- Rule steps behave identically on every run
- Human approval steps wherever you design them
- A hash-chained audit log in the worker's runtime, being made a standard part of every export
- Your own AI provider account: the worker sends prompts only to the provider you choose
Four safeguards, built to be checked.
Every product claim on this site stands on one of these. Each is something you can check, in a live session or in the download itself, not something you are asked to take on faith.
Tested first
Each worker gets its own test data: fictional records generated to match its data, or a file you choose to import. Run a scenario and watch every step, including the moments it stops for a person’s approval, then run sets of scenarios and score the result. Because the Studio generates the data, your security team can approve an evaluation that starts from a description without sharing any of yours.
See it in Nx·StudioRules first
A decision built as a rule is evaluated by code, not by an AI model, so it can’t be flipped by “are you sure?” or a prompt trick. It gives the same answer for the same input for as long as the worker runs. AI steps are different, and we say how further down this page.
Watch rules and AI sort a morning’s decisionsA readable design
Every digital worker is a readable, versioned design, not a tangle of prompts: what it does, who approves what, and where work goes to a person. Compare versions when a policy changes, test it before it runs, and hand it to your reviewers. Before export, the Studio checks its structure and can refuse a design that breaks a safety rule.
Governance you can readOwnership you can check
The download is source code with no license check, no usage meter and no connection to Nexgile. It lists every part inside it and carries a signature over every file, which your engineers verify offline with one script. “No lock-in” stops being a slogan and becomes something you check yourself.
Verify it yourselfDon’t take our word for any of this.
Every export carries a bill of materials and a signed record of every file, with a script your engineers run on their own machine, offline. It confirms that what you deployed is exactly what you were given.
The download itself is plain source code. It contains no Nexgile address, no license check and no usage meter, and your engineers can read every line to see that for themselves.
Fixed rules get the same treatment: shown, not asserted. In any live session, ask us to run the same input through a rule twice and watch it return the same answer.
- Bill of materials every model, tool and software part in the downloadincluded
- Signed record a signature over a digest of every fileincluded
- Verify script recomputes the digests and checks the signature, offlineincluded
Runs on your own machine, offline. It confirms that the files are exactly as they were exported.
Your reviewers read what a worker will do before it does it.
Governance here isn’t a dashboard over a black box. It’s a design you can read, compare and keep.
The design is the document
Every worker is a readable, versioned design: its steps and roles, its connections, its approval points, its routing and decision rules. It is not buried in prompts and not locked inside someone else’s platform. Your engineers compare versions the way they compare code, and your governance team reads it before anything is exported.
What the worker records
Every run reports what each step did, and every AI call is recorded with its model, its size and its cost. A hash-chained audit log, in which a later edit is detectable, exists in the worker’s runtime. Making it a standard part of every export is still in development.
Approval is part of the worker you own
Where a person must decide, the design has an approval step, and the worker stops there until someone does. That step ships inside the code you own, not as a setting on our servers. A reviewer inbox with notifications is still in development.
How we handle the data you choose to share.
Test runs are designed for made-up data. The Studio generates fictional records shaped like your process, so nothing real is needed to watch a worker run.
Design-time inputs are different, and we treat them that way: if you choose to share documents or an event log to ground a worker in how your work really flows, you decide what to share, it’s used only to design your workers, and a data-processing agreement is in place before anything moves. The same goes for any file you choose to import as test data.
A description-based evaluation shares nothing at all.
What’s deterministic, what isn’t — and who decides.
Live AI judgment is probabilistic by nature.
That’s why a well-designed worker uses as little of it as it can. A decision built as a rule returns the same answer for the same input, every run, and the Studio shows what share of each design is fixed rules.
Where judgment is needed, you set a pass mark for the step and choose what happens below it: stop, flag and continue, or take another path, such as review by a person. And before export, the Studio can refuse any design in which a step acts on another system with no approval step before it.
Approval isn’t a courtesy. It’s a control.
What your auditors can request.
Every artifact below is sanitized and shared on request — write to security@nexgile.com.
A sanitized design excerpt
Rendered as a readable document, so your governance team can see what a worker will do before it does it.
A sample evaluation report
Produced by an evaluation run on made-up data: the document procurement will ask for.
A sanitized export in miniature
The file tree of a real download and a page of its generated operating guide: what you actually receive.
A sample threat model
The security document generated with every export, redacted to properties, never configurations.
The audit-log specification
The events the hash-chained audit log records, and the properties it is designed to guarantee.
A sample bill of materials and signed record
With the output of the verify script, so you can see what a clean check looks like.
Your reviewers can read what the worker will do before it does it.
Scoped on purpose. Kept on purpose.
One plain sentence each, scoped to what the platform does today, because a scoped pledge beats a falsifiable absolute.
-
Test runs are designed for made-up data. An evaluation that starts from a description needs none of yours.
-
No license check. No usage meter. No calls back to Nexgile.
-
Nothing stops working if you stop paying us.
Every number on this site comes with how we measured it. When we can’t measure something honestly yet, we don’t publish it.
The house rule covers other people’s numbers too: third-party statistics appear only quoted, attributed, and dated. Our delivery counts carry a method footnote and are re-verified before every publication. And figures that stop reproducing are retired sitewide — not quietly kept.
Reliability
Because you self-host the software we deliver, its availability is in your hands — on your infrastructure, under your SLAs. Our own platform is continuously monitored, with a defined incident-response process. A public status page for Nexgile services is on our roadmap.
Talk to the right team
- Security & disclosure security@nexgile.com
- Privacy & data rights privacy@nexgile.com
- Accessibility accessibility@nexgile.com
You generate it. You preview it. You own it. You run it.
Bring your security, risk, and compliance teams. An evaluation that starts from a description runs on made-up data, so there is nothing of yours to share on day one.