Forge was an attempt to make autonomous software delivery feel structured and inspectable. I did not want a loose loop of prompts and shell commands. I wanted a system with state, review, routing, and a clear model for how work should move from idea to completion.
Separating the brain from the muscle
The core idea was simple: keep orchestration and execution separate. Convex held system state, priorities, workflows, quality gates, and routing logic. The daemon claimed work, launched isolated agent environments, and reported results back. That split kept the runtime deliberately boring. Execution was supposed to do the assigned work, produce evidence, and hand control back.
That part worked. Forge had a real model of software work underneath it. Tasks were not merely marked complete. Agents had to produce artifacts. Those artifacts moved through gates. Reviewers could validate the output. Interrupts could stop the flow when something was blocked, unclear, or off track.
Forge proved the orchestration model. It also proved how much machinery that model can demand.
What it got right
One thing Forge understood early was that long opaque agent runs are hard to trust. So it broke work into short intervals, usually a few minutes at a time. At the end of each burst, the agent had to return something concrete: finished work, evidence of progress, or an interrupt explaining why it could not continue.
It also treated research, planning, coding, review, and merging as separate kinds of work. Larger efforts could break down into smaller tasks without losing the thread. In theory, that is exactly the sort of infrastructure you would want if autonomous software work were going to operate at any real scale.
Where it broke down
Forge also taught me that being architecturally right is not the same thing as being practically right. The system had depth, but it also had weight. Artifacts, gates, reviewers, interrupts, workflow state, daemon coordination, isolated execution, all of that made sense individually. Put together, it became a lot to carry unless the work really needed that much process.
That is why I think of Forge as both successful and obsolete. Successful because it proved the model. Obsolete because the model was heavier than most agent work needs right now. A lot of the complexity was built for a future operating mode that still is not common.
What stayed with me
The important lesson was not the exact implementation. It was the tension underneath it. Agent systems need structure, but they also need compression. They need observability without ritual, coordination without bureaucracy, and enough flexibility to stay useful once real work pushes back.
Forge made that tradeoff impossible for me to ignore. It proved that short execution loops are easier to trust and that agents benefit from real workflow structure. It also showed exactly where the overhead starts to eat the benefit.