When you hand an AI an unfinished draft and keep going, does anything actually notice you're building on its work?

This explores how you could tell when a user picks up something an agent produced partway through a task, such as a draft, a snippet, or an intermediate result, and builds on it. The collection has no study that measures reuse signals directly. It does suggest something more useful: whether reuse is visible at all depends mostly on where the agent's work lives. If partial outputs scroll away in a chat log, reuse is close to invisible. If they sit somewhere the user can find, point to, and edit, reuse leaves a trail.

The clearest case is JarvisHub's shared canvas Can a shared canvas serve both human and agent memory?. Prompts, references, versions, and feedback each become a typed node that both the human and the agent can see and link to. On a canvas like that, the signals you would want are built into the structure. A user links a new request to an old node. A user edits an agent-made version instead of starting over. A user resumes unfinished work from an earlier artifact. The design's purpose is to support local updates and artifact reuse without hiding the process, and a side effect is that reuse becomes observable.

A second idea comes from training research. One line of work argues that every agent action produces a "next-state signal": the user's reply, a tool output, an error, a change on screen. Any of these can serve as live feedback Can agent deployment itself generate training signals automatically?. Reuse is one of the strongest next-state signals there is. A user who copies, cites, or extends an intermediate result is implicitly rating it as good. A user who regenerates it or ignores it is rating it too. There's a parallel in retrieval research, where a model's own partial answer turns out to reveal what information is still missing Can a model's partial response guide what to retrieve next?. Partial outputs say a lot about what a task needs. In the same way, what users do with those outputs says a lot about what they need.

The less obvious point is that reuse depends on trust, and trust depends on consistency. If an agent produces different outputs for the same request on different runs, users can't build a reliable picture of what it will do How does inconsistent agent behavior affect user understanding?. They are then less likely to rely on an intermediate artifact. So a lack of reuse may not mean the outputs were bad. It may mean users couldn't predict whether the outputs were stable enough to build on. Design work on plain-language "action receipts" for people who hand tasks to agents Should agent accountability be designed for end users instead of engineers? points to a fix: give each completed step a short, readable record that users can check and then reuse.

In short, if you want to detect reuse, you mostly have to design for it first. Make partial outputs addressable and versioned, give them human-readable records, and keep them consistent. Then reuse shows up as links, edits, and resumptions that you can actually observe.