Spice release: an open-source Agent framework aiming to pry open the execution black box

When All Agents Are Focused on Execution, Spice Wants to Take Charge of “Decision-Making”

In the 2026 Agent race, no one is still talking about whether they can “get the job done.” Cursor, Claude Code, Manus, Tongyi Lingma 2.0—all of these products have pushed the execution layer to the point where it can almost replace a junior engineer. But one intentionally avoided question remains—after these Agents finish their tasks, can you clearly explain why they behaved that way?

On May 15, developer Jia released a new version of the open-source Agent framework Spice. More than a month after its first appearance, this update targets a rather unpopular direction: bringing the decision-making process of Agents out of the black box.

This is not another ReAct rewrap, nor a LangGraph-style orchestrator. In an update post on the LINUX DO community, Jia put it very plainly: most Agents on the market are still essentially tool proxies where “humans decide what to do, and the Agent decides how to do it.” Spice wants to take it half a step further.

The Ceiling of Execution-Level Agents Arrived Sooner Than Expected

To understand Spice’s focus, first look at the few consensus bottlenecks in the Agent circle today.

The first is the decision black box. Whether you use ReAct, Reflexion, or an RL-trained harness, the real reason an Agent calls a particular tool in the loop is almost invisible externally. You see the text stream of thought→action→observation, but why the model suddenly decides at step three to invoke search rather than read_file isn’t explained anywhere. This leads to all current Agent benchmarks only inferring capability from results—SWE-Bench passing several problems, WebArena success rates—all are result indicators. Process indicators are almost non-existent.

The second is non-auditability and non-traceability. This isn't critical for personal toys, but it’s fatal in enterprises. If an Agent runs for 40 minutes, invokes 200 tools, and finally drops a production database table—how do you assign responsibility afterward? Trace logs can tell you what it did, but not why it thought it was right to do so.

The third is the bloated orchestration layer. A2A, MCP, various memory middlewares, various gateways (such as OpenClaw—mentioned by Jia—that rebuild entry points), have turned Agents from simple chatbots into something resembling “digital employees.” The 2026 Global Intelligent Agent Whitepaper noted that 57% of enterprises deploy multi-stage Agents—behind that figure lies a heap of stitched-together infrastructure. The more capable and numerous Agents become, the more crucial explainability becomes—who is making decisions and according to what logic.

Spice’s judgment: If the execution layer keeps intensifying, its marginal gains will be minimal, while the decision layer remains almost empty.

What Spice Wants to Do: “Extract” Decisions from the Model

According to Jia, Spice’s core design makes several unusual trade-offs:

• Explicit Decision Paths: Instead of stuffing planning into the system prompt for the model to reason by itself, decision steps are extracted as observable, intervenable graph nodes. Each tool choice and each branch is an externally auditable record.
• Decoupling Execution and Decision: Execution-layer Agents (those coding, researching, or doing RPA) are pluggable workers. Spice itself only manages “who to assign, why, and how to verify afterward.” This is somewhat similar in concept to Tongyi Lingma 2.0’s “environment + agent” multi-agent framework, but Spice is more radical—it doesn’t assume workers are homogeneous.
• Exportable Process Data: This addresses a common pain point—developers of self-evolving Agents constantly complain about the lack of process data. Spice structures decision trajectories for direct output, which can theoretically be used for subsequent training.

This echoes a viewpoint repeatedly raised in recent panel discussions: the real difficulty in self-evolving systems isn’t the model solving tasks by itself, but the lack of process data and an environment that can co-evolve with it. The name SPICE (Self-Play In Corpus Environments) already exists in academic work; Jia’s Spice, while differently positioned, stands on the same wave—Agents aiming higher must have a structured decision process.

A Different Approach: Making “Why” a First-Class Citizen

In traditional Agent frameworks, “why do this” appears as natural language in the thought field—written by the model for itself. Spice upgrades this concept to a framework-level object—every decision carries:

• A set of candidate actions
• The criterion for selecting the chosen action (rule-based, model scoring, or external verifier)
• A snapshot of the current context
• A rollback-capable checkpoint

The cost is evident: higher performance overhead, token consumption, and engineering complexity. The benefit is that when an Agent behaves unexpectedly in a production environment, you finally have a way to review its decisions step by step—no need to dig through tens of thousands of lines of trace logs.

To compare the current market directions:

| Framework | Focus | Decision Auditability | | --- | --- | --- | | LangGraph | DAG orchestration | Partial (node-level) | | AutoGen | Multi-Agent dialogue | Weak | | CrewAI | Role division | Weak | | Spice | Explicit decision-making | Strong (design goal) |

Admittedly, this table favors Spice—it’s still early-stage, and its engineering maturity isn’t on par with the others. But the directional difference is real.

Who Will Use Spice

Honestly, individual developers likely won’t migrate in the short term. When coding with Cursor, you don’t care why it decides which file to read first. A “decision-heavy” framework like Spice is more suited for:

1. Teams running critical business workflows within enterprises: compliance, finance, healthcare—where every Agent step must be explainable and reversible.
2. Teams developing Agent training datasets: who need high-quality process trajectories for SFT or RL.
3. Researchers evaluating Agents: shifting from result-based benchmarks to process-based ones is inevitable.

Jia also mentioned that after a month of discussions with investors and technical peers, the most enthusiastic responses came from these groups. This suggests one thing: the Agent industry may be stratifying—one layer for end-user execution Agents (focused on experience and speed), another for enterprise and research-level decision infrastructure (focused on controllability and auditability). Spice bets on the latter.

Questions That Still Need Answering

Beyond its direction, Spice faces several inevitable challenges at this stage:

• The boundary between explicit decisions and model competence: As base models grow more capable (like GPT-5, Claude 4.5, Gemini 3), forcibly extracting decisions might actually hurt overall Agent performance. This is the classic “explicit vs. emergent” debate.
• Ecosystem Compatibility: The current Agent ecosystem is built around ReAct/MCP paradigms. For Spice’s decision protocol to function, it needs to adapt to numerous existing tools and workers.
• Performance Cost: Recording candidate sets, criteria, and checkpoints at every step increases both tokens and latency. Its feasibility in enterprise use depends on business specifics.

There’s no standard answer yet. But at least Spice puts on the table a long-ignored issue hidden under the shine of execution layers: Agents don’t just finish tasks; someone must take responsibility for each decision, and enable those decisions to be improved—which matters far more than building yet another faster ReAct.

Incidentally, the base model behind Spice can connect to any OpenAI-compatible endpoint. Gateways like OpenAI Hub that aggregate GPT, Claude, Gemini, and DeepSeek are perfect for it—a single API key for switching between base models to compare decision-making behaviors, which is quite handy for early Spice debugging.

References

• Spice Project Introduction and Update Post - LINUX DO: Jia’s firsthand explanation of Spice’s design philosophy
• Self-Evolving ≠ Self-Solving, The Real Breakthrough for Agents Is “Creating Their Own Environment?” - Zhihu: Roundtable discussion among six scholars about Agent self-evolution and decision process data