The bet behind JAZ is almost provocative: much of what many LLM agent frameworks build with memory systems, manual tools, and self-improvement pipelines can be compressed into a single primitive, invoke, little more than the agent loop itself. The research group behind JAZ does not add external components; instead, it exposes a single LLM-based primitive and a set of hooks for constraints and monitoring. The argument is that complexity should not be multiplied but reduced to the boundary between code and context.

The core technical point is the definition of invoke. It is not a simple wrapper for function calls: invoke is the simplest loop that satisfies two properties. First, the LLM can write arbitrary executable code, including recursive calls to invoke. Second, everything visible to the LLM—the inputs to invoke and the interaction history with the code environment—is represented as variables in that environment. In this way, memory is not a separate subsystem: it emerges from the state of the code. The design starts from a language principle: invoke as a primitive representing a function whose implementation is provided at runtime by the LLM on every call.

Fewer components, larger execution surface

To validate the primitive, the team tested invoke using only prompting, with no hand-designed tools, no specialized harness, and no external systems such as memory or a file system. On long-horizon workflows requiring recall beyond the context window, JAZ invoke outperforms Letta (MemGPT) by 8% at half the cost on the recall-heavy portion of StuLife. On continual self-improvement, JAZ invoke outperforms ACE by 4% at lower cost on AppWorld. These results point to something structural: if a minimal primitive achieves competitive results against specialized systems, external memory and self-improvement modules may, in many cases, be additional engineering that compensates for a lack of integration with the code environment.

For teams operating self-hosted stacks, reducing components has direct implications. Fewer external services mean fewer integration surfaces, less data movement, and potentially lower TCO. A framework that does not require managed vector memory or separate orchestration services comes closer to a local deployment where control remains with the team. But minimalism shifts the risk: executing arbitrary code and recursive calls to invoke enlarges the execution surface. In an on-premise or air-gapped context, sandboxing and hook monitoring become the new trust boundary. It is no longer the memory database that must be governed, but the runtime that executes the code produced by the LLM.

The signal for the agent ecosystem

The direction indicated by JAZ is not neutral for specialized framework vendors. If a minimal loop can cover use cases for which dedicated systems were designed, pressure mounts to justify every additional component. Providers selling memory as a service or self-improvement pipelines must demonstrate value beyond what code state already offers. At the same time, the simplicity of invoke does not remove complexity: it shifts it toward prompt engineering, hook design, and runtime security. Engineers evaluating on-premise deployments therefore need to reason about a different trade-off: less data infrastructure, more rigor in execution isolation. AI-RADAR offers analytical frameworks at /llm-onpremise to examine these trade-offs without oversimplifying them.

The point is not whether JAZ is better in absolute terms, but whether the added complexity of specialized layers is really necessary when the code environment is already part of the LLM's context. The answer, at least on the cited benchmarks, leaves an uncomfortable question for those who built entire stacks on the assumption that the agent loop alone was not enough.