DarkMoon research series·A. Architecture & attack paths·Article 8 of 23·All 23 articles
Introduction
DarkMoon runs a campaign as an orchestrator plus specialist sub-agents: one for SQL databases, one for storage, one for messaging and caches, one for GraphQL, and so on. Each sub-agent pushes the findings it produces and may declare, in an enabled_by list, which earlier findings it used.
Two problems appear as soon as findings come from several agents. First, the links that matter most often cross agents: the cache agent finds credentials, the database agent uses them. Second, agents frequently link two findings that are really two symptoms of one weakness. This article reports what DarkMoon measured about both, using the error analysis published in the attack-paths research repository.
The problem
Cross-agent links need shared identifiers. An agent can only cite a finding it knows the id of. In DarkMoon, references are resolved campaign-wide, so citing another agent's finding is allowed. But ids cross agent boundaries in only two ways: the orchestrator writes them into delegation prompts ("Already pushed findings: …"), and sub-agents return them in task results. The push reply also lists recently exploited findings, capped at 200 characters. The server itself cannot add missing relations: a tool call carries no session identity, so the server knows the run but not which sub-agent made a given call.
Common causes look like chains. If Redis accepts unauthenticated commands, an agent may report CONFIG SET accepted, SLAVEOF accepted and EVAL accepted as three findings, then declare that one enabled the next. None did: all three were enabled by the missing authentication. In causal terms the structure is A ← C → B, and the agent reports A → B.
Methodology
- Real campaigns on a multi-protocol lab whose intended chain is unauthenticated Redis → database credentials → PostgreSQL access or superuser → command execution or file read → SSH key → SSH. Campaigns c6 (orchestrator only) and c7 (orchestrator plus three sub-agents), then a final validation run with the same three sub-agents.
- Independent oracles scoring every declared link, with error classes.
- Per-link analysis of every same-cause error on c7.
- Proxy-model simulations of prompt variants on the c7 transcripts and on independent synthetic corpora, run twice per variant.
Real results
Cross-agent links
| Campaign | Observation |
|---|---|
| c5 / c6 | 0 of 25 cited ids were cross-agent; every citation was intra-session |
| c7 | 7 of 9 expected links crossed agents; 4 of them were declared. 14 of 19 declared links were cross-agent, 4 of them true positives |
| c6, c7, final run | the critical spine link "PostgreSQL access → SSH key" was missed every time (on the final run the missed link was "database credentials ← Redis") |
The orchestrator copying ids into delegation prompts was observed spontaneously on c7 (VERIFIED). It is what made cross-agent links possible at all. It also seeds the next problem.
Same-root-cause errors
- On c7, 12 of 13 false links were same-cause facets: 4 Redis facets, 4 version-matched CVEs, 2 SMB facets, 2 state findings. All came from sub-agents; the orchestrator made 0 such errors on c6 and c7 (
VERIFIED). - On the final lab run, about 12 of 19 declared links were same-cause (6 Redis facets, 6 SMB facets), approximate scoring (
OBSERVED).
The per-link analysis identified the mechanisms:
- Loose sub-agent wording ("finding … access") invited citing the finding that gave context rather than the one that gave access.
- Precondition treated as progression: a version-matched CVE, confirmed but not exploited, linked to the unauthenticated service it would need.
- "Revealed" treated as "enabled".
- A state finding cited instead of the access step, for example "app is superuser" cited where the login gave the access.
- Content anchoring: the delegation prompt and the hint name the root weakness of the delegated service, and agents cite it. On c7, 0 citations followed the hint's first position when it was wrong, so this is anchoring on content, not on position.
What was tried, and the outcome
| Lever | Result | Decision |
|---|---|---|
| Wording "the direct step actually used" (+54 characters) | c7 0.316 vs c6 0.556, intervals overlap; transitive errors 3 → 0, but 12 same-cause errors appeared with sub-agents | reverted |
| Variant B: "obtained by exploiting it; not a finding sharing its root cause" | c7 replay 27 % → 78 %; independent hard corpus 91.2 % → 79.4 % (SIMULATED) | not applied |
| Micro-test V1 ("mental qualification") / V2 (typed label DIRECT / SAME_CAUSE / CONTEXT / NONE) | c7 replay strict precision V0 36 %, V1 33 % (lost 2 true links, including a cross-agent one), V2 40 %; same-cause errors 14 / 10 / 11; variance ±20 points (SIMULATED) | keep the current text |
Neither variant reached the −50 % same-cause criterion set for the study, and pass-to-pass variance exceeded the differences. Variant B helped on the data that suggested it and hurt on the independent corpus, which is the classic sign of overfitting a prompt.
A second complication: the proxy model did not reproduce the same-cause errors on synthetic corpora (0 such errors). The failure seems to depend on real delegation prompts and long sessions, which makes it expensive to study.
Limits
- All real figures are single runs on one lab with one model; cross-agent counts are small.
- The oracle was built by the same team; mapping choices move c7 precision by about 10 points.
- Simulations used a different model with a shorter context; their fidelity on c7 was close (28.6 % simulated vs 31.6 % real), but they missed the real failure mode elsewhere.
- No separate inter-agent corroboration mechanism exists, because the server cannot distinguish sub-agents per call.
- An untested direction from the repository: make the root cause a first-class node agents can link to, so "both enabled by C" becomes expressible instead of being forced into "A enabled B".
Figures
Scientific sources
- Pearl. Causality: Models, Reasoning, and Inference. 2009. doi:10.1017/CBO9780511803161
- Spirtes, Glymour, Scheines. Causation, Prediction, and Search. MIT Press, 2000. doi:10.7551/mitpress/1754.001.0001
- Cemri et al. Why Do Multi-Agent LLM Systems Fail? 2025. arXiv:2503.13657
- Zhang et al. Which Agent Causes Task Failures and When? On Automated Failure Attribution of LLM Multi-Agent Systems. 2025. arXiv:2505.00212
- Hong et al. MetaGPT: Meta Programming for A Multi-Agent Collaborative Framework. 2023. arXiv:2308.00352
- Wu et al. AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation. 2023. arXiv:2308.08155
The Who&When study reports a best method at 53.5 % agent-level and 14.2 % step-level attribution accuracy, a useful warning that asking an LLM which step caused which outcome is itself unreliable.
Research, source code & reproducibility
- Main research repository: ASCIT31/darkmoon-attack-paths-research, see docs/agent-native §4 and experiments/RESULTS.md §9
- Source code (open source): ASCIT31/Dark-Moon, declaration validation in
declared_links.py - Benchmarks: ASCIT31/Darkmoon-Benchmarks
- Official documentation: docs.dark-moon.org
- Scientific references: literature review §3.4 and §3.6
- Reproducible experiments: EXP-043 (c6), EXP-050 (c7), EXP-051 (variants B/C), EXP-053 (micro-test), EXP-056 (final run)
Related articles
- Agent-Native Attack Graphs: Why We Let AI Agents Declare Dependencies
- Attack Graphs, Knowledge Graphs and Causal Reasoning: What Is Actually Different?
- Measuring Attack-Path Reliability: Benchmarks, False Positives and Limitations
- Declared vs Proven Attack Paths: A Practical Evidence Model
The common-root-cause problem is open. If you have a multi-agent system that tells "two symptoms of one weakness" apart from "one step enabling the next", a replication on comparable data would be worth more to us than another prompt variant.
See the proof, not just the write-up: the Pro remediation benchmark (fixes retested against the exploit) · how Darkmoon compares to other AI pentest tools.
← All articles