From a target to a retested fix

Fingerprint the target, then plan

You hand Darkmoon a scope. A pentest orchestrator fingerprints the technology signals it finds and builds a plan — which target classes are present, in what order to approach them, and how deep to cascade. Cloud and infrastructure branches only open on a positive artifact, never on a guess.

Dispatch 50 specialists by target class

The orchestrator dispatches specialist sub-agents — web, cloud, Active Directory, Kubernetes, databases, IoT/firmware, CI/CD, IaC and an llm agent for exposed AI/LLM inference endpoints. Dispatch is an inline task() call inside the orchestrator's own turn, so there is no separate control plane to trust.

Every tool passes one allow-list gate

Agents reach 142 security tools through a single executor allow-list that is a hard boundary. A build test fails the release if any installed tool drifts outside the list, so the agents can neither silently gain an unvetted binary nor lose a capability between versions.

Run the campaign, map the surface

Specialists run their playbooks against the rehydrated real target, streaming each tool result, infrastructure node and event as it happens. The result is an attack-surface graph, not a flat list — hosts, paths and the relationships between them.

Chain signals into attack paths

The orchestrator correlates what the specialists return — a leaked credential here, a reachable service there — into candidate attack paths, and decides where it is worth pushing exploitation further.

Qualify every finding, adversarially

Each finding is forced through an adversarial rubric in the agent's own prompt: EXPLOITED (impact executed end to end), CONFIRMED (payload plus raw response and extracted data) or UNCONFIRMED (a lead only). A lead is never dressed up as a proven exploit, and exploited findings are counted separately.

Honesty: this qualification is a prompt-enforced self-review, not machine verification. The status is asserted by the agent and then normalized — Darkmoon does not, at this stage, machine-prove exploitation. The one place an exploit is machine-re-run is stage 10 (Pro).

Structure the finding, keep evidence local

Findings carry severity, CVSS, MITRE ATT&CK, ISO 27001 and full local evidence. Everything that leaves the host — the API, HMAC-signed webhooks, the event stream — carries only safe fields: counts, booleans, ids, MITRE tags and timestamps. Evidence bodies, secrets and raw requests/responses never cross those surfaces.

Locate the root cause and patch it

For findings qualified confirmed or exploited, Pro maps the finding back to the target's own source, reproduces the exploit against a clean build, and writes the smallest correct fix as a deterministic search/replace patch.

The fix only counts if the exploit stops firing

The patched code is rebuilt in an ephemeral sandbox on loopback, then the original exploit and its variants are re-run. The fix passes only if the exploit no longer fires and the repository's own tests still pass. This retest is the single place in the whole product where exploitation is machine-re-verified.

Open a PR for a human — never merge it

A validated fix becomes a pull request on a darkmoon/fix branch across 8 SCM providers, carrying the before/after proof; a fix that could not be fully validated is opened as a clearly marked draft. Push credentials stay sealed and are referenced by an opaque token, so no secret ever enters the model's context. Darkmoon never merges — a person reviews and merges.