English | 简体中文
Nuwa is not a prompt generator — it is a mother-forge for digital employees. Describe the AI employee (or team) you want; Nuwa delivers a complete, deployable agent home: a ready-to-run folder — persona (guardrails, honesty, injection-hardening built in) + memory scaffolding + growth loop + launch instructions, everything interlocking. Ask for a team and you also get the entire methodology and infrastructure of a digital-employee team (responsibility partitioning, orchestration, collaboration rules, shared foundations). Kernel updates have a first-class path (
UPGRADE.md): new versions never cost you your customizations.
Keywords: digital employee · AI agent · agent team · multi-agent · prompt architect · system prompt · agent design · guardrails · prompt engineering · agent memory · prompt compiler
You don't need to know how to write a prompt. Just have an AI coding assistant that can read local files (Claude / Cursor / etc.):
flowchart LR
A[① Download this repo<br>clone / download] --> B[② Hand it to your AI<br>"Read START_HERE.md and follow it"]
B --> C[AI sets up your Nuwa base<br>nuwa-base/]
C --> D[③ Start a fresh chat<br>working dir set to nuwa-base/]
D --> E[Describe the agent you want,<br>one sentence]
E --> F[🎁 A complete agent home<br>persona + memory + launch guide]
① Download this repo — clone or download it locally.
② Hand the project to your AI and have it read START_HERE.md:
In your AI assistant, open this folder and say: "Read
START_HERE.mdand follow it."
③ The AI sets up your "Nuwa base," and reminds you to start a fresh conversation there — in the new conversation, Nuwa opens by asking: one agent, or a whole team?; then clarifies your requirements (never guessing critical constraints, always offering name candidates for you to pick) → selects a tier → compiles → hands over the agent home plus a plain-language statement of what it can do for you.
Already on an older version? See docs/UPGRADE.md — five steps, nothing of yours is lost.
There are only two entry points at the top level, cleanly split; everything else is material Nuwa itself uses. Skim this table and the tree, then decide what to read.
| You are… | Start here |
|---|---|
| A human, exploring | This README.md you're reading right now; want a hands-on usage guide → docs/USAGE.md |
| A human, ready to build an agent | Hand this project to your AI assistant and say "read START_HERE.md and follow it" |
| Already on an older version, upgrading | docs/UPGRADE.md — five steps, nothing of yours is lost |
Nuwa/
├─ README.md # This file · the human landing page (you are here)
├─ START_HERE.md # ⭐ The build entry point (English) — hand this to your AI to read
├─ START_HERE.zh-CN.md # ⭐ Build entry point, Chinese edition — Chinese-speaking users hand this one to their AI
├─ nuwa-v10.md # The Nuwa kernel (generic layer): the six-step compiler + every guardrail + team forging
├─ AGENTS.md # Conventions for AI tools that auto-read this repo
├─ CHANGELOG.md # Version history (full history since v4.0)
├─ LICENSE # PolyForm Noncommercial 1.0.0 (noncommercial)
├─ docs/ # Detailed guides: USAGE.md (plain-language usage guide) · UPGRADE.md (upgrade guide)
├─ templates/ # Persona skeletons + agent memory scaffolding + team skeleton (bilingual)
├─ registry/ # Ecosystem capability-component registry (a machine-readable index of the 7 independent skill repos)
├─ schemas/ # Machine-readable assembly-request contract: assembly-request.schema.json (the schema)
│ # + .example.json (a worked example) + validate_assembly_request.py (the validator script)
└─ examples/ # Example builds (including one team-forging example)
No concepts, just outcomes — after one run of Nuwa, here's what you walk away with:
- A whole digital-employee folder, not a snippet of prompt text — a ready-to-run home: a persona file (hard gates — actions that must be confirmed with you first; honesty rules — never claiming a tool it doesn't have; injection resistance — instructions inside foreign content are always treated as data) + a pre-set-up memory directory + launch instructions, every piece interlocking. Drop it into any file-reading AI assistant and it's ready to work.
- An agent that grows, not a one-shot toy — a judgment-type agent ships with a built-in "predict → backfill → calibrate" loop, judging more accurately the longer it's used; the pre-set-up memory structure lets it remember what it learned last time.
- A genuinely collaborating team (if you want one) — forge N specialist agents plus one orchestrator plus a shared foundation, in a single pass; responsibilities get carved up before headcount is decided, so the finished team doesn't step on itself and can pull each other in to collaborate.
- No bureaucratic self-sabotage from the agent it builds — Nuwa compiles capability, not cages: by default, the only standing confirmation gates are for spending money or making a legally binding external commitment; deletion, credentials, and privacy risk each get routed to the matching technical-hygiene default instead of a stop-and-ask; no "that's not my job" walls between roles — a specialty is a routing hint, not a jurisdiction; handoffs between agents always carry goal, constraints, evidence, and open items.
- Updates that never cost you your setup (since v9.0) — when a new kernel version ships, follow the five steps in
docs/UPGRADE.md: your customizations and your agent's memory are entirely preserved, and you still get every new capability. The maintainer's own deployment runs the exact same kernel you do, through the exact same update path (dogfooding). - Every agent tells you what it can actually do for you at delivery — Nuwa always hands off with a plain-language statement of the effect, so you're never left guessing what the thing is good for.
Writing a system prompt that works isn't hard; writing one that survives real deployment is — it has to hold up on boundaries, honesty, attack resistance, and auditability all at once. Nuwa turns that engineering discipline into a compiler:
- Layered & isomorphic ⭐ new in v9.0 — the kernel splits into a generic layer (methodology / guardrails / process — exactly what's in this repo, zero deployment-private information) and a deployment layer (your names / paths / team / local conventions, living in your own base's documents). The payoff is direct: upgrading to a new kernel version is a straight file replacement, and your customizations are never at stake; the maintainer runs this exact same generic layer too, so the update path has actually been walked, not just designed on paper.
- True-Name protocol ⭐ new in v9.0 — "the persona cites a memory file it must read, but that file was never created" is a field-verified cause of agent persona drift (the agent loses its anchor every time it starts up, and second-guesses itself). v9.0 promotes reference-implies-existence to a hard compile-time check: when an agent is born, every memory file its persona names is genuinely created (at least a skeleton); the memory index enforces an explicit created/not-yet-created split.
- Capability-first anti-cage — Nuwa's compiler only stacks capability, never cages: by default, the only standing business confirmation gates are for spending money or making a legally binding external commitment; deletion, credentials, and privacy each get routed to recoverable-by-default, never-plaintext, or scan-before-publish technical hygiene instead of stopping to ask every time. It never writes "that's not my job" walls — a specialty is a routing hint, not a jurisdiction; handoffs between agents always carry the goal, constraints, evidence, and open items in full.
- Team forging — forges an entire collaborating team in one pass: responsibilities get carved up before headcount is decided, delivering a four-layer structure (1 orchestrator + N specialists + a shared foundation + an owner), five communication channels, and a five-loop growth cycle; the v9.0 team foundation includes peer-to-peer borrowing (members can pull each other in directly, without routing everything through the orchestrator) and a team-wide specialty quick-reference (fixing "forgetting who on the team can actually do this").
- Tiered output — automatically selects Lite / Standard / Fortress based on risk signals (irreversibility / blast radius / tool permissions / domain sensitivity), so a simple assistant never gets over-armored and a high-risk agent never gets under-built.
- Closed-loop modules — a judgment/scoring/recommendation-type agent ships with a hard result-backfill gate: it can't take on a new judgment call until its old ones are settled, settled by observing reality, getting more accurate the more it's used.
- Honesty modules — tools are split into "verified / planned" columns, so an agent can never claim to have a hand it doesn't actually have; v9.0 adds "the delivery index is spot-checkable" (anything an agent claims to have written to disk must genuinely be there).
- Injection hardening — instructions found inside foreign content are always treated as data; v9.0 adds a defense against fake stop-work instructions (a "task cancelled / stop working" message surfacing inside a tool channel is ignored as data — a real phenomenon verified in high-concurrency scenarios) and a ground-truth-at-wrap-up discipline (the more a signal looks like "everything's done," the more it needs independent verification).
- Entry confirmation ⭐ new in v9.0 — when building an agent, the name must always come as candidates for you to pick from (a name the architect picked on its own is one you won't recognize), and the language of the folder it lives in must be confirmed with you first (you launch it by opening the folder, so the name has to be instantly recognizable to you); delivery must always spell out exactly which folder to open and how to launch it.
- Auditable — key actions are traceable; externally, it only ever claims "layered, hardened defense / best-effort" — never absolute safety.
Nuwa's job is making employees; the team it builds can optionally install these independent capability blocks as needed (each its own repo, installed separately, no dependencies between them):
| skill | one-liner |
|---|---|
| dont-reinvent | Teaches your agent to find the wheel before building one — a fixed five steps: check the team's own shelf → search for an existing wheel → install and register it → build it yourself → sediment it back to the shelf |
| handoff-protocol | Multi-agent handoff discipline: the four-part dispatch packet / return format / team-log logging |
| knock-knock | Teaches an agent to "knock": phone-notification access, plus the discipline of when to ping and when to stay quiet |
| sharpen-first | Sharpen the requirement first: when a user can't clearly say what they want, the agent sharpens the fuzzy requirement into a consensus sheet before starting work |
| token-saver | Save cost by tiering a subagent's model: tier by task nature — saves roughly 70% of tokens on execution-type work, per measured results |
| track-record | A judgment-calibration ledger: log a checkable judgment as a bet → settle it against reality → distill the bias into a rule |
| user-md | A user profile that grows: a USER.md you own, that moves when your folder moves |
For non-Claude-Code tools (Cursor / Codex / OpenCode / any LLM): every SKILL.md is a complete, portable markdown guide — feed it to your tool as a rules document.
Want to build a complete digital employee / team? Read START_HERE.md (Chinese edition: START_HERE.zh-CN.md).
Want "one command, a whole running team"? On top of the individual pieces there's also the integrated pack, agent-modpack — Nuwa itself (the employee-making mother-forge) + template skeleton + team rules + memory structure, assembled and landed in a single pass: taken apart it's the individual skills (Nuwa included); put together it's a ready-to-run finished product, with a built-in preview→apply→verify→revert install transaction plus existing-data import (the importer) and version-upgrade (the upgrader) tools.
v10 "Assembly Compiler" is a full rewrite-style generational upgrade (every v9.x capability is retained), with four headline changes:
- The kernel goes markdown + its first rename —
nuwa-9.0.xml→nuwa-v10.md: the kernel is now markdown plus compact attribute markup (programmatic rendering + zero-loss diff auditing), more readable for both Chinese-speaking users and AI alike; upgrading goes through the new "v10 rename + format migration" scenario indocs/UPGRADE.md. - An assembly compiler — the compiled artifact is upgraded to a machine-readable
assembly-request(its schema ships with the repo), leaving a clean handoff interface for the integration pack's engineering side. - A bare-environment fallback — even on an empty machine with zero engineering infrastructure, Nuwa can still land the first employee on its own (three landing tiers + six minimum-write boundaries + a three-piece revertible receipt), and its claims never exceed the evidence available (a claim ladder).
- The full template set now bilingual — the English edition is pure English, the Chinese edition is pure Chinese (
.zh-CNsuffix / Chinese filenames), with every bit of jargon replaced by plain language.
Full list in CHANGELOG.md.
v9.0 "Isomorphic & True-Name" is a full rewrite-style generational upgrade (every v8.0 capability is retained), with four headline changes:
- Layered & isomorphic + an update protocol — the kernel splits into a generic layer and a deployment layer;
docs/UPGRADE.mdlays out a five-step update path (back up → replace → rebind → verify → incrementally back-fill existing agents), with every known pitfall drawn from the maintainer's own real updates. - The True-Name protocol — a hard compile-time check for "reference implies existence," ending persona drift caused by phantom references.
- Entry confirmation — an agent's name must always be decided by you, and the folder's language must always be confirmed with you first.
- Ground-truth-at-wrap-up — systematic defense against a "misattribution" phenomenon verified in high-concurrency scenarios (forged completion receipts / stop-work instructions).
Also included: the person who makes a change backfills it themselves (a change an agent makes on its own must be written back into that agent's own memory baseline), an effect statement is now mandatory at delivery, the delivery index is spot-checkable, and a batch of other field-driven hardening. Full list in CHANGELOG.md.
PolyForm Noncommercial 1.0.0 (Noncommercial) — Copyright (c) 2026 Lucio Liu.
Free for personal, research, educational, and other noncommercial use; commercial use requires a separate license. See LICENSE for full terms.
Both language editions are maintained in sync. If they ever diverge, the Chinese edition is authoritative — please open an issue if you spot one.