Library / SDK
openJiuwen-ai/agent-core avatar
openJiuwen-ai/agent-core

openJiuwen Core pins one dependency exactly and reaches one of them over git

openJiuwen agent-core provides a complete set of SDK capabilities related to AI Agent development, running, optimization, and evolution.

471 stars138 forksPythonApache-2.0

At a glance

What is it?
A Python agent SDK for the openJiuwen framework with two agent types, an asynchronous parallel graph executor, and checkpoint recovery for interrupted workflows. The dependency list explains more about its constraints than the feature list does, and one package is pinned to an exact version because a floor would move an algorithm under vendored code.
Who is it for?
Use it if you are building on the openJiuwen framework and want the SDK layer, the graph executor and checkpoint recovery rather than a bare model client. Check your Python version first, since the package requires 3.11 or higher and below 3.14 and recommends 3.11.4.
Can I use it commercially?
Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 1 day ago.
What is it written in?
Mainly Python, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • openJiuwen-ai/agent-core471 ★ · +68
Star history
Repository2026-08-042026-11-15
openJiuwen-ai/agent-core403471

68 Stars in the last 103 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

One dependency is pinned exactly, and the comment says why

Most entries in the dependency list are floors, written with >= and a version. One is not:

code
    "agentdescent==0.4.6",

The comment above it explains the exception at length. The program_opt module vendors a PUCT port out of that package's examples directory, which the wheel does not package, and imports internals around it including FlatPuct, Candidate.prior, AggregatorConfig, vv_staleness, Ledger and get_policy. None of those promise stability across releases, so a floor would let a minor bump move the algorithm the vendored code was written against.

That is the single most useful thing in the file. A pinned transitive dependency with a written justification is a maintainer telling you where the coupling is, and it tells you what breaks first when something moves.

One dependency installs from a git branch, not from an index

Another line bypasses package resolution entirely:

code
    "intelli-router @ git+https://gitcode.com/openJiuwen/agent-protocol.git@feature/intelliRouter#subdirectory=intelli_router",

A direct URL, a branch name rather than a tag, and a subdirectory that is the actual package. So an installation of this SDK depends on a branch on gitcode.com being reachable and containing the code it expects.

The practical consequences sit outside the version number. There is no checksum pinning a wheel, an offline or air-gapped install cannot resolve it, and a change to that branch lands in your environment without a release here. The examples directory includes an intelli_router folder, which suggests the routing layer is meant to be exercised rather than assumed.

Two agent types, and they differ in who decides the next step

Two prebuilt agents ship in the package. ReActAgent follows the reasoning plus action paradigm, running iterative cycles of thinking, action and observation, with multi-round reasoning and self-correction for scenarios that need strategy adjustment mid-task.

WorkflowAgent does the opposite. It executes a user-predefined process strictly, for task structures that decompose cleanly into steps, and it can switch tasks when user intent changes.

Both are wrapped by the same WorkflowAgent application class in the worked example, which calls a workflow through a Runner. The example builds a graph from Start, End and LLMComponent with an LLMCompConfig and a generated workflow key, then prints a result. The expected output line is a single sentence of generated text, which is a low bar for an agent SDK but a clear one: the workflow ran and produced output.

The executor parallelizes a graph, which is what makes checkpoints meaningful

The execution engine is described as an asynchronous parallel graph executor with component concurrency, asynchronous IO and structured context management, supporting parallel processing of multiple workflow tasks and flexible invocation of heterogeneous components.

Components pass values in batch or streaming form, and the engine supports dynamic jumping, state interruption and recovery. Data storage and streaming covers streaming output, streaming between components, and connecting to external storage systems to externalize agent context, which is the part that makes elastic scaling in a distributed deployment plausible.

That combination is what the multi-workflow jump feature rests on. An agent can manage several workflows in one session and switch between them, and an interrupted workflow resumes from a checkpoint. Without externalized state, both claims would be hard to keep.

Python 3.11 to 3.13 only, with an upper bound rather than a test

The install line is short:

bash
pip install -U openjiuwen

The constraint is in pyproject.toml rather than the readme. requires-python is >=3.11,<3.14, and the classifiers stop at 3.13. The readme says 3.11 or higher but lower than 3.14, and recommends 3.11.4 specifically.

That recommendation is unusual, since the newest supported version would normally be the suggestion. Taking it at face value means the SDK is tested hardest on the oldest version in range, which is the safer assumption for a package carrying native or compiled components but also means you give up the newer interpreter.

The project version is 0.1.19 and the classifier declares Development Status 4, Beta. Operating system support is stated as Windows, Linux and macOS.

The Makefile branches on Windows shells before it runs anything

The build tooling is written for cross-platform use in a way that shows in the file itself. There is a block that detects cmd.exe and sh.exe, and inside it the quotes, the null device, the blank-line echo, the failure command and the curl binary all change: NUL instead of /dev/null, exit /b 1 instead of exit 1, curl.exe instead of curl.

The file also decides its default goal from environment variables rather than from arguments. Setting DEP switches the default target to dep, FLAME to flame, SPEEDSCOPE to speedscope, and otherwise it lands on help.

The changed-file detection is the part that shows care. It runs git diff with a null terminator, pipes it through a Python one-liner that filters for .py and .pyi, and does it that way specifically so paths with quotes survive on Windows. Lint, format, spelling and type-check targets all operate on that filtered list.

Two dozen example directories describe the scope better than the feature list

The examples folder is the clearest statement of what the SDK is for. It holds MANGO, PerStream, a2a, adaptive_multi_agent_collab, agent_evolving, context_evolver, graph_memory, harness, intelli_router, interact, jiuwenrl_online, lsp, mcp, mobile_gui, multi_agent, permissions, react_agent, retrieval, rl_calculator, rl_nl2sql, security_rail_demo, session, skill_evaluate and lsp-adjacent work, each in its own directory.

Several of those names are capabilities the feature list does not mention: permissions, security_rail_demo, skill_evaluate, context_evolver and graph_memory. So the SDK covers skill evaluation, a security rail, permission handling, memory as a graph and context evolution, and the readme's two-paragraph feature summary does not get near that.

The presence of a2a and mcp example directories puts it alongside the current agent protocols, next to RL tooling in rl_calculator, rl_nl2sql and jiuwenrl_online, which matches the dependency on transformers, tiktoken and dashscope.

Editorial conclusion

Use it if you are building on the openJiuwen framework and want the SDK layer, the graph executor and checkpoint recovery rather than a bare model client. Check your Python version first, since the package requires 3.11 or higher and below 3.14 and recommends 3.11.4. Read the dependency comments before you upgrade anything: one package is floored, one is pinned to an exact version for a stated reason, and one is installed straight from a git repository on a feature branch. Those three lines tell you where the fragility actually is.

Frequently asked questions

Which Python versions does openJiuwen Core support?

requires-python is >=3.11,<3.14, with classifiers listing 3.11, 3.12 and 3.13. The documentation recommends Python 3.11.4 specifically, and the operating systems stated are Windows, Linux and macOS.

What is the difference between ReActAgent and WorkflowAgent in openJiuwen Core?

ReActAgent runs iterative thinking, action and observation cycles with self-correction for open-ended reasoning. WorkflowAgent strictly executes a user-defined process for tasks that decompose into steps, and can switch tasks when intent changes.

Why is agentdescent pinned to an exact version in openJiuwen Core?

The program_opt module vendors a PUCT port from that package's examples directory and imports internals around it, none of which promise stability across releases. A floor would let a minor bump move the algorithm the vendored code was written against.

How does openJiuwen Core handle an interrupted workflow?

The asynchronous parallel graph executor supports state interruption and recovery, and checkpoint recovery is provided through the framework. Context can be externalized to external storage systems to support elastic scaling in distributed scenarios.

How do you install openJiuwen Core?

Run pip install -U openjiuwen. One dependency is installed from a git URL on gitcode.com using a feature branch and a subdirectory rather than from a package index, so the install needs network access to that repository.

Official sources

  1. Official README
  2. Project repository
  3. Release notes
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/openjiuwen-ai-agent-core.svg)](https://hysenlabs.com/projects/openjiuwen-ai-agent-core)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/openjiuwen-ai-agent-core.svg)](https://hysenlabs.com/projects/openjiuwen-ai-agent-core)

Was this useful?