Pilot changes production infrastructure without a person reviewing each change. Here is what keeps that safe, and where the guarantees stop.
Pilot proposes; an engine decides
Pilot has no shell, no cloud SDK and no credentials of its own. It can only submit transactions, and each one passes through an engine that is ordinary code:
- Capability: only this fleet's resources; never the intents or boundaries.
- Rules: the provider's schema; the spec's bounds, cost ceiling and boundaries; autoscaler ownership; at most half of any capacity removed per change; delete only what Pilot created; irreversible operations, including undoing a create, need a named person. Pilot changes only the properties its profile for a type lists; anything else on a resource needs an approved operation. A protected resource's autoscaler and triggers are protected with it. Every stage of a staged rollout passes the same rules.
- Preconditions: if anything changed since Pilot read it, the change is refused.
- Change budget: refills only while objectives are met.
- Health gate: after a change, the resource is checked; on failure the change is undone automatically.
None of this is a prompt. A wrong or manipulated model still can't get past the engine, or beyond the role you created.
The ledger
Every change, refusal, check, undo, outside change, request and answer is appended to a ledger. Each entry carries the SHA-256 hash of the one before. GET /api/workspaces/<id>/ledger/verify recomputes the chain and replays it. GET /api/workspaces/<id>/export gives you all of it.
One sandbox per workspace
Each workspace's agent runs in its own container, on Cloudflare Containers: its own virtual machine.
- a non-root user, with memory and CPU limits
- its disk is discarded whenever it restarts; what it keeps between runs is in that workspace's state, which no other workspace's agent can reach
- nothing listens inside it, and the only parts of Infrapilot it can reach are its own workspace's state and the model gateway
- no internet access of its own: the only outside hosts it can reach are your cloud provider's API hosts (below)
- only that workspace's cloud credentials
It never holds other customers' data, Infrapilot's database, the encryption key, or Infrapilot's model key. Model calls use a per-workspace gateway token that is replaced each time the agent starts and revoked when it is stopped, with a daily ceiling on calls and on what they cost.
What a sandbox can connect to
Being switched on during the alpha. The list below is in place and every outbound request is checked against it. Until it has run cleanly against each cloud, a request to a host off the list is logged for Infrapilot's operator and forwarded, not refused. This note is removed when refusal is on.
The network enforces it, not the agent's code. The container has no route to the internet. Every HTTP and HTTPS request it makes is handed to Infrapilot's code outside the container, which forwards it only if the host is on the list for your workspace's cloud, and only over HTTPS:
| Your cloud | Hosts |
|---|---|
| AWS | *.amazonaws.com, *.api.aws |
| Azure | login.microsoftonline.com, management.azure.com |
| Google Cloud | *.googleapis.com |
A workspace gets one row: an AWS workspace cannot reach Google's APIs. Anything else is refused and logged with the workspace's id: other websites, package indexes, a model provider (model calls go through the gateway), redirects that lead off the list. Other ports and protocols do not leave the container at all, and its DNS lookups never reach a public resolver.
What this does not do: the list is by host name, so it allows your provider's APIs as a whole, including API hosts of accounts that are not yours. What Pilot can do there is decided by the credentials it holds, which are yours and scoped to your role. The request is opened by Infrapilot's code to apply the list (the container trusts a short-lived certificate authority that the platform creates when the container starts), so the list is applied to the real destination, not to a name the container claims.
Cloud credentials
| Cloud | Access | Infrapilot stores |
|---|---|---|
| AWS | assumes your IAM role with a workspace-unique external id, an hour at a time | the role ARN. No keys. (Access keys are accepted if you choose them, stored encrypted.) |
| Google Cloud | impersonates a service account named for your workspace, an hour at a time | the account email. No keys. (A key file is accepted if you choose it, stored encrypted.) |
| Azure | an app registration that trusts Infrapilot's signed tokens for your workspace's subject only (a federated credential) | no secret: the tenant, app and subscription ids |
Infrapilot's control plane obtains the hourly credentials, or decrypts the stored secret, and hands them to your workspace's sandbox and to nothing else.
Tokens (sign-in links, sessions, setup and API tokens, answer links) are stored only as hashes. API tokens expire (90 days unless you choose otherwise) and can be listed and revoked. A setup token becomes read-only once Pilot has completed its first review.
To cut Pilot off, delete the role, service account or app registration. Everything keeps running as left.
Payments
You pay on Stripe's page; card details never reach Infrapilot. If a subscription ends, Pilot stops changing things but keeps watching and recording. Nothing is removed for non-payment.
People
- Sign-in is by emailed link. Sessions are HttpOnly cookies; state changes must come from Infrapilot's own pages.
- Only people change intents and boundaries. Approvals are recorded by name. A change made with a token is recorded under the workspace owner's name, with the token it came through.
- Only the owner adds or removes members and deletes the workspace. Removing someone ends their access and their answer links.
- Email answer links are personal and expire after a week. Anyone holding one can answer that request, so treat a forwarded one like a forwarded approval.
- The Slack app keeps one bot token per installation, encrypted and never returned by the API. It can post in the channel you picked (and other public channels), edit its own messages, and read the profile of whoever presses Approve or Deny; it cannot read messages, files or channel lists. A press must carry Slack's signature, be under five minutes old, name that one request in that channel, and come from a member of the workspace, matched by the email address on their Slack profile. Your Slack workspace's admins can change that address, so they could approve as a member. Removing the app in Settings revokes the token.
- A pause stops the next change, including inside a review that is already running. Pilot keeps observing and recording but decides nothing.
- Infrapilot's operator can pause Pilot in your workspace, undo one of its changes, or give up Infrapilot's access to your account, when something has gone wrong. Each is recorded in your ledger or notifications under the name
operator@infrapilot, with the reason. An undo is checked by the engine like any other change, and an irreversible one needs the name of the person on your side who agreed to it. - An approved operation runs only if the resources are unchanged since Pilot asked.
Limits of these guarantees
- A role that allows too much. The engine enforces the spec; your cloud enforces the role. Grant only what the provider page lists.
- A spec that asks for the wrong thing. A ceiling set too high is respected as written.
- Outside changes. Detected, attributed and kept or reverted, but not prevented.
- Resources Infrapilot has no price for count as zero toward a ceiling. Under a ceiling, Pilot does not create them or raise their capacity or size; a person can approve it.
- Secrets in plain configuration. Plain environment-variable values and secret-named fields are hidden: they are not recorded, shown to Pilot, or changed when Pilot updates the resource. Because they are hidden, a change someone else makes to one is not detected as an outside change. Use your provider's secret manager anyway.
- Text Pilot reads. Resource names and settings, error messages and notes from people reach the model marked as data, never as instructions, and the engine applies the same rules whatever the model was told. A model can still be misled by what it reads; the rules above are what bound the result.
- Secrets in a workload's
specwould be recorded. Pass a reference instead. On Azure, a change carrying a Container App secret value is refused.