Your auditor’s first question, already answered.
A model wrote it, nobody reviewed it, and it is already running on production data. When the auditor asks what ran and who approved it, there is no answer. Overnight makes that answer a matter of record.
The answer is written as it happens.
Every call an app makes is recorded against an identity while it runs, refusals included. Nothing is reconstructed later from logs that were never designed to be evidence.
A compliant runtime is an execution environment where AI- and agent-written software runs with isolation, a complete audit trail, and policy enforcement applied by default, before the code touches real data. The controls are structural and always on, so what happened inside is something you can prove to an auditor.
When the request arrives, from an auditor, a customer, or your own security team, the work is an export you can run in an afternoon.
- 01the audit trail
What ran, under whose identity, against which approved version
If an auditor asked tomorrow what an AI-built app did to your data last quarter, most teams would be assembling the answer out of server logs that were never meant to be evidence. Overnight writes it down while it happens: the app, the identity behind it, the exact version that ran, every change it made and every outside call, and the person who approved it.
Refusals go into the same record, which is often the half that matters. A question about one customer over one date range becomes something you can answer the same afternoon, and the record is kept for 12 months in a tamper-evident archive you can check yourself.
- 02layered enforcement
Isolation enforced beneath the workload, not opt-in for it
Every control here holds whether or not the generated code cooperates. Each workload runs inside its own sandboxed boundary, with separation enforced beneath the operating system the app can see, and there is no default route out. Logins for the tools your app connects to never reach it: calls go through Overnight, which holds the token. Other secrets are encrypted and handed to the app only when it runs, and every system call passes through a sandbox first.
That is also what settles the question most platform engineers ask second. The Refinery hardens the code before it runs, but it was never the thing holding the line, and code that skipped it entirely still has nowhere to go and nothing to authenticate with.
- 03per-tenant isolation
Every customer gets a dedicated tenant of their own
Your data sits behind walls of its own: your own database, your own sandboxed workload boundary. That separation is structural, enforced underneath the code, which matters precisely because a model wrote that code. A dropped tenant check has nothing to reach.
The network edge in front of that boundary is shared infrastructure across every customer today. We disclose that rather than leave it for you to find, because the isolation claim above is about your data and your workload, not every component in front of it.
- 04inherited controls
The boundary carries the controls for every app inside it
Isolation, identity, logging, retention, and egress policy belong to the runtime. Your apps do not implement them and cannot opt out of them, which is how one security review comes to cover the fiftieth app as well as the first.
Overnight is built with the controls auditors look for: company identity (SSO) on every app, approval before anything goes live, a tamper-evident audit log, and outside access blocked unless you allow it. The runtime enforces them once, so nobody assembles them again for every new workload. Where any certification stands today is something we will tell you directly, in writing.
Ask us where we stand → - 05past the sandbox
Where a sandbox stops being enough
A sandbox answers whether code can run without touching the host, and it is the right tool while an agent iterates. The question changes the moment that software points at real customer data, because now you have to show what it did and who approved it, weeks after the fact.
That needs a tenant which persists, a record that outlives any single execution, and someone willing to stand behind it as your subprocessor. Most mature teams run both: a sandbox in the build loop, Overnight at the production boundary.
The clean line between them → - 06what it costs you
One mediated hop, and your code stays yours
Overhead lands on calls that cross the boundary, where a policy decision has to happen anyway. Work an app does inside its own process runs untouched, so for the internal tools, reports, and data jobs teams build here, the mediated hop is rarely what determines how long anything takes.
Your apps are your own code, and they leave with you whenever you want. The audit trail exports too, because a record you cannot take with you is worth little to an auditor in year three.
- 07subprocessor of record
One accountable subprocessor
Someone has to be accountable for what runs on your data, and the tool that generated it will not be, because its responsibility ended the moment the code existed. Overnight signs on as your runtime subprocessor of record.
We own what executes, so we can be named as your subprocessor. That gives the question which stalls most security reviews an actual party to point at.
Make your next audit boring.
Approve the boundary once. Every app that runs inside it inherits a posture you can defend in the room.