openJiuwen 0.1.19: Business-Defined Metrics

Trigger

On September 29, 2026, the team behind the open agent framework openJiuwen agent-core released version 0.1.19. The release includes an RFC for the Reward Engine, two-loop online agent evolution, agent-team orchestration, and package-based Skill installation. For a company implementing agents, the release leads to a simple conclusion: an agent that learns on the job is only as useful as the precision with which its desired outcome is defined.

Without a metric, self-learning amplifies the error.

What is included in the release

The authors highlight six areas: agent self-evolution, team orchestration, the Skill lifecycle, runtime reliability, security, and observability.
Specific changes: - Reward Engine RFC.
A draft specification for a module that evaluates agent actions and issues a numerical reward.
The behavior the agent reinforces depends on this evaluation. - TTSE dual-track online evolution.
The agent changes its behavior on the fly along two parallel tracks.
The architecture is described in an RFC, so the details should be checked against the source code. - Team Organization and scheduler.
Multiple agents are assigned roles, and a planner distributes tasks among them. - Proactive Context Service.
The service selects the agent's context in advance, before the request. - Skill packages.
Skills are installed as packages, and built-in Skills are available to third-party agents. - Streaming tool-call arguments and enhanced file tools.
The interface receives tool-call arguments in parts and can display progress. The fixes include recovering an agent team after a failure, RSI (recursive self-improvement) evaluation, and integration with memory-server.
Based on these points, the framework's current weaknesses lie in team fault tolerance and agent memory.

Why an agent needs a reward function

A standard LLM agent follows an instruction: prompt, tools, response.
It will repeat the error until an engineer fixes the prompt.
A self-evolving agent collects a signal about the quality of its actions and adjusts its strategy accordingly. This signal is called a reward. A person defines the reward.
If a support agent is rewarded for closing a ticket, it will learn to close tickets, while the share of resolved problems may fall. In machine learning, this is called reward hacking: the system optimizes a number the business does not need.
That is why implementing the Reward Engine depends on management maturity before it depends on code. A manager who cannot define an employee’s outcome metric will not define one for an agent either.

Assess where AI can deliver impact in your process

clients@kt.team Telegram @kt_team_it

Where self-evolution breaks in production

Take an agent that enriches product cards in PIM: it adds descriptions, assigns attributes, and links products to the taxonomy.

If you pay it for “card completeness”

, and the fields will be filled with plausible nonsense.

If you pay for card conversion, the signal will arrive weeks later, and the agent will learn from noise. This approach works in our catalog-enrichment projects involving facets, card text, taxonomy, and manual tag overrides.

The agent proposes a change, the validator checks it against reference-data rules, the editor selectively approves it, and the history records who changed what.

Feedback from the validator and editor serves as a reward that can be verified and rolled back.

This leads to three conditions that must be met before online evolution is released to production: 1. A metric with an owner.

A specific person owns the number the agent learns from. 2. Decision log.

Every change in the agent’s behavior is visible in the logs and linked to the reward that triggered it. 3. Rollback.

The agent can be restored to last week’s version in minutes

In our assessment, openJiuwen is not yet fully there with the third condition: the release included fixes for recovering an agent team after a failure.

Agent teams and Skills as packages

Team orchestration and Skill packages address an engineering challenge that often derails pilots. A Skill installed as a package gets a version, dependencies, and an update procedure, like any library.

For an integrator, this is a TTU (time to use) question: how much time passes from “we found a useful Skill”

to “the Skill works for the customer.” Giving third-party agents access to built-in Skills solves the same problem as the MCP protocol: describe a tool once and connect it to different agents. This is how we build agent integrations with 1C, PIM, and ESB. Agent tools live in MCP servers, model requests go through the LLM & Security Gateway, and business-system events arrive through Apache Kafka. Each component can be replaced separately, so integrations do not need to be rewritten when the orchestration framework changes.

Proactive Context Service works as anticipatory RAG: the system selects the documents the agent will need in advance. This reduces response time while expanding the leakage surface. If the service retrieves context automatically, data access rights must be checked before the model, at the gateway level.

What should businesses do about this?

Version 0.1.19 belongs to an early framework with an ambitious roadmap, and its most interesting features are still described only in RFCs. A practical strategy: - test the concept of a controlled reward on your agent using a clear metric: the share of cards that pass validation or the share of requests resolved without repeat contact; - keep the tools and model-access layer independent of the framework so changing the orchestrator takes days; - enable online evolution where agent errors are inexpensive and reversible.

Verdict

Based on openJiuwen, self-learning agents will enter enterprise systems as rewards, skill packages, and teams with a scheduler. Framework developers will build this part. Companies will have to create the outcome metric, decision log, and rollback process themselves. An agent trained on a poor metric will drive the process toward failure quickly and confidently, and the manager who launched it will be responsible for that failure.

openJiuwen 0.1.19: Business-Defined Metrics

Trigger

What is included in the release

Why an agent needs a reward function

Assess where AI can deliver impact in your process

Where self-evolution breaks in production

The agent can be restored to last week’s version in minutes

Agent teams and Skills as packages

What should businesses do about this?

Verdict

Discuss the article: openJiuwen 0.1.19: for a self-learning agent…

Continue on the topic

Related solutions

Articles on the topic

Related videos

News on the topic