JAZ Framework: Rethinking LLM Agent Design with a Minimal invoke Primitive

The Complexity Problem in Agent Frameworks

Most modern language model agents are built around an "agent loop": an LLM is placed in an environment with access to a set of tools, and it drives the entire workflow by alternating between tool calls and observations. This paradigm is elegant in its simplicity — yet it struggles with certain classes of tasks.

Capabilities like memory systems and self-improvement often can't be handled by a basic agent loop alone, forcing developers to bolt on dedicated engineering modules. This raises a question worth asking: are these seemingly essential specialized systems actually necessary? Or are they just patches forced into existence by the limited expressiveness of the underlying framework?

A new paper on arXiv introduces the JAZ framework as a direct response to this question. The research team set out to test how far a minimal "harness" — one that contains little more than the agent loop itself — can go in handling the tasks that specialized systems are typically built for.

invoke: Treating the LLM as a Runtime Function

At the heart of JAZ is a single LLM-based primitive: invoke. The researchers define it with deliberate restraint, as the simplest possible loop satisfying two key properties:

First, the LLM can write arbitrary executable code, and that code may contain recursive invoke calls. Second, everything visible to the LLM — including all inputs to invoke and its interaction history with the code environment — exists as variables within that code environment.

These two properties may seem simple, but they embody a genuinely thought-provoking design philosophy. The paper treats invoke as a language primitive: it represents a function whose implementation is supplied dynamically by the LLM at runtime on each call. In other words, the LLM is no longer just the driver of a workflow — it becomes a dynamic, composable function unit within a programming language.

This perspective is a generalization of existing "code-mode" agent loops. It converges all agent capability into a single primitive, rather than continuously stacking specialized tools and external systems onto the framework.

Replacing Specialized Systems with Hooks

Beyond invoke, JAZ provides a set of built-in hooks that allow developers to impose constraints and perform monitoring. The design philosophy here is: rather than building separate systems for memory and self-improvement, provide sufficiently general low-level mechanisms and let these higher-level behaviors emerge naturally from the composition and recursion of invoke.

Language primitive refers to the indivisible basic building blocks of a programming language — integers, booleans, or function calls themselves. Traditional agent frameworks typically pile layers of "scaffolding" on top of the LLM: predefined tool registries, external memory databases, planning modules, and more. These add-ons are often tightly coupled to specific LLM capabilities and difficult to reuse across contexts. JAZ's invoke compresses the LLM's reasoning behavior itself into a single primitive, meaning any higher-level behavior — memory retrieval, multi-step planning, self-correction — is expressed through recursive composition of invoke, rather than hardcoded specialized paths at the framework level. This is philosophically aligned with the functional programming idea of "expressing all computation through Lambda calculus": as long as the primitive is expressive enough, complex behavior can emerge from simple rules without needing dedicated machinery for every capability.

Experimental Results: Minimal Can Still Win

To validate the invoke primitive design, the research team set up a deliberately strict experimental condition: prompting only, with no hand-crafted tools, harnesses, or external systems (such as memory modules or file systems) — evaluated directly on workflows that traditionally depend on specialized external frameworks.

The results are compelling. On long-horizon workflows requiring information recall beyond the context window, JAZ's invoke outperformed Letta (formerly MemGPT) by 8% on the recall-focused portion of the StuLife benchmark, at half the cost.

On the continuous self-improvement scenario, JAZ's invoke outperformed ACE by 4% on the AppWorld benchmark, again at lower cost.

Taken together, these two results point to a clear conclusion: the functionality of complex systems purpose-built for memory and self-improvement can largely be covered by a sufficiently general and minimal primitive — and may actually perform better on both quality and cost.

Letta (MemGPT) is an agent system designed specifically to overcome LLM context window limitations. Its core idea mimics OS memory paging — dividing information into "in-context" and "out-of-context" memory and using dedicated memory management tools to bring necessary information into context. ACE (Autonomous Cognitive Entity) is a layered cognitive architecture with dedicated planning, execution, and reflection layers designed for continuous self-improvement scenarios. StuLife and AppWorld are academic benchmarks: the former tests an agent's ability to recall information across long multi-turn interactions, while the latter simulates real-world application operation environments to evaluate continuous learning and self-improvement. JAZ surpassing these specialized architectures without relying on them demonstrates that complex system design is not the only path to acquiring these capabilities.

Why This Work Deserves Attention

JAZ's significance goes beyond beating two benchmarks. The deeper proposition it advances is this: the complexity of an agent framework does not necessarily set the ceiling on its capabilities.

For some time, the agent ecosystem has trended toward addition — more memory, more planning, more reflection, more external tools. JAZ takes a subtractive approach, seeking the smallest, most expressive core possible. If a single primitive combined with recursion and a code environment can cover a wide range of advanced requirements, then the value of many specialized systems deserves to be reconsidered.

Of course, as a newly released preprint, JAZ's validation remains focused on specific benchmarks, and its performance in broader, more complex real-world scenarios remains to be seen. Whether the minimal design hits bottlenecks in certain edge cases also requires further experimentation. But from a design philosophy standpoint, the idea that "the harness is the language" offers a clear and valuable direction for how agent frameworks might evolve.