Amber Eco-Bottle 2.0 Released: Turning the Agent Framework into “LEGO”

Today, the open-source Agent framework KohakuTerrarium has released version 2.0.0. This is a major, almost full rewrite-level update. The author, Kohaku-Lab, systematized all the lessons learned from the community over the past six months in projects like openclaw, Hermes Agent, and OpenManus, and integrated them into a unified framework.

If you’ve been experimenting with Agents recently, you might have noticed an odd phenomenon: every time a new paradigm appears—whether it’s a variation of ReAct or a new multi-agent collaboration pattern—the first reaction is often, “I’ll just build an Agent from scratch to demo it.” The result? Dozens of highly similar Agent architectures litter GitHub, differing only in their outer-layer ideas. KohakuTerrarium aims to solve exactly that problem: preserve the parts that always need to be rewritten so that new ideas only require implementing the new idea itself.

So what actually changed in this release?

Version 2.0.0 is marked as a “breaking change” release; the author acknowledges that its API is incompatible with 1.x. The key changes include:

1. Execution state management rewritten

This is the most notable improvement. One longstanding pain point in Agent frameworks is: “What if it crashes halfway?” Early versions of LangChain and AutoGen were criticized for this—long tool invocation chains would lose all progress if a network hiccup occurred, forcing users to restart from scratch.

KohakuTerrarium 2.0 introduces an explicit execution state model, dividing Agent operations into serializable, interruptible, and recoverable chunks. In other words, you can serialize a running Agent to the database, shut down for dinner, and resume tomorrow. It sounds basic, but few frameworks do it right—most hide states in Python closures or serialize them unreliably.

2. Multi-Model Collaboration

Version 2.0 changes the abstraction from “one Agent with one LLM” to “one Agent can schedule different models at different decision nodes.” Behind this change is a practical realization: by 2026, relying on a single flagship model for all tasks is both expensive and slow. A well-designed Agent should look like this:

• Use Claude Opus or GPT-5 for planning stages requiring deep reasoning
• Use cost-efficient models like DeepSeek or Qwen for large-scale tool calls and code generation
• Use Gemini for visual understanding tasks
• Return to a strong model for final summarization

Terrarium 2.0 makes this “model-per-node” approach a first-class feature, configurable directly through YAML. For developers using aggregate API platforms (such as OpenAI Hub, which supports multiple models with one key), this mechanism works out-of-the-box—switching models just means editing a model field, no SDK or auth changes required.

3. “Agent-as-Skill” configuration-based workflow

The framework emphasizes that a complete Agent should be callable by another Agent as a “skill.” This means Agents must have standardized I/O protocols, discoverable capability descriptions, and composable designs.

Version 2.0 makes this configuration-driven—you write a YAML file describing what the Agent does, what tools it needs, and what model it uses, and the framework automatically instantiates a callable sub-Agent. This design echoes Google’s A2A protocol and the MCP model for tooling—but KohakuTerrarium integrates it internally within Agents.

How does it position itself among existing frameworks?

It’s worth comparing, since the “yet another Agent framework” space is already crowded.

• LangChain / LangGraph: Lean toward “application development frameworks” with many abstraction layers—flexible but steep learning curve. LangGraph’s state-machine implementation is good, but overall it remains a “glue library.”
• AutoGen: From Microsoft, strong in multi-Agent dialogue orchestration, but quite rigid underneath—awkward for non-dialogue use cases.
• OpenManus / Minion-agent: Product-level Agent replicas with complete UI and toolsets out of the box, but high customization cost.
• AgentVerse: Research-oriented, good for multi-Agent simulation experiments.

KohakuTerrarium 2.0 positions itself as “the Rails for Agents”—it provides structure and batteries-included components but keeps extension points clear. The author explicitly states support for “TUI, Web UI, persistent sessions, built-in tools, sub-Agents,” all essential for production-grade frameworks yet not overly prescriptive.

Simply put: LangChain favors engineers assembling parts, AutoGen suits researchers experimenting, and KohakuTerrarium aims to serve both. It’s an ambitious goal—whether it succeeds depends on community traction.

Some detailed design notes

Looking at the repo (github.com/Kohaku-Lab/KohakuTerrarium), several design details stand out:

• Custom Module System: Users can inject their own modules into an Agent’s execution loop, similar to middleware in web frameworks—useful for evaluation, logging, and guardrails.
• Session Persistence: Long sessions can be saved to disk; combined with execution state management, this enables “Agents that never drop.”
• Dual Frontend: TUI + Web UI: The TUI is for developer debugging, while the Web UI targets end-users. This “separation of development and production modes” is rare in Agent frameworks.
• Batching and Concurrency: Version 2.0 improves scheduling for concurrent multi-Agent execution, fixing the prior version’s “serial sub-agent lag” issues.

How does multi-model collaboration actually work?

Since Version 2.0’s headline feature is multi-model collaboration, how are models configured? According to examples by the author, model setup follows the OpenAI-compatible protocol—meaning any service (official API or aggregator) that emits OpenAI-style responses can connect directly.

models:
  planner:
    base_url: https://api.openai-hub.com/v1
    model: claude-opus-4-6
    api_key: ${API_KEY}
  worker:
    base_url: https://api.openai-hub.com/v1
    model: deepseek-chat
    api_key: ${API_KEY}
  vision:
    base_url: https://api.openai-hub.com/v1
    model: gemini-2.5-pro
    api_key: ${API_KEY}

This design is friendly for developers in regions like China—one key gives access to all models, no need for separate proxies or authentication per provider. Aggregated services like OpenAI Hub are designed for exactly this scenario, and together with Terrarium’s multi-model node scheduling, it allows developers to “just swap a line in YAML to switch models.”

Remaining drawbacks

To be fair, Version 2.0 isn’t without issues:

1. Documentation is catching up. With so many breaking changes, the migration guide is currently brief—1.x users must do manual adaptation.
2. Tool ecosystem is small. It can’t yet compare with LangChain’s vast integrations; complex tools generally require custom implementation.
3. No explicit MCP support. Given MCP’s emergence as the de facto standard for tool protocols, missing explicit server/client support is a clear shortcoming—likely to be addressed in future releases.
4. No performance benchmarks. Throughput for multi-Agent collaboration and overhead for state restoration are not yet quantified.

Final thoughts

By 2026, the word “Agent” has been so overused it’s lost meaning. Yet frameworks that genuinely let developers “write less code and think more” remain rare. KohakuTerrarium 2.0 tackles two of the most practical pain points—execution state and multi-model coordination—and heads in the right direction.

Notably, the author is active in the LINUX DO community, and the Kohaku series (including KohakuBlueleaf image models) has maintained a solid reputation in open-source circles. Frameworks like this depend not only on technology but on patience and community feedback. Judging by the steady iteration from 1.x to 2.0, the author seems committed.

If you’re planning to build your own Agent soon, or you’re curious about paradigms like openclaw or Hermes but don’t want to start from zero, this project is worth cloning and exploring.

References

• KohakuTerrarium GitHub repository — Official repo with source code, configuration examples, and documentation
• KohakuTerrarium 2.0.0 major update announcement (LINUX DO) — Author’s post on LINUX DO community explaining version details and design philosophy