Last year I was running a LangGraph agent in production. It failed on step 4 of 6 nd by the time I opened the logs, the state was gone.
I had no idea what the agent was holding in memory at step 3, what tool call it made, or what the model actually returned. I reran it and it passed.
I had no idea why.
That kept happening and I started adding print statements everywhere. Then I started dumping state to files manually but at some point I had more debugging code than actual agent code and it still wasn't giving me what I needed.
So I built ai-agent-vcr. It records the full execution state at every step inputs, outputs, tool calls, memory, model responses Under 5ms overhead. When something breaks you rewind to the exact step, look at what the agent was holding, edit it if you want nd resume from there without rerunning everything before it.
The name is a bad VHS joke.
The thing I kept getting wrong before I built this I assumed most agent bugs were model bugs. They are not. The model did exactly what you told it to given what was in context.
The problem is that by step 4 the context has drifted from what you expected, and without a record of how it got there you are just guessing.
Works with LangGraph and CrewAI and Traces are plain JSONL, git-friendly, no cloud required.
Still early and rough around the edges.
Would genuinely like to hear from anyone who has hit the same wall.
the interesting part isn't that they cant control it but its that the reasoning trace is honest precisely because it isn't controlled a model that could perfectly curate its chain of thought on demand would be harder to audit not easier and the "problem" is actually the safety property.
the docs-first approach is the part most people skip everyone wants to jump straight to prompting but without a PITCH.md or equivalent, the agent has no north star and you spend half your time correcting drift instead of building
the context save/restore slash commands are underrated too losing context mid-session and having to re-explain the whole codebase is where most of my time used to go.
the three questions he describes where did this output come from, what did it cost was it any good are the exact questions that kill you in week two of production nd the demo never surfaces them because demos dont hve billing alerts or angry users.
the part most people skip is evaluation tracing and cost metering feel urgent because they show up as incidents bad outputs just look like user error until they dont.
built my first Go project last month. never wrote a line of Go before that the agent just picked it because it compiled fast and shipped clean and Python kept slowing things down.
Wes is right that the ergonomics argument fades when you're not the one typing. but the ecosystem moat cuts both ways now all that Python tooling was built for humans to navigate not agents iterating at 100x the moat might become the trap.
the cold resume at 32ms is the number that matters most here and workspace restore + process spawn + reconnect in 32ms means you can treat agents as stateless from the infrastructure side without paying the UX cost of a cold start. that's the hard part of session persistence done right.
curious how CRDB handles the write amplification on high-frequency streaming sessions every SSE chunk going to the DB or are you batching at the session boundary?
the ethics problem isnt the agents its that we keep deploying systems that make real decisions before anyone has agreed on who owns the outcome when it goes wrong every alignment paper treats accountability as a footnote its not.
nobody wants to be liable for what an autonomous system does and until that changes the ethics conversation is just noise around the actual problem.
"last job" assumes the thing u r building doesn't eventually build the next engineer the more likely outcome is AI Engineer becomes the job that absorbs everything else nt because its the last one standing but because it keeps expanding its own scope that's not safety thats just a slower version of the same problem.
the real trick was making "ship your machine" sound like best practice and ten years later we r doing the same thing with ai "it works in my notebook" jst became "containerize the notebook and call it a pipeline" the abstraction always wins because fixing the actual problem is just too hard.
repurposing a Palm Pilot dial-up tool to sneak container traffic past enterprise firewalls is unhinged and yet it worked the best infrastructure hacks are never clever in the moment they are just desperate that the cleverness only shows up after someone else has to maintain it.
quit rate under 20% across every age group is wild most unemployment isnt people walking out its layoffs end of contract business closing the "nobody wants to work" narrative always felt off and this is why.
Gatling died in 1903 and he never saw his gun used in a trench and the engineers at Anthropic, OpenAI, Google they're watching it happen on X in real time..that's the difference nobody's talking about So Does seeing it change anything? I genuinely don't know.