Valkor, Zhejiang University, and UCL Open Source Loom: A Structured Engineering State Layer for AI Coding Agents

In an era where Vibe Coding lowers the development barrier, coding agents perform impressively on short tasks. But once the context lengthens, developers fall into a 'debug black hole': after a test failure, the agent frantically modifies code, apologizes profusely, outputs multiple rounds of diffs, and eventually forgets the original goal, even reverting previously fixed bugs. The entire session is filled with error messages and garbage logs, creating high environmental noise. Developers have to manually cut off and start a new session, but must then piece together all the information from the past hour using natural language.

This is the biggest bottleneck for current AI coding tools in large-scale real-world engineering: agents dump all engineering clues and garbage noise into the chat context, lacking an independent, structured Engineering State layer for isolation and control.

To break this bottleneck, Valkor, together with Zhejiang University's Intelligent Computing and Software Research Center and University College London (UCL) Software Engineering team, officially launched and open-sourced Loom. Loom focuses on what happens after AI generates code: how to ensure complex software tasks progress, are verifiable, and can be resumed in real engineering workflows.

Loom's approach is to decompose a complex software delivery process into a structured, resumable state chain, similar to introducing 'auto-save points' in a single-player game. When an agent runs a test and fails, Loom does not dump the failure as terminal text into the chat. Instead, it captures and structures it as a todo state independent of the chat history. This means bugs are not buried; failures become 'strong constraints' for the next action. Meanwhile, multiple agents can take over with zero cost—a new agent reads the structured 'delivery state chain' and instantly knows who it is, where it is, and which bug to fix next, without re-reading chat history.

Many attribute long-task failures to insufficient context window length, but Loom argues this is a false premise in real engineering logic. In software development, more information does not equal higher reliability. Stuffing tens of thousands of lines of compilation logs, multiple diffs, and test outputs into the context only fills the session with noise, causing the model to get lost or misjudge.

The essence of engineering is structure and determinism. Loom's approach is not to make the model see more or remember more, but to help it filter noise and extract only the core engineering clues: what step is the plan at? Which unit tests actually passed? Which files' diffs are finalized and should not be touched? When these key points become structured data readable by programs, the metric for AI coding effectiveness shifts from 'how many lines of code can the model generate' to 'the completion rate of long-task progression.'

Software engineering may be the best feedback field for agents, with absolutely rigid rules: code either compiles or it doesn't; unit tests either pass or they don't. If AI coding is to move toward serious production environments, it must return to the classic common sense of software engineering. Vibe Coding allows everyone to quickly whip up demos, but between a demo and real software that runs in production, there is a whole set of credibility verification missing. If coding agents only write code and offload all verification, alignment, and correction costs to human engineers, the efficiency leverage will soon hit a ceiling.

What Loom aims to explore is not just a useful open-source tool, but the state infrastructure missing for large models to move toward serious production environments. Large models learn 'what perfect final code looks like' from static corpora, but they struggle to learn 'how a complex bug is gradually located, fails, compromises, and finally fixed'—these process trajectories are the core engineering judgment in software engineering. Through this state layer, Loom not only makes agent long-task progression more stable but also captures the dynamic feedback trajectory of agents in real execution environments, providing more realistic engineering corpus for future dynamic evaluation and fine-tuning data collection of agents.