How a distributed, event-sourced issue tracker built with developer ergonomics in mind may have a role to play in the next generation of agentic workflows
Harness engineering has recently popularized the idea of containing ** architectural drift** in agentic workflows. What might be missing in the discussion is a similar issue on a higher level -
By vision drift I mean that the implementation no longer drifts only from the architecture - it drifts from the original product intent. And it seems like the risk may be obscured by restricted tooling. As long as the project management tools only present a snapshot rather than a traceable story, there is an increased risk of undetected drift.
Drift is detected via specification audits over time. However, while code history easily can be traversed via Git, issue tracking essentially lacks this capability. Issue trackers tend to be excellent at answering the question “what is going on right now?”, but fail at answering the question “how did our work in this area evolve last month?” or “what went on this time last year?”, or “how did we get from there to there?”.
When I set off to build Epiq, this was not a concern on my radar. Agentic coding was something I had heard distant rumors of, and in fact I was just pursuing the ideal developer experience. This pursuit did however lead me down a path of unorthodox architecture, which in turn resulted in an issue tracker with some uncommon properties. One of these is the ability to inspect historical state by time-traveling, and replay sequences. I have not yet encountered another issue tracker with these capabilities.
Initially I thought of it as a gimmick feature. Imagine the wow-factor of replaying the entire sprint in a retro, visualizing the past 2 weeks as a short movie. I thought it would help out with reflection of how much (or little) work had been accomplished. Not until I set out to do my own first fully agent-implemented feature did I notice how time-travel was going to be an essential feature for anyone serious about staying in control of their product development.
I had made a master plan for a new feature together with Claude, and Claude used the Epiq MCP to break it down into digestible tasks. As I returned two hours after it set off I was delighted to see that all of the issues had moved across the board to the review column. I spent an hour or two reviewing the code. It all looked great. All solid, tested and well functioning code, following already established architectural patterns in the codebase. Only, now I was incredibly interested in how the work had elapsed. Instead of stopping at questions regarding the code, I found myself asking an entirely new set of questions:
A single agent working independently for two hours already left me wondering how the implementation evolved. I found myself asking what kind of questions would arise when twenty agents collaborate over three days.
How was the work coordinated?
Had they wastefully worked against each other, or in harmony, building on each other's work?
Most importantly - had they abandoned, or revised the initial vision?
At that point, I could see how a snapshot state of the board no longer satisfied these questions, and unless you sat and monitored the board evolution in real time you would be unequipped to answer them.
On the other hand, with Epiq, this was but a single command away: “:replay 2h”. That was all it took for me to see the whole session replayed as a time-lapsed movie. Right then it dawned upon me that this is part of a whole new generation of capabilities required for humans to stay in charge of the vision.
It seems like agentic coding isn’t going to go away any time soon. And given that we do some course corrections in our methodology after the initial hype I can see its given place even in serious productions, given that we reserve for humans the ability to stay in charge. This means new requirements on the next generation of project management tooling.
With agents getting more and more autonomy, the risk of potential vision drift calls for better workflow auditing. Just one step up from architectural audits it seems like the natural next step in the discussion surrounding agentic workflows.
Git made the evolution of source code inspectable. I believe the next generation of project management tooling will need to make the evolution of intent inspectable.
In case you are interested 👉 Explore Epiq