Among all the places you could compromise, find the one direction that holds
Zhenbei builds enterprise infrastructure: unified identity and Agent IAM (UIAM), a multi-tenant AI agent platform (Uniclaw), private-domain SCRM for WeCom (Uniscrm), an online learning platform (Unilearning), and a hardcore toolkit for developers — legdger, NewTool and pxc.
What Zhenbei is
True North is the direction the compass actually points — not the one the needle drifts to under magnetic interference. We build infrastructure in pursuit of the same thing: among countless places where compromise is possible, find the direction that stays correct, then pin it down.
What we build
Four main business lines — UIAM (unified identity and authentication), Uniclaw (enterprise AI agent platform), Uniscrm (WeCom private-domain SCRM) and Unilearning (online learning platform) — plus a hardcore toolkit built for developers themselves: legdger, an encrypted local-first ledger; NewTool, driven by a Rust algorithm kernel; and pxc, a traffic-capture proxy benchmarked against Proxyman.
What we do not do
We do not sacrifice the data model for demo effect, do not make uploading user data to the cloud the default, and do not re-implement business logic in the UI layer. Each is a hard constraint written into repository conventions, not marketing copy.
How we decide something is done
We look at whether the numbers moved. Every product page has a “code facts” column: endpoint counts, table counts, module counts, migration counts. These are countable in the repository, and they are how we judge progress and quality internally. Adjectives do not count as done.
- Company
- 真北科技
- English name
- Zhenbei
- Domain
- zhenbei.tech
- Namespace
- tech.zhenbei.*
- Location
- Shanghai, China
- Business lines
- UIAM / Uniclaw / Uniscrm / Unilearning
- Tools
- legdger / NewTool / pxc
- Runtime languages
- Kotlin · Java · TS · Go · Rust · Swift
Seven product lines, one engineering standard
Four business lines plus three tools. Different languages, different forms, but one shared set of constraints: contract first, boundaries enforced by the compiler or framework, every action auditable.
Four things we are willing to be checked on
These are not values posters — they are practices you can verify in the product and the code.
Go’s internal wall makes cross-domain imports fail at compile time; jOOQ’s access listener intercepts missing tenant predicates at the query layer. Any constraint that can be hardcoded is not left to a document to remember.
On the device-side product (legdger), neither the books nor AI inference ever leave the device; in private deployments the models, vectors and business data all stay inside the customer network. That is the product form, not a switch.
UIAM gives agents MACHINE principals and tool-level grants; Uniclaw splits the cognitive loop into four independent engines; NewTool exposes its algorithm kernel to AI, humans and the browser alike.
Migration tooling, legacy data import, rollback plans and runbooks ship with the delivery. Unilearning’s legacy-system migration preserves IDs and original passwords, so business teams do not start over.
What kind of company Zhenbei is
The four lines look unrelated — identity, agents, private-domain CRM, online learning. What connects them is not an industry but a way of working.
The four lines differ in language and shape, but share one set of constraints: contract first, boundaries enforced by the compiler or framework, every action traceable.
UIAM's api/biz layering and Unilearning's api/internal layering are the same rule expressed in two languages
Every product reserves an identity, credential and read-only interface slot for agents. AI gets structured output, not screenshots.
UIAM's four Agent IAM pillars; Uniclaw's 19 built-in tools; legdger's read-only ledger-cli token
Any constraint that can be baked into the compiler, the framework or the query layer does not go into a document for people to remember.
Tenant filtering is enforced by a jOOQ VisitListener in the query layer; Go’s internal wall makes cross-domain imports fail to compile
Sensitive data stays on the user’s own device or inside the customer network by default; the cloud only does what it must. Every business line supports private deployment.
legdger runs AI on-device with local encryption; Uniclaw can self-host models and memory; Unilearning ships as a single container
Scale is counted, not described
Every number below maps to a module, table or endpoint that actually exists in the code. It is also how we decide whether something is done.
KotlinUIAM identity kernel · Uniscrm business modules
JavaUniscrm WeCom server side
TypeScriptUniclaw agent runtime · console
GoUnilearning modular monolith · pxc kernel
RustNewTool algorithm kernel · CLI · WASM
Swiftlegdger on iOS and macOS · pxc macOS shell
From one identity system to four business lines and a toolkit
The timeline only records milestones backed by deliverables. We do not write “aspires to be” sentences — only what was actually built.
It began with one identity system
Zhenbei’s first business line was unified identity. The starting point was concrete: customers ran several business systems, each maintaining its own accounts, with mismatched permission semantics and no audit view to show. We started from the identity kernel, getting OAuth 2.1 / OIDC, tenant isolation and fine-grained authorization right.
The identity boundary moved from people to AI
As agents entered enterprise systems, the existing identity model could not hold them: agents worked with human tokens, and incidents could not be attributed. So machine principals, delegation chains, multi-hop propagation and MCP tool authorization became first-class capabilities of the kernel.
One business line became four
Beyond identity, customers raised needs in private-domain operations, online learning and AI applications — all sharing the same underlying judgements: where data should live, and who should guard the boundary. Four business lines took shape, in different languages but under one engineering standard.
Turning “good enough” into “holds up”
Once products ran in production, the real pressure came from operations and iteration. We did two structural rebuilds: Unilearning folded 6 microservices into 1 modular monolith, and Uniscrm rebuilt customer relationships from “friends inside an employee’s WeChat” into a company asset that can be inherited.
The toolkit: built for ourselves, used by ourselves, then shipped
Across four business lines in production we accumulated a set of internal tools sharing one trait: kernel separated from shell, with AI treated as a first-class citizen. We polished them into products — running internally first is what made us willing to ship them.
How we build products
Not methodology slogans — hard constraints written into each repository’s AGENTS.md and enforced on every commit.
Product capability lives in a testable, reusable kernel; the UI is just a shell. Algorithms are written once and shared by people and AI alike.
Sensitive data stays on the user’s device by default; the cloud only handles what it must — sync and collaboration.
Kernel and shell agree on exactly one contract — a /v1 API, a CLI envelope or an algorithm manifest — so behaviour is identical across platforms.
Every product reserves an integration point for agents: identity, credentials, a read-only CLI and structured output, so AI can work safely.
Once a data model is settled it is never overturned. Load-bearing walls are fixed; everything else is free to iterate quickly.
From identity audit to captured traffic, every action is traceable, replayable and shareable. Debugging stops relying on word of mouth.
How we deliver
From the architecture call to production operations, we turn every step into a verifiable artifact.
Thirty minutes to map out the current state, constraints and goals, ending with a written problem list.
Architecture layers, data model and migration path — with the trade-offs stated explicitly.
Private-deployable, infrastructure as code, identical environments.
Stable kernel, backward-compatible interfaces, audited and rollback-able changes.
A few milestones backed by deliverables
The full evolution lives on the timeline; only the three most recent phases are shown here.
Beyond identity, customers raised needs in private-domain operations, online learning and AI applications — all sharing the same underlying judgements: where data should live, and who should guard the boundary. Four business lines took shape, in different languages but under one engineering standard.
Once products ran in production, the real pressure came from operations and iteration. We did two structural rebuilds: Unilearning folded 6 microservices into 1 modular monolith, and Uniscrm rebuilt customer relationships from “friends inside an employee’s WeChat” into a company asset that can be inherited.
Across four business lines in production we accumulated a set of internal tools sharing one trait: kernel separated from shell, with AI treated as a first-class citizen. We polished them into products — running internally first is what made us willing to ship them.
Other directions
Historical experience and new exploration — both judged by what we can actually deliver.
Deep blockchain experience across industries, from advisory through to delivered systems.
Process, product, engineering and management working together as end-to-end advisors for private-domain operations.
Hand the complexity of identity, agents and private domain to one governable kernel
Whether you are replacing an existing IAM, building an agent platform, or trying to make private-domain operations actually work — start with a 30-minute architecture call. We will first judge whether this is the kind of problem we are good at, and say so plainly if it is not.