TL;DR
Human + agent version history is a single timeline that records every change to an artifact, whether a person made it by hand or an AI agent pushed it programmatically, with the same information for both: who or what, when, and the state to roll back to. It matters because AI-built apps now routinely have both kinds of editor, and any history that only sees one kind is half a record, which is roughly as useful as none.
The new editing population
An AI-built app in real use accumulates three kinds of change:
- Human hand edits. A teammate fixes the headline directly; a client tweaks a label during review.
- Human-prompted regenerations. You take the feedback back to Claude or ChatGPT and republish the result.
- Agent pushes. Increasingly, no human touches the loop at all: an agent updates the dashboard's numbers on schedule, or a coding agent revises the page through a CLI or an MCP tool because you asked it to in some other conversation.
The third kind is the new one, and it breaks the old assumptions quietly: agent edits happen while you're asleep, at machine speed, sometimes several in a row. If your record of the artifact is "I remember what I changed," the record is already wrong.
What the combined history has to do
One timeline, not two. The tempting design is a human history plus an agent log. It fails on the first real question: "the pricing section changed Tuesday; what happened?" With split records you're manually interleaving two logs to reconstruct causality; the agent's 2am push and Ana's 9am fix are one story and belong in one sequence.
Attribution that names agents like authors. Every version carries its author: Ana, or agent via CLI. Not "system," not blank. When an agent is a first-class editor, it gets first-class blame, which is what makes trusting it rational: you can always see exactly what it did.
Rollback that doesn't care who wrote it. An agent's overzealous rewrite restores the same way a human's mistake does: one click to any prior version. This symmetry is the safety property that lets you grant agents access at all; the cost of a bad push drops to the cost of noticing it.
Concurrency without collision. Agents don't wait their turn: a push can land mid-way through two humans' editing session. The merge has to absorb that (CRDTs, explained here) and the history has to record the merged sequence sanely.
Checkpoints for intent. Automatic versions record every change; named checkpoints ("client-approved v1") record meaning. With agents editing continuously, the named checkpoint is how humans mark the states that matter against the stream of states that merely happened. It's the general versioning problem, sharpened: more versions, fewer memories.
Why existing records don't cover this
Chat scrollback only sees changes made in that chat, so hand edits and agent pushes are invisible to it. Git handles machine authorship fine but lives where non-developers don't, and the no-code edits made on a shared surface never reach it. File copies were already failing before agents showed up. The record has to live where the artifact lives, capturing every editor that touches it, human or not: which is an argument about where the artifact should live, as much as about history.
How Coedit fits
Coedit implements exactly this model: every project has one version timeline, and a change is a change whether it came from a hand edit on the live page, a republish, or an agent working through the Coedit CLI or MCP server; each lands with authorship and timestamp, each restores identically, and "Save version" pins the named checkpoints. It's why "let the agent update the dashboard" and "let the client fix the label" can both be yes without anyone losing the thread of what happened.
FAQ
Q: What is human + agent version history? A: A single, chronological record of every change to an artifact, made by people or AI agents alike, with authorship, timestamps, and the ability to restore any prior version regardless of who or what created it.
Q: Why not keep a separate log for agent changes? A: Because the artifact has one lifetime, and questions about it ("what changed Tuesday?") span both kinds of editor. Split records force manual interleaving, and interleaved-by-hand is where causality gets lost.
Q: How do I safely let an AI agent edit something my team uses? A: Three properties: the agent's edits are attributed (you can see what it did), reversible (rollback is one click), and mergeable (its pushes don't clobber concurrent human edits). Given those, agent access is a convenience rather than a risk.
Q: Is this just git for AI? A: Same spirit, different audience and grain: it versions a live shared artifact automatically, including edits from people who will never run a commit, in the place where they make them. Git remains the right tool for engineering codebases.