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.

Policy, not vibes

Consequences ask; routine flows

Publishing, merging, dependencies, spend — each is a per-project policy that defaults to asking you. Your branch model decides what is routine, and the agent that pushes is never the one that wrote the code.

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 the port you pick
  • Keeps your project pure: reads it, never edits it
expoapp Populated head-start

React Native / Expo, both platforms

One pack for iOS and Android: the same issue-driven pipeline, plus simulator and emulator acceptance lanes and local-run and ship skills.

  • iOS + Android in one pack, one pipeline
  • Acceptance runs against the simulator/emulator
  • Grows project-specific capabilities as you work

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.

One command from inside your project. It installs the framework beside your app, asks domain → port → optional workers, and writes nothing into your code.

xenomoon · install webapp
# from inside your project — one command
$ cd myapp
$ npx github:arthur0n/xenomoon
→ installs beside it (../myapp-xm) · asks domain · port · workers
# then the linked CLI drives it
$ xenomoon up
http://localhost:<your port>
$ xenomoon doctor # health · xenomoon update # pull latest

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. Consequential actions ask by default; a per-project policy decides what runs autonomously — and the pusher is never the author.