jolaflow

They went woke. Never seen anyone resembling the average dev in their promotion… You can see the correlation in their downtime graph.

When code becomes easy to shape, internal rigidity remains a challenge. Some reflections from the project I'm working on. Does this resonate?

I think that strictness will be the most important feature going forward. Whichever framework creates the safest boundaries for agents to work within will gain traction. That's why I think Effect has a bright future.

That's great!

I wish the MCP protocol supported push notifications from the app to the model. That'd make for a much nicer integration, with less overhead for this kind of interaction.

For this to work, you'd need to be able to replay the workflow after the fact. Spent last year and a half building an issue tracker that let's you replay the board and code. It lives in your repo and syncs via Git. https://ljtn.github.io/epiq I sometimes leave it on before going to sleep, instruct it to tag any deviations from the plan with a fork tag, and if needed a "human-input-needed" tag that I can filter for and review in the morning.

Got it! I am not up to speed on Claude cloud sessions yet. Interested to hear how that works out for you. Let me know if you figure out what's getting in the way, I'd be happy to look into it.

You might have use for an issue tracker I've been building the past year and a half. It lets you inspect diffs inline in the ticket, and replay the board to see how the workflow evolved over time via a timeline scrubber.

https://ljtn.github.io/epiq/

It stores issues as an immutable event log in your repo, so you can go back and inspect the context behind a change without having to litter the code with comments. Helps with traceability of intent.

Curious to hear how you find it after trying it!

I think it works well for tracking intent. I tell my agents to use a "human-input-needed" tag when there is a high stakes decision fork, and then I just filter on that tag, immediately highlighting blocked workflows. I think you can get a long way with clever tagging, filtering + time travel.

You are totally right in that it makes no sense. It seems like the skill.md had regressed as I had updated it via agent proxy. Thanks for pointing it out, the skill has been brushed up.

Spent the past 1,5 years building a tool that might be relevant, helping keep durable task state between agent sessions. It is an issue tracker persisting state as immutable event logs, allows you to inspect workflows after the fact, lets you inspect diffs inline in the tickets and it is much more lightweight than Jira/Linear. There is no central service to integrate with, as it is Git-backed and lives with your code in your repo.

https://ljtn.github.io/epiq/

Might be worth a look if you’re evaluating alternatives to Beads.

> We still haven’t solved how to help people stay oriented as hundreds of increasingly capable agents change a system at once…

Building an issue tracker that addresses this. It can replay the workflow after the fact like a movie, and pin down the parts that require human input via tagging and inline diffs in the tickets. It is git-native, lives in your repo alongside the code doesn’t require any external service.

https://ljtn.github.io/epiq/

I think what is different from the assembly -> C analogy is that we are now non-deterministic. You could almost argue that going to C increased human understanding, as we could express problems in a more human way. And while agents enable us to express ourselves in natural language, we lost the determinism along the way.

An attempt to reason about risks introduced by agentic workflows in a structured way.

Once agents run autonomously for longer periods preventing vision drift becomes as important as correctness.

Epiq solves this with an architecture that supports workflow auditing, allowing you to time-travel state in a filtered view to reconstruct what happened, when, by who, and where intent started drifting, while also allowing you to correlate the evolution of the board with the corresponding commits.

https://ljtn.github.io/epiq

For issue tracking you may also be interested in Epiq. It is git-native, vendor agnostic, and distributed. Comes with a command line TUI, a browser GUI, mcp, and more. Also event sourced state with replay, which is super powerful for auditing workflows.

It is also event sourced, and supports state replay from beginning to end, so very powerful for auditing workflows, whether that be your own or a swarm of agents.

Epiq also solves this with a git-native backend, so it is vendor agnostic and adheres to a issue-tracking-as-code paradigm. It is therefore distributed, has a TUI + browser GUI, mcp server, and so on.

https://ljtn.github.io/epiq/

In regards to issue tracking there are alternatives. Epiq is a git-native (vendor agnostic) issue tracker you self-host: https://ljtn.github.io/epiq/

A modern issue tracker enabling replay for agentic workflows (via board time-travel) and focus on ergonomics (native to the terminal).

https://ljtn.github.io/epiq/

As for issue tracking, there are also other git-native alternatives out there. Epiq is entirely git-backed, vendor agnostic and persists state as a versioned log in your repo.

Im its creator, for full disclosure.

That is also very true, and I think time-travel capabilities would help detect that too.

I think behavior driven development probably can make intent more explicit and standardized. However, I think they operate at different levels, or on a different axis if you will. BDD helps make each point in time easier to reason about wile being able to traverse the time axis helps understand how the workflow evolved.

Interesting. When it comes to auditing, I think there is also another layer to be verified - the intent. We have tooling for static analysis and automated tests, but drift in intent or vision is hard to detect.

After leaving agents unsupervised for longer periods of time, the biggest questions tend to be "how did it arrive at this conclusion?" and "did we drift from the initial vision?". Typically these questions are hard to answer as you only review the final state of the workflow.

I recently built an issue tracker that does offer time-traveling as a core feature. Somewhat unexpectedly this turned out to provide a much sought for overview allowing for a better workflow audit, as detailed here: https://dev.to/ljtn/vision-drift-addressing-the-next-problem...

Would be interested to hear your thoughts. I guess vision drift would classify as something that is hard to reverse, because you often don't realize it has happened until much later.

I have run into the same problem, and started calling the phenomenon vision drift.

I noticed that the issue tracker I built was well suited to address this problem, as it handles board time-travel. So a simple command like ":replay 4h" gives you a clear overview of how the workflow has evolved over time, and you can checkout previous states at will.

Wrote more about it here:

https://dev.to/ljtn/vision-drift-addressing-the-next-problem...

A feature I built for fun turned out to be very useful for tracing vision drift in agentic workflows.

How new ways of working asks for a new generation of issue tracking capabilities

Thank you for the kind words!