esús Samuel Suárez, preso político que había quedado en libertad el viernes 2 de octubre en San Cristóbal, estado Táchira

Yes — and actually, that comparison is very close to how Esus came about. The first version of the agent was essentially the baseline you describe: I gave the 4B model a CRUD app specification and asked it to generate the entire application in a single pass. It produced roughly **19k tokens of code**. At first glance, the result looked surprisingly good — the structure and code “shape” were convincing. But when I actually tried to run it, it was basically invalid: non-functional in several places and, more importantly, it didn’t actually respect important parts of the specification. That failure is what pushed me toward the Esus architecture in the first place: instead of trying to get the model to reliably produce a large coherent artifact in one shot, I started moving the parts that could be made deterministic into the kernel. So there is already a qualitative before/after comparison from the development process. What I haven’t done yet is turn that into a **systematic controlled benchmark** with identical specifications, independent acceptance tests, repair budgets, and token accounting. That’s definitely a useful next step. And I particularly like your invariant-conflict case. My expectation is that Esus should **explicitly reject** a specification that violates a hard kernel invariant rather than silently changing the requirement. But I haven’t benchmarked that rejection behavior systematically yet. So I’d say the current results demonstrate the motivation and the architectural effect, but not yet a rigorous apples-to-apples measurement of the improvement.

For your current goal of making bounded generation harder to break, I’d be interested in a same-model comparison: the 4B model generating code directly versus the same model through Esus, with identical specifications and independent acceptance tests. First-pass success, success after a fixed repair budget, and total tokens including failed attempts would help show where the kernel improves reliability. One useful edge case could be a specification that conflicts with a kernel invariant: does the system explicitly reject it, ask for clarification, or silently change the requirement? Do your current benchmarks include those rejection cases, or mainly valid specifications?

That’s an interesting experiment, and I think it points to a possible next step for Esus. But I think I’m slightly earlier in the process at the moment. My main goal with Esus is still to **make the generation itself as robust and deterministic as possible** , rather than to build a resilient long-running agent. Today, a generation is basically a bounded process: the goal is to go from a specification to a working application, with the deterministic kernel doing as much of the construction and validation as possible. The recovery question becomes much more important once I move towards a more persistent agent, especially for brownfield development or iterative debugging. So I wouldn’t build a recovery mechanism yet. But deliberately interrupting a generation and measuring what is lost could be a useful experiment later — especially to see whether the current pipeline already gives us natural recovery points through its intermediate artifacts. **For now, I’d rather spend that effort on making the generation itself harder to break.** And I think that’s probably the more interesting question for Esus at this stage.

I think your point that interrupted execution is a different problem from the code-generation problem Esus is primarily solving is an important distinction. Rather than designing a recovery system first, I’d probably just break Esus deliberately at several points during a real, nontrivial generation run and see what recovery actually costs. Kill it: * after an LLM decision * after deterministic generation * after validation * after output has been written * somewhere awkward between two stages Then restart it and ask a few simple questions: what survived, what has to be rebuilt, what is ambiguous, and how much work gets thrown away? If most of the pain disappears by persisting only the last verified stage and its artifacts, then you may only need a very light recovery layer. If interruptions repeatedly force a large reconstruction of already-expensive work, then you’ve got a pretty concrete argument for building recovery alongside the generation process instead of adding it later. So maybe the useful test is less “can Esus recover?” and more “how far can it fall before climbing back becomes expensive enough that a few handholds are worth building?” -SS

Thanks for sharing. I agree that smaller, domain-specific models could be particularly interesting for agent architectures, especially when combined with deterministic tools and domain-specific validation. That’s actually quite close to what I’m exploring with Esus, although my focus is currently more on the **architecture around the model** than on building a vertical model itself.

เจนเอไอจนสภาพอากาศวิปริต พอปรากฏการณ์ธรรมชาติเล่นงานจนทุกอย่างวิปริตก็ยังเจนเอไอเล่นล้อสถานการณ์อีก สมดังที่พระพุทธองค์ไม่ได้ตรัสไว้ พวกเจนเอไอผู้สมองฝ่อเบาปัญญาเอ๋ย ท่านสมควรโดนอัปเปหิและตกนรกหมกไห...

This is a very interesting way of framing the boundary. I think I’m converging toward the second option you describe: the LLM should propose a mutation, but the deterministic layer should own the state transition and decide whether it is legal. In Esus, this is already close to how I’m trying to handle business invariants: the model can interpret a requirement and propose a decision, but once the decision reaches the kernel, the kernel is responsible for applying and validating the deterministic rules. Your point about interrupted execution is actually something I haven’t explored deeply enough yet. At the moment, Esus is much more focused on code generation than on long-running agent execution, so I don’t want to pretend that I already have a complete answer there. But I agree with your proposed test: if a process is interrupted, the deterministic layer should be able to establish what actually happened from durable state, rather than asking the LLM to reconstruct it from context. That suggests an interesting principle for the next iterations: The LLM can propose a state transition, but it should never be the source of truth about whether that transition actually happened. I hadn’t explicitly formulated the architecture this way before, so that’s a useful direction to explore. What kind of interrupted workflow do you have in mind as a concrete test case? I’d be interested in trying to model one in Esus.

Thanks! That’s actually one of the interesting things I’ve observed so far. In my current benchmark, Esus makes **more model calls than Claude for the same prompts (75 vs 35)** , but consumes **far fewer tokens: about 55k vs 3.9M**. This is partly because Esus doesn’t keep accumulating context in one long conversation. Each model interaction is independent, and the deterministic kernel carries the state between steps instead. So the idea is not necessarily to make the model do fewer things. It can actually make **more, smaller decisions** , while keeping the workflow state outside the model. The complexity of the workflow doesn’t have to translate into an ever-growing model context: **the deterministic code manages the state, while the LLM handles the decisions that actually require reasoning.** That’s also why I’m interested in testing more complex agent workflows. **What would you consider a “more complex agent workflow” in this context?** I’d be particularly interested in concrete examples where you think keeping the workflow state outside the model would become difficult. Of course, I still need to test how well this generalizes beyond the current code-generation domain.