We Sent an AI Agent Back Into ChatGPT to Find Code Another AI Had Written
DEEP DIVE AI · AI AGENTS · LOCAL AUTOMATION · DIGITAL FORENSICS
We Sent an AI Agent Back Into ChatGPT to Find Code Another AI Had Written
The strange morning our AI Factory became a digital investigation—and what it taught us about ownership, memory, and trusting autonomous agents.
By Deep Dive AI | October 23, 2026
Hero artwork: AI-generated editorial cartoon. The characters and scene are a satirical illustration of our investigation, not a screenshot of the tools.
The Code Was Real. The Conversation Was Missing.
This morning, I found myself doing something I never expected to do: asking an artificial intelligence to investigate another artificial intelligence.
Not because the original agent had done something malicious. Not because our AI Factory had completely stopped working. I wanted to find a piece of code—or, more precisely, the original ChatGPT exchange in which an AI agent had helped create or hand off a Python script for our automated video-production system.
The script was called one_click7.py. What started as a simple question—where did that code come from?—turned into a much larger investigation into AI memory, work history and the difference between a plausible explanation and a provable one.
We had local execution records. We had job names and timestamps. We had evidence that the system had run. What we couldn't establish was the complete trail connecting the original ChatGPT conversation to a particular execution.
That distinction became the story.
The Factory We Were Trying to Understand
For anyone new to Deep Dive AI, we've been building an automation system we call our AI Factory. The goal is straightforward: produce useful, research-driven content while reducing the repetitive work between writing an article and creating finished media.
Our workflow involves a published blog article, NotebookLM, locally managed scripts, automated production steps, imagery, audio, captions and video assembly. We've deliberately been pushing toward a local-first approach, keeping scripts, files, logs and execution processes under our control on a Windows computer instead of depending entirely on remote services.
One part of that workflow was located at D:\codex-projects\hermes-episodes\_oneclick\one_click7.py. The point of a one-click script is to avoid coordinating every production stage manually. We want one reliable, controlled entry point.
But a question emerged. We knew the script existed. We knew one-click jobs had been run. I remembered testing a handoff through ChatGPT. Could we prove which conversation started which run?
Sending an Agent Back Into the Past
The investigation focused on an earlier ChatGPT conversation called Evergreen Factory Daily, particularly activity from October 19–21, 2026.
I remembered providing a Python command, script or related handoff during a second test after the one-click installation. Another run had also been started around that period.
The objective wasn't to find just any mention of the script. We needed original evidence: What did I paste? What did the assistant reply? Which tool did it call? What instructions were submitted? Which local job, if any, came from that exchange?
A conversation can describe an action without proving it happened. An assistant might say it started production, and a log might independently show that production started. Without a shared identifier or matching submission record, those observations don't automatically prove they're describing the same event.
We treated this as an investigation, not a memory exercise. No rewriting history. No recreating the missing exchange and calling it original. No rerunning the script just to manufacture new evidence. The assignment was read-only: find what actually happened.
What We Found
It wasn't a complete failure. The investigation established important facts about the local side of our automation. Our system used a Google Drive-synced approved-job runner to deliver work to the Windows machine. Local records showed installation jobs and three one-click run records:
| Job | Recorded local time |
|---|---|
| ep5-oc-run1 | 1:45:36 PM |
| ep5-oc-run2 | 1:57:44 PM |
| ep5-oc-run3 | 7:19:08 PM |
Those were historical records, not new jobs launched this morning. We also found evidence of the wrapper installation and a later copy of one_click7.py, with completion records and matching file hashes.
That was meaningful. We weren't simply relying on an AI assistant's claim. Machine-generated records supported portions of the execution history. But the most important connection remained unresolved.
We could not conclusively associate my remembered second ChatGPT test with any one of those three jobs. The precise original user message wasn't recovered. Neither were its exact timestamp, immediate assistant responses, tool-call arguments, submitted payload or the complete identifier chain needed to prove which execution it initiated.
We had evidence of execution. We didn't have the complete evidence of origin.
The Difference Between Remembering and Proving
Humans remember events as stories. I remembered installing the script, running tests and initiating another test through the Evergreen conversation. Those memories were useful leads. But a reliable agent investigation needs more than a plausible story.
Imagine finding three shipping receipts in a warehouse. You know three packages went out. You remember placing an order. But the order confirmation is missing. You cannot automatically declare which receipt belongs to your order.
That's where we were. Artificial intelligence is excellent at constructing coherent explanations from incomplete information. That is useful for writing and brainstorming; it's dangerous when trying to establish what actually happened.
A convincing reconstruction is still a reconstruction. We needed the original record.
An AI Searching for Another AI's Work
There was something comical about the situation. We built AI-assisted workflows to eliminate repetitive effort, yet here we were asking one AI assistant to find historical work from another.
The code wasn't the only issue. The missing context was. Why did we make the change? Which test was second? Which instructions were approved? Had two runs overlapped? What did the assistant claim—and what did the machine actually do?
That is an accountability problem. When an assistant writes a paragraph, the paragraph is usually the deliverable. When an agent creates scripts, moves files or launches production, the finished output is only part of the deliverable. We also need to know how it got there.
The Missing Link in the Automation Chain
Every serious AI workflow should be able to document this chain:
Human instruction → AI decision → Tool invocation → Job submission → Local execution → Finished output
If every stage shares traceable identifiers, an investigator can follow the work from beginning to end. But if the conversation is stored in one place, the tool invocation in another and Windows job logs somewhere else, reconstructing an event can become difficult.
We could verify meaningful portions of the local process. We couldn't establish an uninterrupted chain back to the original ChatGPT exchange.
A working automation and an auditable automation are not the same thing.
Why Local-First Still Matters
This isn't an argument against our local-first approach. Quite the opposite: much of what we established came from local execution records, including job identifiers, launcher activity and file locations. Without those, we might have had little more than conversational recollection.
But local-first doesn't solve everything automatically. A computer can preserve the script without preserving why an agent wrote it. A log can show that a process launched without identifying the conversation that authorized the launch. A file hash can prove two copies match without proving which user message led to their creation.
Local control gives us the opportunity to build a reliable system. We still have to design the recordkeeping.
What We're Changing in Our Thinking
We're not giving up on agents or automation. We're treating traceability as a production requirement.
- Give each significant job a unique ID tied to its instructions and submitted payload.
- Connect the approval, local launcher, output files and final status to the same record.
- Preserve the originating conversation reference whenever available.
- Separate what an AI intended to do from what a tool actually completed.
- Keep audit and status checks read-only so investigating a run never accidentally starts another one.
These safeguards don't create prettier videos or more compelling thumbnails. They make the system understandable and trustworthy when something goes wrong.
What We Still Don't Know
By the end of the investigation, the central question remained: Which exact ChatGPT exchange caused the second test I remembered, and which job did it submit?
We didn't recover enough evidence to answer reliably, and we couldn't establish from the available records whether that specific submission overlapped another run.
It's not a satisfying ending, but it's better than inventing certainty. Sometimes the most useful finding is identifying precisely where the audit trail breaks.
The Bigger Problem Nobody Talks About Enough
AI agents can write code, navigate tools, build websites, manage files and coordinate increasingly complicated workflows. But the conversation about agents still focuses heavily on what they can accomplish, not on preserving the history behind those accomplishments.
What happens six months later when you need to know why an agent chose a particular approach? When a script has been revised fifteen times? When an AI says it finished but the only surviving evidence is a partial output? When two agents perform similar jobs and their histories are difficult to distinguish?
For us, these are no longer abstract questions. We're encountering them while operating a real AI Factory.
The Takeaway: Keep the Receipts
We built an AI Factory to make our creative work easier. Then we spent part of a morning using AI to investigate the historical actions of another AI.
It's funny. It's also a warning about the next phase of automation.
The more responsibility we give agents, the more important it becomes to preserve the instructions, decisions, permissions, executions and results behind their work.
A script isn't the full history of a project. A chat transcript isn't an execution log. And an AI agent's confident explanation isn't a substitute for either.
We still have work to do on our audit trail. But today clarified the direction: the next generation of useful AI workflows won't just perform complicated tasks. They'll show us exactly what happened.
Because if an AI agent can do the work, we should be able to prove how it did it.
About Deep Dive AI
Deep Dive AI explores artificial intelligence, local automation, practical AI tools, and the real-world challenges of building AI-assisted workflows. We document what works, what fails and what we learn.
Subscribe on YouTube · Read the blog · AI Workflow Solutions on Facebook
Disclosure: AI tools assisted with organizing and writing this article. The investigation describes our workflow and its documented limitations. Missing records were not reconstructed as original evidence.
Comments
Post a Comment