ArtifactReactor: Decentralized Artifact Coordination

• ArtifactReactor is a decentralized system component that organizes computational outputs as immutable artifacts within a directed acyclic graph (DAG).
• It employs pressure-based scoring and schema-overlap matching to trigger emergent multi-parent synthesis, enabling autonomous task assignment among independent agents.
• An integrated mutation/pruning layer dynamically manages artifact growth and conflict, ensuring efficient workflow convergence and provenance-aware reasoning.

ArtifactReactor is a core component of the ScienceClaw + Infinite autonomous science framework, designed to coordinate fully decentralized scientific investigation by independent agents. It implements plannerless, emergent task assignment and knowledge synthesis across heterogeneous agent populations without relying on central control. ArtifactReactor organizes all computational outputs as immutable artifacts in a directed acyclic graph (DAG), enabling provenance-aware reasoning, multi-parent lineage assignment, and self-tuned workflow convergence. The reactor’s principal innovations include pressure-based fulfillment of distributed “needs,” schema-overlap–triggered multi-parent synthesis, and an autonomous mutation/pruning layer that dynamically manages workflow growth and conflict—all operating within the artifact layer of the ScienceClaw ecosystem (Wang et al., 15 Mar 2026).

1. Role and Architecture within ScienceClaw + Infinite

Within the ScienceClaw + Infinite six-stage agent workflow, ArtifactReactor occupies the artifact layer, orchestrating step 3: artifactization of computational results and coordination of subsequent information flow. Its primary function is to scan the global index of agent-broadcast needs and peer artifacts, prioritize fulfillment using pressure-based scoring, and trigger artifact synthesis via schema-compatible skill matching.

ArtifactReactor comprises three interacting subcomponents:

• Pressure-Based Scorer: Computes the “pressure” on every open need based on novelty, centrality, DAG depth, and request age. High-pressure needs are prioritized for fulfillment.
• Schema-Overlap Matcher: Identifies pairs or groups of artifacts whose payloads overlap the input parameter schema of available skills, enabling implicit discovery of multi-parent synthesis opportunities.
• Mutation/Pruning Layer (ArtifactMutator): Continuously observes the evolving artifact DAG for stagnation, redundancy, and conflict, applying local graph operations (fork, merge, graft) to maintain workflow health and efficiency.

Output artifacts, including all synthesized knowledge products, are recursively appended with full parent lineage and tracked in both local agent stores and a global index, ensuring complete computational auditability.

2. Formal Definitions: Scoring, Matching, and Mutation

ArtifactReactor operationalizes emergent, plannerless coordination using rigorously defined algorithms:

2.1 Pressure Scoring Function

Each open need $n$, associated with an artifact $a$, is scored as:

$$\text{Pressure}(a,n) = \alpha\,\mathrm{novelty}(n) + \beta\,\mathrm{centrality}(n) + \delta\,\mathrm{depth}(a) + \varepsilon\,\mathrm{age}(n)$$

Default hyperparameters: $$\alpha=2.0,\,\beta=1.0,\,\delta=0.5,\,\varepsilon=0.2$$.

Definitions:

• $$\mathrm{novelty}(n) = 1 / (1 + \mathrm{coverage}(n))$$, where $\mathrm{coverage}(n)$ is the number of prior fulfillments for $n$.
• $\mathrm{centrality}(n)$: number of co-occurring, type-identical needs with overlapping query tokens.
• $\mathrm{depth}(a)$: path length from $a$ to the DAG root.
• $$\mathrm{age}(n) = \log(1 + \mathrm{age\_minutes}(n))$$: prioritizes long-unfulfilled needs.

2.2 Schema-Overlap Multi-Parent Synthesis

The reactor’s React() function is defined as follows:

def React(): # 1) Need-driven reactions for need in scan_needs().sorted_by(Pressure).take(limit): if can_fulfill(need): artifact = run_skill(need.skill, params=need.query) record_artifact(artifact, parents=need.source_artifact) # 2) Multi-parent synthesis peers = scan_available() grouped = group_by_compatible_skill(peers) for (skill, group) in grouped: if group.size >= 2: merged_payload = merge_payloads(group) synth_art = run_skill(skill, merged_payload) record_artifact(synth_art, parents=group.artifact_ids) # 3) Pruning/mutation ArtifactMutator.apply(DAG)

• scan_needs(): returns open needs matching available skills.
• scan_available(): selects peer artifacts with payloads schema-overlapping with at least one skill.
• merge_payloads(group): merges JSON key–value pairs, newer overwrites older.

2.3 ArtifactMutator: Mutation and Pruning

ArtifactMutator executes policies per heartbeat:

• Stagnation: Forks leaf artifacts having no children after $K$ cycles ($K=3$ default), splitting payload keys.
• Redundancy: Merges siblings sharing > $P\%$ of payload keys ($P=0.7$ default).
• Conflict: Identifies siblings with identical keys but differing values, then either grafts one as parent or creates an overview artifact.

Mutation policy thresholds ($K,P$) are themselves stored as “mutation_policy” artifacts and may self-tune stochastically in response to observed rates of redundancy and conflict.

3. Artifact Representations and DAG Operations

Artifacts encode computational outputs with standard fields:

Field	Description
artifact_id	UUID4 identifier
artifact_type	Controlled type (pubmed_results, synthesis, etc.)
producer_agent	Originating agent name
skill_name	Skill/tool invoked
timestamp	ISO 8601 UTC
content_hash	SHA-256 of payload data
parent_artifact_ids	Ordered list of input artifact IDs
needs	Optional open needs list
schema_version	Payload versioning
result_quality	For downstream gating

Artifacts are appended to per-agent store.jsonl logs. The global index exposes only metadata to enable rapid need and payload scanning.

DAG update rules:

• Node Addition: Link new artifact $v$ to parent(s) $p$ via directed edges; guarantee acyclicity.
• Multi-Parent Synthesis: Enable $|\mathrm{parents}| \geq 2$, providing explicit lineage credit.
• Merging Duplicates: Upon redundancy, remove $v_1, v_2$, issue merged artifact with joint payload and parent set.
• Pruning: Remove or fork leaves in accordance with policy. Each operation ensures acyclicity and consumes artifact/need IDs to prevent re-triggering.

4. SSTR2 Peptide Design Case Study

ArtifactReactor’s coordination is illustrated by automated peptide design for the somatostatin receptor SSTR2. In this use case, approximately 10 agents, applying 23 distinct skills, generated 177 artifacts, including 57 synthesis nodes. The prototypical workflow sequence:

1. Literature agent executes pubmed_search("somatostatin receptor 2 peptide"), yielding artifact $A_1$ with attached needs, e.g., {"need_type":"protein_data","query":"7XNA PDB structure"}.
2. ArtifactReactor computes high pressure for $(A_1, \text{protein_data})$ (since coverage = 0), assigning priority. Pressure computation yields $3.5$.
3. Structure agent fulfills the need via alphafold_model(pdb_id="7XNA"), producing artifact $A_2$ with $\text{parent\_artifact\_ids}=[A_1]$.
4. Simultaneously, an ADMET prediction need is satisfied by a chemistry agent (artifact $A_3$), all lineage-tracked.
5. Schema-overlap logic identifies $A_2$ and $A_3$ as compatible for combined processing (both match input schema for sequence_alignment), producing synthesis artifact $A_4$ with multi-parent lineage $[A_2, A_3]$.
6. Across the investigation, 57 such multi-parent artifacts emerge, incorporating data from structural, evolutionary, and chemical domains.

The resulting DAG captures how needs, scans, fulfillment, and synthesis interleave, yielding asynchronous, convergent knowledge flows (Wang et al., 15 Mar 2026).

5. Relation to Prior Systems and Contributions

ArtifactReactor diverges from conventional multi-agent science frameworks, which typically use centralized planning or manual orchestration at critical junctions. Distinctive features include:

• Plannerless Distributed Coordination: Open needs are self-selected for fulfillment by agents according to deterministic pressure ranking, eliminating global task scheduling.
• Emergent Multi-Parent Synthesis: Purely schema-based overlap triggers implicit cross-agent merges, enabling synthesis without explicit negotiation or static pipelines, with full credit to all contributing parents.
• Autonomous Mutation and Pruning: The ArtifactMutator continuously restructures the artifact DAG to avoid stagnation, redundancy, and repetitive branching—maintaining workflow health without human oversight.

Empirical results across four case studies demonstrate scalability to 8–13 agents, 52–177 artifacts per run, and skill catalogs in excess of 300. Convergence is emergent: whenever multiple peer artifacts qualify as inputs for the same skill or need, synthesis occurs, driving the DAG toward integrated hypotheses and discoveries.

Documented limitations include the absence of formal guarantees for global optimum or full convergence—behavior emerges deterministically but is not theoretically bounded. Mutation/pruning parameter misconfiguration can result in excessive tree branching or premature artifact merging. Domain-specific gating restricts cross-domain synthesis absent agent qualification sharing.

Collectively, ArtifactReactor operationalizes a robust, decentralized, pressure-driven coordination approach that promotes scalable, transparent, and provenance-aware knowledge synthesis in autonomous scientific ecosystems without recourse to centralized orchestration (Wang et al., 15 Mar 2026).