# Oinone Pamirs: an AGPL Java back end for metadata-driven enterprise apps

> Oinone is a low-code framework split across a Java back end, this repository, and a separate front end. What the README claims and what the module list shows are not quite the same shape.

**oinone/oinone-pamirs** — Oinone is an AI‑Powered low‑code framework that unifies AI and developers around a shared metadata model to build maintainable, evolvable, high‑quality enterprise intelligent applications.[AI Coding][Vibe Coding][Framework][Low Code]

- Repository: https://github.com/oinone/oinone-pamirs
- Website: https://oinone.ai
- Stars: 2,350 · Forks: 210
- Language: Java
- License: AGPL-3.0
- Published: 2026-10-07 · Updated: 2026-10-07 · Language: en
- Canonical page: https://hysenlabs.com/projects/oinone-oinone-pamirs

## Nine Maven modules that describe the architecture

The repository root is a Maven multi-module build, and the module names do more explanatory work than the README does. `pamirs-boot/` is the Spring Boot entry point. `pamirs-core/` is the engine. `pamirs-framework/`, `pamirs-framework-commons/` and `pamirs-framework-adaptor/` are the framework layer plus its shared utilities and its adapter layer, which is where the platform-specific integration points live. `pamirs-middleware/` holds cross-cutting concerns, `pamirs-spi/` is the extension point contract, and `pamirs-ux/` is the user experience layer.

Two things follow from that list. The presence of `pamirs-spi/` means customisation is expected to go through a defined interface rather than by editing the core, which is the conventional arrangement for a framework that wants third-party extension. And `pamirs-k2/`, sitting beside the rest with no explanation in the README, looks like a vendor or product-specific integration module rather than a general one.

The primary language is Java and the repository carries both `README.md` and `README_zh-CN.md`, so the English document is the translated one and the Chinese one is likely the original. There is no `docs/` directory, no `CONTRIBUTING.md`, and no example project in the tree.

## The quickstart is a compose file pulled from a mirror host

The README's quickstart is three commands and a set of default credentials, and it does not build anything from this repository. It downloads a compose file from a Gitee raw URL, brings it up, and points a browser at localhost:

```bash
curl -L https://gitee.com/oinone/oinone-docker-shared/raw/master/oinone/docker-compose.yml -o docker-compose.yml
docker compose -p oinone up -d
# open http://127.0.0.1:88   admin / admin
```

So what you get from that is a running Oinone instance built from published images, not from the Java sources in this repository. That is a reasonable way to evaluate the product and a useless way to develop against it, which matters because the README calls this the back-end repository and never explains how to build or run it locally from a clone.

The README also says the first boot takes a few minutes and gives you a way to watch it:

```bash
docker logs -f oinone-backend
```

A slow first boot for a low-code platform is normal, since the first run typically creates schema and seeds metadata. It does mean a five minute estimate in the README is a floor rather than a promise, and it is worth having the logs open from the start rather than assuming a hang.

The credentials are `admin` and `admin` on port 88. Fine for a local evaluation, and something to change before that compose file is ever pointed at anything else.

## What 100% metadata-driven means and what it asks of you

The framework's central claim is that it is 100% metadata-driven. The README's argument for that claim is aimed specifically at AI coding assistants: because the design principles and development paradigms are expressed as metadata and open code, a code-generating model can read the framework's own rules rather than improvising against a free-form scaffold.

That is a coherent position, and it is a recognisable one. Low-code platforms that describe themselves as free-form code generators produce demos. Platforms that encode structure as data produce systems. The README is explicit that it is the second kind, listing visual no-code design, an enterprise software foundation, enterprise integration and simplified complex technology as the four parts of what it calls framework discipline.

The second structural claim is a data feedback loop that runs through training, modelling, execution, evaluation and autonomous execution. This is the least concrete part of the README, since no mechanism is described, and it is the part a technical evaluator should press on. Everything else in the document is either a module name or a capability list; the self-evolving loop is a diagram reference and an aspiration.

The agent layer is called Aino, an ontology-based enterprise AI agent platform, positioned beyond chatbots and combining model access, fine-tuning, tool and skill libraries, knowledge bases and agent orchestration. That is a lot of surface area described in two sentences, and the repository contains none of it: no Python, no model serving code, no agent runtime in the module list.

## AGPL-3.0 is the first question to ask about this framework

GitHub reports the repository as AGPL-3.0, and the repository root contains a `LICENSE.txt`. For an enterprise low-code platform that is the single most consequential fact in the metadata, and it deserves attention before the architecture does.

AGPL extends the copyleft obligations of GPL to network use. If you run a modified version of this software and let users interact with it over a network, you owe them the corresponding source of your modifications. Whether that affects a commercial deployment depends entirely on how you deploy it: an unmodified instance serving your own staff internally is a different question from offering a hosted multi-tenant service built on a modified Pamirs. I am not offering a legal opinion here, but the point is that this is a decision for whoever owns your compliance function, and it needs an answer before evaluation rather than after.

There is also no dual-licensing option advertised in the README and no commercial edition link, which is worth noticing for a framework whose customer list in the README is entirely named enterprises.

The last push to the repository was on 2026-09-03 and the project publishes no GitHub releases, so there is no published version to pin and no changelog to read. For a framework at that stage, cloning the default branch is the only option, which is worth factoring into any upgrade plan.

## The one-stop framing and the two-repository reality

The README explains that the name Oinone is a phonetic echo of all in one, meaning one-stop solutions, agile responsiveness and continuous innovation. It is a nice name for a platform whose stated ambition is to unify AI and developers around a shared metadata model.

The repository layout complicates that framing in a small but concrete way. This repository is explicitly the back end. The front end lives in a separate project, oinone-kunlun, hosted on both Gitee and AtomGit and mirrored to GitHub. So the metadata model that the whole thesis rests on is interpreted and edited by a front end you are not looking at.

For an evaluator this is a real consideration rather than a nitpick. If your team is going to build custom screens, the front-end framework is where the work lands, and its extension model is documented separately from this repository. The two-repository split also means a version mismatch between back end and front end is a thing you have to manage.

The hosting arrangement is worth noting too. Documentation, mirrors and the compose file all point at Gitee and AtomGit, Chinese Git hosting services, with GitHub as the English-facing mirror. For a team outside China that is mostly a bandwidth and access question, but it does mean the primary documentation site is not the one linked from the repository you are reading.

## Who the README says this is for, and what cannot be checked

The README names its audience twice: developers, enterprise research and development teams, and software companies. The named customers are Chinese enterprises across manufacturing, automotive parts, software and tobacco, and the business domains listed include MES, APS, ERP, HIS, internal control, anti-counterfeiting traceability, investment management, OMS and F2B2b.

None of that is verifiable from the repository, and it should be read as positioning rather than evidence. There are no case studies, no architecture decision records, no benchmarks, and no issue history in the tree to corroborate it. For a framework you would deploy against an internal control or traceability requirement, that absence is not a small gap.

What the repository does offer as evidence is structural. A nine-module Maven build with a dedicated SPI module, a middleware layer, and a user experience module is a coherent shape for a framework of this kind. The pom.xml at the root and the module directories are real, and the fact that `pamirs-k2/` is present without explanation suggests the platform has at least one specialised integration that is not part of the general story.

The documentation the README links sits on external sites rather than in this repository, and the demo table at the end of the front page is present without content. So the practical starting point is the compose quickstart, then the external guide, then the module you actually need to extend.

## Conclusion

Pamirs is a substantial Java framework rather than a thin generator, and the module split in the repository is real rather than aspirational. What you cannot verify from the repository is the part that matters most for an enterprise decision: the documentation lives on external sites in English and Chinese, the repository publishes no releases, and the customer list in the README is unverified marketing. If your requirement is a metadata layer that both people and code generators write against, the architecture fits. Fetch the compose file, boot the stack on port 88 with the documented admin credentials, and read `pamirs-spi/` and `pamirs-ux/` before committing a team to it.

## FAQ

### What is Oinone Pamirs and what does this repository contain?

Pamirs is the Java back-end half of the Oinone low-code framework, and the README says so explicitly. The repository is a Maven multi-module build with nine modules: `pamirs-boot`, `pamirs-core`, `pamirs-framework`, `pamirs-framework-commons`, `pamirs-framework-adaptor`, `pamirs-middleware`, `pamirs-spi`, `pamirs-ux` and `pamirs-k2`. The front end is a separate project, oinone-kunlun.

### How do I run Oinone locally to try it?

The README quickstart downloads a compose file from a Gitee raw URL, runs `docker compose -p oinone up -d`, and opens http://127.0.0.1:88 with the credentials admin and admin. First boot takes a few minutes, which you can watch with `docker logs -f oinone-backend`. Note that this starts published images rather than building from the Java sources in the repository.

### Why does a commercial-looking low-code framework use AGPL-3.0?

GitHub reports AGPL-3.0 for the repository and a `LICENSE.txt` sits at the root, and the README advertises no alternative licence or commercial edition. AGPL extends copyleft to network use, so whether it constrains a particular deployment depends on how you host a modified version. That question belongs with whoever handles your compliance obligations rather than with a technical evaluation.

### Does Oinone publish versions I can pin?

No GitHub releases are published for this repository, and the last push was on 2026-09-03. There is no changelog and no version history to read, so tracking the default branch is the only option and any upgrade plan has to account for that. The documentation the README links lives on external sites rather than in the repository.

## Sources

- [Issues](https://github.com/oinone/oinone-pamirs/issues)
- [License: AGPL-3.0](https://github.com/oinone/oinone-pamirs/blob/feature/7.2.0/LICENSE)
- [oinone/oinone-pamirs on GitHub](https://github.com/oinone/oinone-pamirs)
- [Project website](https://oinone.ai)
- [README](https://github.com/oinone/oinone-pamirs/blob/feature/7.2.0/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/oinone-oinone-pamirs