When an AI result changes, “go back to the data that produced the earlier result” sounds like a straightforward instruction. In a Databricks environment, it is not one operation.
The relevant history may sit in a Delta table, an operational Lakebase database, or the execution record for the model or agent. Databricks Time Travel, RESTORE, Lakebase point-in-time branching, and MLflow each recover or record a different part of that history.
Syntitan addresses a related but separate question: which data state was approved for the AI task, and how was that state connected to the run under review?
The distinction matters because historical access and run-level evidence are not interchangeable. Databricks can help a team return to an earlier table or database state. Syntitan is designed to qualify the data for a selected AI task and preserve the path from Release State to Run Binding, Diff, and Reproduce. A production investigation may need both layers.
What Databricks Time Travel establishes
Databricks table history records operations that modify supported Delta Lake and Apache Iceberg tables. Time Travel can query a table by version or timestamp, allowing a team to inspect an earlier state without replacing the current table.
RESTORE performs a different job. It returns a table to a previous version by creating a new current state based on that historical version. Querying an earlier version supports inspection and comparison. Restoring changes the table that downstream work will see.
Both operations depend on retained history. Databricks notes that the required transaction log and data files must still exist, and it does not position table history as a default long-term backup strategy. Before relying on Time Travel during an investigation, the team has to confirm that the target version is still recoverable.
For an AI workflow, these controls answer a narrow but valuable question: what did this table contain at the selected version or time? They do not identify every other table, file, feature transformation, or reference input used by the AI execution.
What Lakebase point-in-time branching establishes
Lakebase operates on a different object. A point-in-time branch creates an isolated branch from an earlier moment within the configured restore window. The production branch remains unchanged.
That distinction is useful when an application, agent, or model depends on operational records stored in Postgres. A team can inspect the earlier database state, compare it with the present state, and run tests against the branch without rolling production backward.
The branch still has a defined boundary. It represents the operational database state available within its restore window. It does not automatically identify external files, Delta tables, feature pipelines, prompts, model artifacts, or evaluation settings that may also have shaped the AI result.
Time Travel and Lakebase therefore provide two kinds of historical evidence:
- Time Travel and
RESTOREoperate on supported table history. - Lakebase point-in-time branching operates on an operational Postgres database.
Neither control should be used as shorthand for the complete data state of an AI run.
The missing question is whether the state belongs to the run
Historical recovery tells a team what data existed. An AI investigation has to establish more.
First, the team must know which combination of data was approved for the selected task. A recoverable table version may still be incomplete, inconsistent with a companion source, or unsuitable for the evaluation being performed.
Second, that approved state has to be connected to the execution before the result is challenged. Otherwise, the team is reconstructing the likely input after the fact rather than resolving the state that the AI actually received.
This is the boundary between Databricks historical controls and Syntitan. Time Travel and Lakebase recover the relevant storage state. Syntitan addresses task-specific data readiness and the evidence that connects an approved data state to an AI run.
run
Which approved state reached it?
- Release State
- Run Binding
- Diff
- Reproduce
Recovery shows what existed. Run evidence shows what produced the result.
How Syntitan organizes task readiness and run evidence
Syntitan begins with the requirements of the selected AI task. It diagnoses the data across six readiness axes: Usability, Integrity, Context, Consistency, Reproducibility, and Traceability. Get AI-Ready addresses identified gaps before the evidence path proceeds through four operating steps:
- Release State fixes the data state approved for the AI task.
- Run Binding connects the AI execution to that Release State.
- Diff compares released states to identify what changed.
- Reproduce restores the recorded state for a controlled rerun of the investigation.
The sequence does not replace Delta table history, Lakebase branching, or MLflow tracking. It adds a task-level record: the approved data state tied to the execution.
For a controlled data-side comparison, the team holds the selected task, model or agent, evaluation set, and relevant execution conditions constant while changing the data state. A material change in the result gives the team a reason to examine the data differences. Little or no change is also useful evidence because it shifts the investigation toward the model, prompt, code, tools, or runtime instead of treating data as the presumed bottleneck.
These terms describe Syntitan’s current product model. They do not independently prove that every AI result will reproduce or improve. The model, code, seed, dependencies, runtime, prompts, and evaluation configuration still require evidence from the systems that own them.
Compare the evidence, not the feature count
| Decision question | Databricks control or record | Syntitan control or record | What the evidence supports |
|---|---|---|---|
| What did a Delta table contain earlier? | Time Travel query | Not a replacement for table history | Inspection of a historical table version or timestamp |
| Should the current Delta table return to an earlier state? | RESTORE | Not a replacement for table recovery | An approved table-level recovery action and its recorded history |
| What did the operational database contain earlier? | Lakebase point-in-time branch | Not a replacement for database branching | Inspection or testing against an isolated historical Postgres state |
| Was the data suitable for the selected AI task? | Historical access contributes source evidence but does not establish task readiness by itself | Six-axis diagnosis and Get AI-Ready | A task-specific readiness decision with stated criteria |
| Which approved data state reached the AI execution? | Logged dataset references and run records can contribute evidence | Release State and Run Binding | A resolvable connection between the approved state and the run |
| What changed between approved states? | Comparison depends on the stored object and the team's implementation | Diff | The data changes under review between released states |
| Can the data-side investigation be rerun? | Time Travel, RESTORE, or a Lakebase branch can recover historical inputs | Reproduce | A bounded rerun using the recorded data state; full execution evidence remains necessary |
The table is not a product ranking. It is a control map. Databricks owns the platform and storage operations described in its documentation. Syntitan addresses the task-level qualification and state-to-run evidence that historical access does not establish on its own.
Example: one AI result, two Databricks histories
Consider a recommendation model that reads a Delta feature table and recent transactions from a Lakebase application database. After both sources are updated, the model produces a different ranking.
Time Travel can expose the earlier feature-table version. A Lakebase point-in-time branch can expose the earlier transaction state. Those controls recover two important parts of the input path.
The investigation still has to prove that those two historical objects formed the approved combination used by the earlier run. It also needs to determine whether the data met the selected task’s readiness criteria. That is where Release State and Run Binding change the investigation from reconstruction to resolution: the team can identify the approved state behind the execution rather than infer it from timestamps alone.
In that controlled comparison, Diff identifies the data changes under review, and Reproduce supports a bounded rerun from the recorded state. Neither step captures an execution condition that the team failed to preserve.
Where MLflow fits
MLflow on Databricks can record parameters, metrics, artifacts, code versions, and datasets for model-development and evaluation runs. That record complements Time Travel, Lakebase, and Syntitan because it covers parts of the execution that a historical data object cannot explain.
Its evidentiary value depends on what the team logs. A dataset reference helps only when it resolves to the intended state. An experiment record cannot describe an external input, transformation, or runtime condition that was never captured.
A defensible investigation connects three records:
- the historical table or database state;
- the execution record for the model or agent; and
- the task-level evidence showing which approved data state reached that execution.
The AI reproducibility evidence boundary remains important. Returning to the same data supports a controlled comparison, but it does not freeze every condition that can affect the result.
Use the missing evidence as the architecture decision
Start with the question the team cannot answer.
- Use Time Travel when the investigation needs to inspect an earlier Delta table without changing the current state.
- Use
RESTOREwhen the team has approved a table-level recovery and understands the downstream implications. - Use a Lakebase point-in-time branch when the investigation needs an isolated historical operational database.
- Use MLflow or the current tracking system to preserve the execution details it can record.
- Use Syntitan when the unresolved decision concerns task readiness, the approved Release State, or the state-to-run path through Run Binding, Diff, and Reproduce.
The stronger architecture does not force one control to perform another control’s job. It preserves the boundary between historical storage, execution tracking, and task-level evidence, then connects the records needed for the investigation.
For the broader platform boundary, see Databricks vs Syntitan: governing the estate, reproducing the run. The narrower decision here concerns what Time Travel and Lakebase can recover and what Syntitan adds when the team has to explain a specific AI result.
Historical recovery is not run evidence
Databricks Time Travel can recover a historical table state. Lakebase can expose a historical operational database. Both are valuable when an AI result changes.
Syntitan addresses the next question: whether the data was ready for the selected task and which approved state reached the run. That distinction turns historical recovery into one part of an evidence path rather than the final explanation.
Know which approved data state produced the result before the next AI decision. See how Syntitan connects AI-ready data to run evidence.
