Docs Concepts
Concepts
Revisions and the timeline
Every completed sync seals a revision: a read-only record of everything in the workspace at that moment. Kumo.io keeps them, so you can look back at an earlier revision and compare any two.
What a revision is
When a sync finishes, Kumo.io doesn't update your workspace in place. It seals a new revision: every resource, every connection between resources, and their settings, as they were at that moment. A revision is never edited afterwards. If something was wrong, the next sync seals a corrected revision, and the earlier one stays as it was.
A revision covers the whole workspace. It combines the latest sync of every source in the workspace, so syncing one source seals a new revision that still includes what your other sources last found.
Inside a revision, Kumo.io records a new version of a resource only when that resource actually changed. Resources that didn't change carry over unchanged.
Find revisions in the web app
The web app calls revisions snapshots. To see them:
- Open Workspaces and choose a workspace.
- Open the Inventory tab and go to Snapshots.
Snapshots are listed newest first. Each one shows:
- Snapshot # followed by its number. Numbers go up by one with each revision, and the newest carries a latest badge.
- When it was sealed, and how many source snapshots it was Composed from (one per source that had synced).
- Compare With Previous, which opens a comparison with the revision before it. Comparing revisions needs the Business plan or above. See Changes and diffs.
- Technical Details, with the Snapshot ID and State Hash, each with a copy button. The snapshot ID is the revision id that the API and CLI use.
Select a snapshot's number to open it and list the resources it contains.
Diagrams have their own Snapshots menu. A diagram snapshot is one rendering of that diagram, drawn from a revision. See Views and diagrams.
Look back at an earlier revision
- A whole workspace: open an earlier snapshot from the Snapshots list.
- A diagram: open the diagram's Snapshots menu and pick an earlier rendering. The bar under the menu says Earlier snapshot and offers Open Latest to return. An earlier rendering is read-only.
- One resource, from the command line:
kumo resource showreads a resource at a given revision, or at a point in time on a self-hosted installation:
kumo resource show --workspace <workspace-id> --id <resource-id> --revision <revision-id>
kumo resource show --workspace <workspace-id> --id <resource-id> --time 2026-06-30T09:00:00Z
--time isn't available when the CLI talks to kumo.io; use --revision there. kumo revision list lists a workspace's revisions.
How Kumo.io handles resources it didn't see
A resource missing from a sync isn't necessarily deleted. The credential might have lost access to a region, or a sync might have failed part-way. So Kumo.io only marks a resource as deleted when the sync had full coverage of the place it lived: the right account, region, service and resource type, read successfully. Anything else that is merely missing is carried forward.
Kumo.io also records how complete each revision is:
| Assessment | Values | What it tells you |
|---|---|---|
| Coverage | complete, partial, unknown | Whether the sync read everything it was meant to. With partial coverage, don't read too much into something being absent. |
| Freshness | current, mixed, stale, unknown | Whether the data is up to date. |
When you compare revisions and either one is less than complete or current, the comparison page shows it. A removal that might only be a gap in coverage is labelled Removal may be a coverage gap rather than reported as a deletion.
How long revisions are kept
Kumo.io doesn't delete or compact revisions on its own. They stay until a retention policy compacts them.
Your plan sets the longest window a retention policy can keep full detail for:
| Plan | Retention window |
|---|---|
| Team | 90 days |
| Business | 180 days |
| Enterprise | 365 days |
| Enterprise (Licensed) | 365 days |
Retention policies are set per account through the API, at /v1/accounts/{accountId}/retention-policies. Creating a policy that keeps revisions longer than your plan's window is refused, and if your plan changes, existing policies are held to the new window. Policies run once a day. A compaction policy (target compact_revisions) compacts revisions older than its window. Kumo.io still knows that a compacted resource existed and when, but drops its details, including its name.
See Plans and limits.
What revisions are not
- Not a backup. A revision records your infrastructure's configuration and how it connects, not the data stored in it.
- Not a record of every change. Kumo.io records the state at each sync. If something changed twice between two syncs, you see the net difference. How often you sync sets how fine-grained your history is. See How syncing works.