The useful change across recent AI projects is not simply that agents can write more code. It is that people are beginning to wrap agents in repeatable workflows: tools, missions, evidence, review steps, and saved state. That shift creates a practical gap for anyone using Codex or another coding agent: a human fix can exist in the working file, while a later agent task may act on an older version. One Codex user reported exactly that behavior after manually fixing small bugs; the report and its cause remain unverified.
The sensible response is a preservation and review tool. It should record what existed, identify which version an agent was given, show the proposed file afterward, and require a human decision before replacing the current file. It should not pretend to provide automatic merge support or guaranteed conflict resolution.
Why do agent handoffs need checkpoints?
Agent handoffs need checkpoints because the next task may not share the same working state as the human who made the last fix. The Codex report describes manual edits being lost when a later feature request touched the same file. A reply suggested recording file-change times and rereading a modified file before deciding whether to overwrite it, preserve it, or ask a question. That is practical advice, but it is not evidence that every Codex session behaves this way.
The broader market evidence points in the same direction. Runner 0.19.3 connects chats and missions in its sidebar, and its 55-second demo shows one Claude Code chat starting two Codex missions before receiving their reports. Sherlogram turns six months of Telegram research into an MCP service with 49 tools, including evidence collection and recurring market checks. The scan-to-vector skill moves error-prone document work into scripts, producing comparison images and reports instead of relying on an agent to notice every omission.
These projects treat the agent as one part of a larger operating procedure. The missing piece for coding files is a small, explicit boundary between “the agent proposed this” and “the human accepted this.”
What should the first version preserve?
The first version should preserve file content, version identity, author, timestamp, parent version, and the decision made at review time. A useful record can be represented as a SQLite row containing a project identifier, relative file path, content hash, full file content, source label such as `human` or `agent`, parent checkpoint, and status such as `pending`, `accepted`, or `rejected`.
The content itself matters. Storing only a timestamp or a short summary would not recover a manual fix. Python can calculate a content hash, save the complete text, and compare two checkpoints line by line. The hash is an identity check, not a semantic understanding of the code. If two versions differ, the tool can show the changed lines; it cannot decide whether both edits are logically compatible.
This design also makes the audit trail concrete. Suppose a human fixes a bug and creates checkpoint H-02. An agent then receives H-02, proposes checkpoint A-03, and changes the same file. The review page can display H-02 as the current human-approved version, A-03 as the proposal, and the exact difference between them. The human can accept A-03, reject it, or create another human checkpoint after editing the file.
How would the hosted workflow work?
The hosted workflow would use an HTML page for review, Python for version operations, and SQLite for durable checkpoint records. A builder could run HTML online to publish the review interface and use file management for the project files that the workflow is meant to inspect.
The page needs only a small set of actions:
- Create a human checkpoint from the current file.
- Upload or register an agent-proposed version.
- Display current, parent, and proposed content side by side.
- Show a line-oriented change view.
- Accept the proposal as the next checkpoint.
- Reject it without deleting the prior record.
- Record a note explaining the decision.
The Python side can expose these operations as scripts or in-platform tool calls. A builder can run Python online to calculate hashes, compare text, validate that the proposal was based on the expected parent, and write records. If the proposal claims to be based on H-02 but the current file is H-04, the workflow should stop and mark the proposal as stale. That is a preservation check, not conflict resolution.
A basic record flow would look like this:
- Read the current file and create a human checkpoint.
- Give the agent the checkpoint identifier and file content.
- Save the agent output as a separate proposal.
- Compare the proposal with its declared parent.
- Let the human review the changes.
- Accept, reject, or manually revise and checkpoint the result.
The important decision is to keep the proposal separate until review. Writing the agent output directly over the working file would recreate the problem the tool is meant to document.
Where does SQLite fit best?
SQLite fits best as the local project ledger for immutable checkpoint records and explicit review decisions. The SQLite editor can help a builder inspect rows, correct metadata, and verify that the history matches what the review page displays.
The database should preserve old content rather than updating one mutable “latest version” row. A minimal schema could include `checkpoints`, `files`, and `reviews`. `checkpoints` stores content and ancestry; `files` identifies the current approved checkpoint; `reviews` stores the human decision and note. Foreign keys can connect a proposal to its parent and prevent an accepted version from losing its history.
This is also where the product boundary needs to be visible. SQLite can preserve versions and decisions, but it does not understand whether a code change is safe. Python can detect textual overlap or a changed parent, but that is not the same as resolving a conflict. A semantic merge engine, repository integration, or automatic conflict-free guarantee is outside this proposed capability set and should be marked unverified rather than implied.
What can a small team ship first?
A small team can ship a single-file review workflow before attempting a complete agent orchestration platform. The first release only needs one project, a few text files, checkpoint creation, proposal upload, comparison, and explicit acceptance or rejection.
The interface should make state hard to misunderstand. Put the approved checkpoint, proposal parent, and proposal status near the file name. Show a warning when the current approved checkpoint is not the proposal parent. Keep rejected proposals visible in history. Require an explicit action before an accepted proposal becomes the current version.
The workflow can later use a LanceDB knowledge base for searchable project notes or checkpoint explanations, but that is optional. It should not be presented as a substitute for the SQLite record of file content. Likewise, Model Center APIs could help summarize a change when an available model is appropriate, but generated explanations must remain secondary to the actual file comparison.
There is a useful precedent in the supplied market evidence: the scan-to-vector project reports both successful measurements and failure cases, including a version where one model became worse because the photo ratio was calculated incorrectly. A checkpoint tool should adopt that habit. Preserve rejected proposals, record why they were rejected, and make it possible to inspect the exact input and output instead of keeping only a polished final state.
What should the tool refuse to promise?
The tool should refuse to promise automatic merging, perfect agent awareness, or guaranteed recovery from every overwrite. The Codex report is a real user report, but its generality and cause are unverified. The proposed workflow reduces the cost of inspecting and preserving changes; it does not prove that an agent will always reread the newest file.
It should also avoid claiming broad deployment support. Within the confirmed VicroCode capabilities, the build can use AI coding assistance, AI agent development, hosted HTML web apps, online Python execution, API Endpoint Hosting and in-platform tool calls, file management, SQLite, LanceDB, and project publishing or sharing. Support for a particular external repository host, shell environment, programming language, cloud service, or automatic deployment method is unverified and outside this design.
That boundary is not a weakness in the product definition. It keeps the promise precise: every proposed file change gets an inspectable parent, a preserved copy, and a human decision before acceptance.
FAQ
Does this automatically merge agent changes?
No. It compares and preserves versions, then waits for a human decision; automatic merge support and guaranteed conflict resolution are not part of the design.
Can it recover a manual bug fix?
Yes, if the fix was checkpointed before the later proposal was accepted. Recovery after an unrecorded overwrite is unverified and depends on whether an older file copy still exists.
Is the tool a replacement for version control?
No. It is a focused preservation and review layer for agent handoffs, not a general version-control system or repository workflow.