White-label · domain-neutral · MIT

Early experiment · nothing here is stable yet

A deliberate pipeline for whatever you build.

Xenomoon is a Claude Code framework that drives a human-gated pipeline instead of a chat box. It is domain-neutral: install it into a project, lock it to a domain, and it runs that pipeline for whatever you are building. One install per project. Each one learns its own.

Runtime
Claude Code SDK
Model
Domain-neutral
Standard
agentskills.io
License
MIT
The Xenomoon sigil: a ringed cratered moon set in an engraved bronze orbital diagram
Fig. I · Ringed satellite · bronze register

The method

A pipeline, not a chat box.

Five gated phases, waxing from a rough idea to something you have actually looked at. The model never guesses its way past a phase.

Most setups hand you a frontier model and a blank prompt. Xenomoon moves the design decision before inference: it reads a project-owned lock, runs a structured pipeline, and refuses to silently fill a vague brief. Each phase is a gate. The last one is you.

PHASE 01
Triage
Sort the intent, name the real problem.
PHASE 02
Solution
Lock an approach before any code is written.
PHASE 03
Implement
Build exactly the locked solution, nothing more.
PHASE 04
Verify
Deterministic checks before anything counts as done.
PHASE 05
You
Full moon. One human look, and the call is yours.
Read literally

The lock is the brief

A committed, project-owned lock binds each project to its domain. No runtime "what are you building?", no guessing.

Never scaffolds over you

Deterministic install

It installs into new or existing projects in place, never writing over your code. A conflicting override is refused, not applied.

Human-gated

You are the last phase

Every phase is a gate you can hold. The framework keeps the loop fast and honest; it does not take your judgement.

Learns the project

No one-size brain

Each install accumulates capabilities for its specific project. The researcher loop folds friction back into the packages.

Domain packs

From empty to head-start.

The spine is domain-neutral. It reads a pack for the project marker, file inventory, capabilities, and orchestrator, instead of hardcoding one engine.

webapp Populated head-start

React + Node, wired on arrival

A working head-start: an issue-driven triage → solution → implement pipeline whose orchestrator learns your project. Installs in place and writes nothing into your app.

  • Binds the path in a gitignored .xenomoon.json
  • Serves the browser UI on localhost:3117
  • Keeps your project pure: reads it, never edits it
app Empty learning pack

A blank slate that still runs

An empty Node pack proves the point: a domain with no pre-baked capabilities installs and runs cleanly, then accumulates its own as you work.

  • Empty packages are valid, not a broken state
  • Grows capabilities specific to one project
  • Promote the keepers when they earn it

Portability & stance

Use, don't compete.

Author a package once; run it where the standard runs. The bet is on composition, not on building a rival runtime.

  • STD

    The open skill standard

    Packages target the open agentskills.io SKILL.md / SOUL.md format, the same one OpenClaw and Hermes already speak, so one authored package can travel.

  • WORK

    Other agents as workers

    The aim is to drive OpenClaw and Hermes as delegated workers, or distribute packages onto them, not to replace the runtime underneath.

  • CORE

    A basic install, every session

    A domain-agnostic core plugin loads into every project session: meta skills, safety hooks, and the researcher learning loop. The active domain pack loads alongside it.

Install

Bind it to a project.

Install the framework into a React + Node web app with the webapp domain. It binds in place and writes nothing into your project. Prefix commands with rtk; a hook enforces it.

xenomoon · install webapp
# install framework deps
$ rtk npm ci
# bind it to your app, lock the domain
$ rtk npm run new -- <ABS_PATH> --domain=webapp
# confirm health, then boot the UI
$ rtk npm run doctor
$ rtk npm start
http://localhost:3117

Lineage

Forked from the forge. Sync flows one way.

Xenomoon is a white-label fork of Xenodot Forge. We fetch its curated, domain-agnostic improvements and never push back. Godot stays the exclusive upstream product we forked from: it is not a domain here, and the engine payload never lands.

The architect

Arthur Nunes

I build agentic systems that stay honest under pressure: pipelines that push back on vague scope, deterministic gates that refuse to call things done, and human approval kept in the loop by construction. Xenomoon is the domain-neutral cut of that idea, made to install anywhere and learn each project it lands in.

  • A1 Domain-neutral framework design. One spine, per-domain packs read from a seam, never branched on a name.
  • A2 Deterministic install. Project-owned locks and in-place binding that never scaffolds over your code.
  • A3 Portable capabilities. Packages on the open agentskills.io standard, built to travel across runtimes.
  • A4 Human-gated orchestration. Multi-agent routing where the approval gate never bends.