One sentence in.
A proven change out.
SnapFlow runs a change the way a careful engineer would. Plan it, check it against policy, get sign-off on the risky part, run it in isolation, prove it, then keep watching.
Understand
Cortex returns a plan you can inspect
Cortex turns "provision a Redis cluster for staging" into a typed, ordered plan before anything touches your cloud. It arrives with the exact actions, the resources they touch, what else depends on them, an estimated cost and a rollback path.
Govern
Policy runs before and during
Write the rules once. No public buckets. Production needs approval. Nothing ships on a Friday night. SnapFlow enforces them when the plan is built and again when each command is issued. Safe work runs. Risky work waits for a person who can see what they're approving.
Execute
Containers that get thrown away
Each step runs in an isolated worker on an internal network, scoped to the permissions that step needs and destroyed afterwards. An unapproved step can't obtain mutating credentials at all, because the gate sits in the credential layer rather than the interface.
Prove
Done means proven
When a step finishes, SnapFlow checks the result against your live cloud estate using real resource identifiers, rather than trusting the model's "done". Every receipt records which method was used: proved against cloud, graded, or human-confirmed.
"vpc-04b1, rds-read-replica and iam-policy-cache-ro exist, in that account, with those settings. Checked by live API lookup, not self-report."
Watch
It watches what it built, and can undo it
Every resource is tagged to its mission, so teardown is complete rather than best-effort. After a deploy, a post-deploy watch monitors the new resources and can revert them automatically when a critical incident fires.
Scheduled monitors poll your estate and raise an incident the moment something drifts from expected state.
Notify, escalate through an on-call rota, acknowledge, resolve. Slack and PagerDuty natively.
Critical incidents can trigger an automatic revert. On resolution a blameless postmortem is drafted from the flight log, with root cause flagged as a hypothesis for a human to confirm.
The Execution Core
Built LLM-agnostic
SnapFlow is not an agent looping on its own transcript. Control flow, retries and branching are governed by a state machine, not by asking a model what should happen next. That choice is what lets it run on any model, stay cheap, and hold quality as a mission gets longer.
Each step receives a scoped payload from the one before it, not the full run history. Context doesn't balloon, so quality doesn't decay on long runs.
Routine steps route to small, cheap models. Judgment-heavy ones route to frontier models. A router picks per step on cost, latency and uptime.
Steps that must return structured data are constrained to a schema at the token level. Run on frontier APIs, open models, or fully on-premise.
From our own architecture research on a simulated multi-step pipeline, measured against an unconstrained agent loop. It models the mechanism rather than customer traffic: an open loop's context grows with the square of the step count, ours grows linearly. On long missions that gap compounds.
Everything It Does
Core capabilities
Grouped the way a buyer thinks about them.
- Plain language to a typed, ordered plan
- Real provisioning on AWS, GCP and Azure through OpenTofu and Terraform
- Idempotent steps that adopt what already exists on retry
- Change-as-PR into your own repository
- Dev, staging and production as real boundaries
- Approval screens with action, blast radius, cost and rollback
- Policy-as-code checked at plan time and command time
- Results checked against the live cloud estate
- Tamper-evident receipts carrying a SHA-256 content hash
- Every resource tagged to its mission for complete teardown
- Post-deploy watch with automatic revert on a critical incident
- Scheduled monitors that raise incidents from real telemetry
- Detect, notify, escalate, acknowledge, resolve
- Postmortems drafted from the flight log
- Credits frozen up front, settled on the result
- Priced by the work a mission actually does
- A map of everything you actually run, across clouds, repos and your own servers
- Every node opens a full property page — not a truncated summary
- Console-grade actions on each resource, deletes included
- Every one runs as a governed mission, so nothing skips the approval gate
- A missing permission pauses the run — it does not kill it
- Fix it in your own console and the mission resumes itself, on any provider
- An agent out of time hands over to a fresh one with what’s left
- Credits stay held while paused: nothing charged, nothing refunded
- Hand over a migration end to end, gated separately at cutover
- Ongoing ownership of one of your own on-premises servers
- A bespoke automation built for your stack, handed back as yours to re-run
- Settled on the same verified-outcome rule as everything else