PaperlayerView exact revision on arXiv

Source-linked AI summary

Autonomous Agents Coordinating Distributed Discovery Through Emergent Artifact Exchange

Fiona Y. Wang, Lee Marom, Subhadeep Pal, Rachel K. Luu, Wei Lu, Jaime A. Berkovich, Markus J. Buehler

arXiv:2603.14312v1cs.AIcond-mat.dis-nncs.LGcs.MAq-bio.BM

TL;DR

Current AI systems mainly respond to prompts rather than independently conducting iterative, distributed scientific investigations. ScienceClaw + Infinite addresses this gap with autonomous agents, interoperable tool chaining, provenance-preserving artifacts, and emergent coordination across four investigations, demonstrating traceable multi-agent convergence and cross-domain discovery workflows.

  • Problem

    AI systems remain largely interactive and lack evidence of independently conducting iterative investigations that combine tools, hypothesis testing, and converging evidence across domains.

  • Method

    ScienceClaw + Infinite enables autonomous agents to select and chain interoperable scientific tools, exchange needs and artifacts, and preserve computational provenance through emergent coordination.

  • Results

    Across four autonomous investigations, the framework supported heterogeneous tool chaining, convergence among independent analyses, cross-domain knowledge transfer, and traceable reasoning from computation to findings.

  • Takeaways & Limitations

    The framework demonstrates a model of distributed scientific discovery in which autonomous agents accumulate, inspect, and extend reproducible findings across research cycles.

  • Takeaways & Limitations

    The urban-morphology analogy is only a constrained formal analogy based on coarse topological similarity, not mathematical isomorphism, and depends heavily on a hub mapping.

Abstract

from arXiv · show

We present ScienceClaw + Infinite, a framework for autonomous scientific investigation in which independent agents conduct research without central coordination, and any contributor can deploy new agents into a shared ecosystem. The system is built around three components: an extensible registry of over 300 interoperable scientific skills, an artifact layer that preserves full computational lineage as a directed acyclic graph (DAG), and a structured platform for agent-based scientific discourse with provenance-aware governance. Agents select and chain tools based on their scientific profiles, produce immutable artifacts with typed metadata and parent lineage, and broadcast unsatisfied information needs to a shared global index. The ArtifactReactor enables plannerless coordination: peer agents discover and fulfill open needs through pressure-based scoring, while schema-overlap matching triggers multi-parent synthesis across independent analyses. An autonomous mutation layer actively prunes the expanding artifact DAG to resolve conflicting or redundant workflows, while persistent memory allows agents to continuously build upon complex epistemic states across multiple cycles. Infinite converts these outputs into auditable scientific records through structured posts, provenance views, and machine-readable discourse relations, with community feedback steering subsequent investigation cycles. Across four autonomous investigations, peptide design for the somatostatin receptor SSTR2, lightweight impact-resistant ceramic screening, cross-domain resonance bridging biology, materials, and music, and formal analogy construction between urban morphology and grain-boundary evolution, the framework demonstrates heterogeneous tool chaining, emergent convergence among independently operating agents, and traceable reasoning from raw computation to published finding.

1 Introduction

The introduction argues that scientific AI remains largely interactive despite discovery’s iterative, evidence-convergent nature. It introduces SCIENCECLAW + INFINITE as a framework for distributed autonomous investigation, illustrating a shift toward reproducible, networked agent activity.

  • AI commonly assists scientific research through literature summarization, hypothesis generation, coding, protein prediction, materials screening, and molecular generation.
  • The prevailing paradigm remains interactive, with AI responding to human prompts rather than initiating and conducting investigations independently.
  • Scientific discovery requires iterative exploration, tool use, hypothesis testing, and comparison across evidence, with progress emerging from convergent or structurally analogous reasoning.
  • SCIENCECLAW + INFINITE supports distributed autonomous exploration through interoperable scientific tools and agent-based discourse.SCIENCECLAW provides the computational layer for selecting and chaining tools across biology, chemistry, materials science, and computational analysis.
  • INFINITE lets agents publish findings, artifacts, and open questions for human and agent evaluation, enabling follow-up analyses through feedback.
  • 4 autonomous investigations span multiple scientific domains, including SSTR2 peptide design and lightweight impact-resistant ceramic screening.The SSTR2 investigation demonstrates convergence among independent agents using structural analysis, evolutionary evidence, and protein language models.
  • The studies illustrate a shift toward systems that conduct investigations, generate structured reproducible evidence, and participate in distributed autonomous research networks.

2 Algorithm and System Design

SCIENCECLAW + INFINITE coordinates autonomous scientific investigation through profile-driven skill chaining, immutable artifact lineage, and decentralized need matching. The system turns these computations into provenance-aware publications while feedback and operational constraints regulate subsequent autonomous cycles.

  • Artifact Lineage: Each computation becomes an immutable, addressable artifact with typed metadata, content hashing, and parent lineage, forming a DAG that preserves complete traceability.Published numbers can be traced through intermediate computations to the raw tool invocation that produced them.
  • ArtifactReactor Coordination: The ArtifactReactor enables plannerless collaboration by broadcasting unsatisfied needs, ranking them through deterministic pressure scoring, and matching peer outputs for multi-parent synthesis.Pressure combines novelty, centrality, DAG depth, and age; schema-overlap matching provides a complementary coordination signal.
  • Publication and Feedback: Structured INFINITE posts expose artifacts as evidence surfaces and can package sufficiently provenanced quantitative investigations into self-contained reports with publication-ready figures.Community votes and actions generate new need signals, while a heartbeat daemon repeats the autonomous cycle every couple hours and supports noninterruptive human redirects or chat.
  • Agent and Skill Architecture: Agents use declarative scientific profiles to select heterogeneous, chainable skills without hardcoded routing, producing systematically different approaches to the same question.Profiles encode research interests, preferred tool domains, and curiosity and communication styles; skills return typed JSON payloads for sequential composition.
  • Governance and Constraints: Operational constraints limit autonomous behavior through capability verification and uniform rate limits, including one action per 30 minutes, one action per 20 seconds, and 50 actions per day.Registration requires proof-of-capability challenges before agents can post in relevant communities.

3 Case Studies: Emergent Discovery Across Domains

Across four case studies, autonomous agents coordinated heterogeneous scientific workflows through artifact exchange, producing traceable synthesis and domain-specific findings. The studies identified an SSTR2 peptide-binding motif, lightweight ceramic candidates, and distinct patterns of artifact generation, synthesis, and dependency depth.

  • Cross-study metrics: Protein Binder generated 177 artifacts from 23 tools, while Materials Discovery generated 73 artifacts from 10 tools.These correspond to 7.7 artifacts/tool and 7.3 artifacts/tool, respectively.
  • Cross-study metrics: Design-driven studies produced 57, 22, and 19 synthesis artifacts for Protein Binder, Materials, and Resonance, while Urban-Material Analogy produced 25.Urban-Material achieved comparable synthesis density through graphs, models, and reports rather than candidate ranking.
  • Cross-study assessment: Across investigations, autonomous execution remained sustainable with minimal human redirection across 8-13 agents per study.The studies included 5 heartbeat cycles in Resonance and 23 tools in Protein Binder and Urban-Material.
  • SSTR2 peptide design: The SSTR2 investigation identified the central K-T-C motif as a receptor-binding anchor, with surrounding residues forming a flexible mutational design space.The K-T-C triad contacts Tyr50, Phe294, Asp295, and Asp122; the optimized MGLKNFFLKTFTSC candidate had a mass of approximately 1639 Da versus octreotide ∼1019 Da and lanreotide ∼1096 Da.
  • Lightweight ceramics: Screening 212 light-element ceramic phases found 14 satisfying ρ < 5 g/cm3 and K > 200 GPa, including 7 thermodynamically stable candidates.B4C had approximately 2.54 g/cm3 density and 238 GPa bulk modulus, while B6O had 2.62 g/cm3 and 229 GPa; both lay above the dataset’s density-stiffness trend.

4 Conclusions

SCIENCECLAW + INFINITE provides infrastructure for autonomous decentralized scientific investigation by combining extensible skills, persistent artifact lineage, and structured scientific discourse. Its case studies show traceable multi-agent workflows, while persistent artifacts and community feedback support cumulative reinterpretation and extension.

  • Framework contribution: SCIENCECLAW + INFINITE combines an extensible skill registry, an artifact layer preserving computational lineage, and structured agent-based scientific discourse.These components allow investigations to persist across agents and cycles, leaving findings available for reinterpretation and extension.
  • Framework contribution: Agents can select and chain tools without hardcoded routing, while explicit artifact lineage keeps published findings traceable to their generating computations.Need signals and schema overlap help later agents identify information that would advance an investigation.
  • Scientific record: INFINITE converts computational outputs into inspectable scientific records with structured fields, visible provenance, and machine-readable discourse relations.Community actions and redirects feed back into later investigation cycles.
  • Case studies: The case studies demonstrate convergence across distinct analytical approaches in peptide design and progressive narrowing from broad candidate spaces to experimentally meaningful shortlists in materials research.The peptide workflow combined structural reasoning, evolutionary evidence, and protein language model analysis within a traceable workflow.
  • Cumulative participation: The framework supports cumulative scientific participation by allowing new skills, methods, and domains to enter without redesigning the reasoning layer.Persistent artifact chains remain available beyond single runs, while broader participation expands investigative pathways and community feedback can redirect work.

5 Materials and Methods … Memory and Persistence Layer

The methods implement configurable autonomous agents that analyze topics, select tools, generate and critique hypotheses, and synthesize results. Persistent local memory preserves observations, investigations, and semantic relationships across heartbeat cycles, enabling agents to resume and extend research.

  • 5 Materials and Methods: The system combines the ScienceClaw agent framework, Infinite platform, and computational tools for independent investigations and shared findings.These components comprise the technical implementation of the autonomous scientific agent system.
  • Language Models: Language models analyze topics, select skills, generate hypotheses, synthesize multi-tool results, and self-critique conclusions.Self-critique improves specificity and reduces overgeneralizations; the primary deployment uses Anthropic’s Claude Opus 4.6/4.5.
  • Language Models: The active language-model backend is configured in llm_config.json and can be changed through backend-specific environment variables.Alternative selections use ANTHROPIC_MODEL, OPENAI_MODEL, or HF_MODEL.
  • ScienceClaw Agent System: Each agent uses agent_profile.json to store identity, research interests, and preferred tools selected from the 200+ available skills.setup.py supports interactive or quick setup and collects metadata including expertise, organisms, and tools.
  • ScienceClaw Agent System: Expertise presets cover biology, chemistry, materials science, and mixed profiles, defining initial interests, targets, compounds, and preferred tools.For example, biology emphasizes protein structure and molecular biology, while chemistry emphasizes drug discovery and ADMET prediction.
  • ScienceClaw Agent System: During initialization, setup.py creates the agent profile, SOUL.md personality specification, and LLM configuration, then registers the agent with Infinite when credentials are supplied.Registered agents receive an API key for authenticated posting.
  • Memory and Persistence Layer: The local memory layer uses three complementary stores that persist independently across heartbeat cycles.The stores support knowledge accumulation across multiple investigation cycles.
  • Memory and Persistence Layer: AgentJournal records timestamped observations, hypotheses, experiments, and conclusions in an append-only JSONL log, while InvestigationTracker resumes multi-step work across cycles.The tracker maintains topics, hypotheses, experiments, and results, helping agents avoid duplicated work.

Autonomous Investigation Loop (6-Hour Cycles) · Deep Investigation System

The system runs autonomous investigation cycles every six hours, using community observation and hypothesis generation to identify and pursue research gaps. Its deep-investigation entry point coordinates LLM-guided skill selection, multi-step tool execution, and synthesis rather than relying on hardcoded chains.

  • Autonomous Investigation Loop (6-Hour Cycles): Every six hours, the heartbeat daemon triggers an autonomous investigation cycle and records agent state and execution logs locally.The default interval is 21600 seconds; it loads agent_profile.json and tracks heartbeat_state.json and heartbeat_daemon.log.
  • Autonomous Investigation Loop (6-Hour Cycles): The loop controller begins by reading recent Infinite community posts to identify shallow research, gaps, and unresolved questions.This community-observation step connects to subscribed communities on the Infinite platform.
  • Autonomous Investigation Loop (6-Hour Cycles): The reasoning engine generates candidate hypotheses from identified gaps through rule-based pattern matching and LLM-powered synthesis.Hypothesis generation follows community observation within the five-step sequential investigation cycle.
  • Deep Investigation System: run_deep_investigation(agent_name: str, topic: str, community: str, agent_profile: dict) coordinates skill selection, multi-step tool execution, and finding synthesis.This function is the entry point for the deep investigation system.
  • Deep Investigation System: The topic analyzer uses an LLM to determine suitable tools and investigation approaches, after which the skill selector chooses up to five relevant skills from 200+ available tools.Available skill families include literature search, protein characterization, and compound prediction.
  • Deep Investigation System: The system must use run_deep_investigation() because directly calling DeepInvestigator methods bypasses intelligent selection and produces shallow, generic outputs.The workflow therefore depends on LLM-powered analyzer and selector components rather than hardcoded tool chains.

Skills and Tools Registry · Infinite Platform

The Skills and Tools Registry standardizes discovery and execution across 200+ computational tools, while Infinite provides a structured platform for agent accounts, scientific findings, threaded discourse, provenance links, notifications, and verified authentication.

  • Skills and Tools Registry: 200+ computational tools span literature search, bioinformatics, chemistry, materials science, and machine learning, using standardized Python-script interfaces with JSON outputs for chainability.Tools are stored under skills/{toolname}/scripts/ and accept command-line arguments through argparse.
  • Skills and Tools Registry: The skill registry records each tool’s name, description, inputs, output schema, and category, enabling discovery and matching to investigation goals.Tool families include literature, proteins, compounds, genomics, and machine learning.
  • Skills and Tools Registry: The skill executor invokes named scripts with parameter dictionaries passed as command-line flags, captures JSON output, and returns parsed results.The described TDC example uses a molecular SMILES string and model selection to produce ADMET predictions.
  • Infinite Platform: Infinite uses a Next.js 14 application with PostgreSQL and Drizzle ORM, modeling agents, communities, posts, comments, votes, post links, and notifications.These entities form the platform’s core database schema.
  • Infinite Platform: The agents table stores identity, biography, authentication, verification, karma, reputation, spam, moderation, activity counts, and timestamps for AI agent accounts.It also maintains database indices for agent records.
  • Infinite Platform: The posts table stores scientific findings alongside hypotheses, methods, findings, data sources, open questions, engagement counts, moderation status, and spam-detection flags.Data sources are represented as a JSONL array of PMIDs or accession numbers.
  • Infinite Platform: Threaded comments support nesting and optional scientific structure, while post links encode cite, contradict, extend, and replicate relationships; notifications track agent interactions.Comments include parent references and depth tracking, and notifications cover mentions, votes, replies, and citations.
  • Infinite Platform: Agent authentication requires capability proof and verification before issuing an lammac_-prefixed API key, which authenticated requests submit for hashed comparison.Verification uses signature verification and capability-specific checks.

Multi-Agent Coordination and Collaborative Sessions · Artifact System for Computational Provenance

The framework coordinates multi-agent investigations through shared sessions, atomic task execution, artifact logging, and automated synthesis. Its artifact system records computational provenance in structured, addressable JSON objects and enforces domain-aware sharing of collaborative findings.

  • Multi-Agent Coordination and Collaborative Sessions: Shared sessions coordinate multiple agents on complex investigations, with the SessionManager storing collaborative session data as JSON files.Sessions are managed in the agent’s sessions directory.
  • Multi-Agent Coordination and Collaborative Sessions: Each session records participating agents, shared tasks, collected results, synthesis findings, and creation and completion timestamps.Tasks include identifiers, descriptions, tool requirements, and status.
  • Multi-Agent Coordination and Collaborative Sessions: Agents join sessions when preferred tools match requirements, claim tasks atomically, execute specified tools, log artifacts, append results, and mark tasks complete.When enabled, the session manager triggers LLM synthesis after task completion.
  • Multi-Agent Coordination and Collaborative Sessions: Given only a research topic string, the AutonomousOrchestrator uses an LLM to identify needed expertise and tools and generates 2-5 agent specifications.Specifications include names, expertise profiles, preferred tools, and personality traits.
  • Multi-Agent Coordination and Collaborative Sessions: The orchestrator registers temporary agent profiles with Infinite, creates tasks and a collaborative session, triggers autonomous work, synthesizes findings, and posts a comprehensive community result.Tasks are derived from the topic analysis.
  • Artifact System for Computational Provenance: Every skill invocation produces an addressable artifact that records a skill’s output for a specific agent during a specific investigation, providing computational provenance.Artifacts support domain-gating in collaborative sessions.
  • Artifact System for Computational Provenance: Artifacts are JSON objects containing UUIDs, types, producer and skill metadata, schema versions, unchanged payloads, investigation IDs, UTC timestamps, and SHA256 content hashes.The artifact_id is generated with uuid4(), and timestamps use ISO 8601 format.
  • Artifact System for Computational Provenance: Domain validation uses the SKILL_DOMAIN_MAP to restrict referenced artifact types to an agent’s allowed domain, while synthesis and peer_validation artifacts remain universally permitted.Agents without preferred_tools are unrestricted.

ArtifactReactor: Reactive Coordination Mechanism · Need Signals: Explicit Demand Broadcasting · Schema-Overlap Matching: Implicit Supply Discovery

ArtifactReactor coordinates agents reactively by detecting unmet needs and compatibility signals, then triggering autonomous skill execution without explicit orchestration. Explicit NeedsSignals broadcast structured demands, while schema-overlap matching discovers compatible peer artifacts through normalized parameter and payload keys.

  • ArtifactReactor: Reactive Coordination Mechanism: ArtifactReactor detects unmet demands and compatibility signals in the artifact store, automatically triggering skill execution to fulfill them.Agents scan shared artifacts and respond autonomously rather than relying on explicit orchestration.
  • ArtifactReactor: Reactive Coordination Mechanism: Agents independently scan the artifact store for unmet demands and compatible artifacts, enabling reactive multi-agent coordination.The mechanism replaces centrally specified orchestration with autonomous responses to shared repository signals.
  • Need Signals: Explicit Demand Broadcasting: Each synthesis artifact may attach a NeedsSignal containing up to two NeedItem records that specify the required artifact type and targeted entity or search term.NeedItem search terms must contain at least five characters.
  • Need Signals: Explicit Demand Broadcasting: Each NeedItem includes a rationale, optional parallel exploration of up to six competing variants, and optional preferred skills and parameters.Rationales must contain at least 20 characters, and parallel exploration is explicitly represented in the demand record.
  • Schema-Overlap Matching: Implicit Supply Discovery: The reactor matches unclaimed peer artifacts when skill.input_params ∩ artifact.payload_keys ≠ ∅.Compatibility is based on a non-empty intersection between skill input parameter names and artifact payload keys.
  • Schema-Overlap Matching: Implicit Supply Discovery: Parameter names are parsed from --help, normalized to snake_case, and cached before matching against normalized top-level payload keys.Skills exposing a --describe-schema flag also receive secondary schema processing.

Pressure-Based Scoring of Open Needs … Mutation Layer: Topology Self-Modification

The ArtifactReactor prioritizes open needs through deterministic pressure scoring, synthesizes compatible artifacts with provenance-aware multi-parent lineage, and prevents feedback loops through consumption tracking and identity checks. The ArtifactMutator modifies DAG topology by forking stagnant artifacts, merging redundant siblings, and grafting or merging conflicting siblings.

  • Pressure-Based Scoring of Open Needs: Open needs are processed before schema-overlap reactions and ranked deterministically by a pressure score.The reactor’s react() method executes need-driven reactions first.
  • Pressure-Based Scoring of Open Needs: score = 2.0 · novelty + 1.0 · centrality + 0.5 · depth + 0.2 · ageThe score combines novelty, centrality, DAG depth, and age.
  • Pressure-Based Scoring of Open Needs: Novelty prioritizes unfulfilled needs, while centrality prioritizes convergent demand from agents with overlapping query tokens.A need fulfilled zero times scores 1.0, after two fulfillments 0.33, and five agents requesting related protein data yield centrality 5.0.
  • Multi-Parent Synthesis and Cross-Agent Credit: Compatible artifacts are merged through a shared skill into synthesis artifacts carrying multiple parent IDs and all contributing agents’ DAG lineage.Merging proceeds oldest-to-newest; when keys overlap, the newest value overwrites, subject to domain gating.
  • Loop Prevention and Investigation Isolation: Consumed artifact IDs prevent re-reaction, producer–reactor identity checks block self-cycles, and investigation_id_filter prevents cross-run pollution.The filter scopes scans to one investigation when agent identities are reused across shared demonstrations.
  • Mutation Layer: Topology Self-Modification: The ArtifactMutator forks stagnant artifacts into children with disjoint key subsets, merges redundant siblings, and resolves conflicts through grafting or merging.Stagnation is defined as more than K cycles without children; redundancy is sibling key overlap above P%, while conflict involves differing values for the same key.

ArtifactReactor Implementation · Post Generation and Platform Integration

ArtifactReactor coordinates agent reactions through ordered need fulfillment, multi-parent synthesis, and single-parent transformation, while Infinite converts investigation outputs into authenticated, structured posts and governed platform interactions. The integration preserves scientific provenance through methods, findings, sources, discourse links, rate limits, spam controls, and karma-based permissions.

  • ArtifactReactor Implementation: ArtifactReactor.react() executes up to a specified limit in priority order: need-driven reactions, multi-parent synthesis, then single-parent transforms, with optional mutation detection.scan_available() identifies compatible unclaimed peer artifacts, while scan_needs() searches the global index for broadcast information needs.
  • Post Generation and Platform Integration: Investigation results are formatted into structured posts containing titles, narratives, hypotheses, methods, findings, data sources, and open questions.Posts are generated by run_deep_investigation(), which returns the structured findings used to construct the post object.
  • Post Generation and Platform Integration: Posts must integrate multiple computational tools, demonstrate novel mechanistic insights, report quantitative findings with confidence metrics or error bounds, and attribute work to an authenticated agent.These requirements distinguish genuine scientific investigation from simple summaries.
  • Post Generation and Platform Integration: The Infinite client validates authentication, rate limits, and karma thresholds before submitting posts through POST /api/posts and returning the post ID.The create_post() method provides the platform’s posting interface for structured investigation outputs.
  • Post Generation and Platform Integration: Agents can create threaded comments with @mentions, link posts using cite, contradict, extend, or replicate relationships, and retrieve notifications for mentions, replies, upvotes, and citations.These interfaces support nested discussion, semantic discourse relations, and agent awareness of platform activity.
  • Post Generation and Platform Integration: 1 post per 30 minutes, 50 comments per day, and 200 daily votes are permitted, with trusted agents receiving 400 daily votes.Spam violations can lead to shadowban or banned status, reducing visibility and posting privileges.
  • Post Generation and Platform Integration: Karma thresholds define platform privileges from banned and shadowbanned agents to probation, active, and trusted contributors with increasing participation and governance authority.Banned agents have karma <= -100, while trusted agents require karma >= 200 and reputation >= 1000.

Scientific Reasoning and Hypothesis Generation · Implementation Notes and Verification

The scientific reasoning engine orchestrates autonomous investigations through five components that detect knowledge gaps, generate hypotheses, design and execute experiments, and analyze results. Implementation separates computational investigation from platform interaction, while JSON outputs support chainability and integration.

  • Scientific Reasoning and Hypothesis Generation: The scientific reasoning engine orchestrates the autonomous investigation workflow through five components.These components span gap detection, hypothesis generation, experiment design, execution, and result analysis.
  • Scientific Reasoning and Hypothesis Generation: GapDetector ranks knowledge gaps by frequency, recency, and alignment with the agent’s research interests.It searches agent journals and community discussions for incomplete understanding and explicitly mentioned questions.
  • Scientific Reasoning and Hypothesis Generation: HypothesisGenerator converts gaps into testable research questions with variables, predicted relationships, and mechanistic explanations.It combines pattern matching across prior investigations with LLM synthesis rather than merely restating gaps.
  • Scientific Reasoning and Hypothesis Generation: ExperimentDesigner selects registry tools, constructs schema-based parameters, and orders executions to maximize information flow.For example, literature results can identify entities for targeted database queries.
  • Scientific Reasoning and Hypothesis Generation: ExperimentExecutor invokes each selected tool sequentially, passes parameters, collects results, logs experiment steps, and stores artifacts.Each execution is recorded in the agent’s journal as an experiment entry.
  • Scientific Reasoning and Hypothesis Generation: ResultAnalyzer extracts quantitative findings and confidence metrics, identifies unexpected patterns, synthesizes convergent evidence, and updates the knowledge graph.It formats conclusions as evidence-based statements with supporting data references.
  • Implementation Notes and Verification: JSON output from every tool execution enables chainability and integration between computational investigations and platform interaction.ScienceClaw and Infinite remain separate, allowing agents to investigate independently of platform connectivity and post results when appropriate.

Supplementary Information

The supplementary information identifies the paper and lists its authors and their MIT affiliations across multiple engineering and computational departments.

  • The paper is titled “Autonomous Agents Coordinating Distributed Discovery Through Emergent.”
  • The listed authors include Fiona Y. Wang, Lee Marom, Subhadeep Pal, Rachel K. Luu, Wei Lu, Jaime A. Berkovich, and Markus J. Buehler.
  • The authors are affiliated with MIT’s LAM and departments spanning biological, mechanical, civil and environmental, and materials science and engineering, plus computational science and engineering.

Supplementary: Agent Interaction Networks

The supplementary figures map agent interaction networks across protein design, materials science, resonance, and formal analogy investigations. Each network represents direct discussion, cross-agent artifact dependencies, and comment-level participation, with domain-specific artifact types labeling exchanges.

  • Protein Design: Protein design agents are connected by mention/reply edges and artifact-passed dependencies involving pubmed_results, sequence_alignment, admet_prediction, protein_data, and synthesis.Agents and comments are shown as large colored nodes and small satellite nodes, respectively.
  • Materials Science: Materials science agents exchange comments and artifacts through mention/reply and artifact-passed edges labeled pubmed_results, materials_data, ml_prediction, and synthesis.The network also depicts individual comments as satellite nodes.
  • Resonance Landscape: The resonance landscape network shows direct discussion and artifact-passed dependencies involving synthesis, computational_analysis, rdkit_properties, and accumulated_results.Agent nodes are labeled with comment counts and linked to individual comment satellites.
  • Formal Analogy: The formal analogy network represents direct discussion and cross-agent artifact exchange using materials_data, figure, ml_prediction, pubmed_results, and network_data.Artifact-passed edges include dashed arrows and triangular synthesis markers.
Loading 2603.14312v1…