Inter-Agent Rigor Module (Inter-ARM)

• Inter-ARM is a supervisory module that enforces strict, formally defined state transitions and validations in multi-agent AI experiments.
• It intercepts inter-agent messages, applies rigorous scheduling based on priorities, and logs every transition for full traceability.
• By ensuring consistency and reproducibility, Inter-ARM significantly improves the reliability of automated scientific experimentation.

The Inter-Agent Rigor Module (Inter-ARM) is a core component of the Curie framework, which is designed to embed methodological rigor, reliability, and interpretability into automated scientific experimentation by AI agents. Inter-ARM enforces strict, formally specified control-flow and scheduling policies for all inter-agent communications, ensuring that every partition of an experiment proceeds through a pre-specified, auditable, and scientifically rigorous workflow. It operates by intercepting inter-agent handoffs, validating each subtask via required intra-agent checks, scheduling based on explicit priorities and resource constraints, and logging all state transitions for complete traceability. This methodological control significantly enhances the reliability and reproducibility of AI-automated experimentation (Kon et al., 22 Feb 2025).

1. Definition and Functional Role

Inter-ARM functions as the supervisory mechanism responsible for methodical control in Curie’s multi-agent experimentation engine. Its primary objectives are as follows:

• Guaranteeing procedural adherence: All experimental subparts (“plan partitions”) advance only through rigorously permitted state transitions, defined by a finite-state control-flow grammar. Inter-ARM prevents out-of-order execution, ensuring, for example, that no experiment is executed before prior validation.
• Validation enforcement: Every transition requiring validation triggers an invocation of the Intra-Agent Rigor Module (Intra-ARM), which handles reliability checks at the agent level.
• Resource optimization and scheduling: Assignment and dispatch of tasks respect technician availability and experiment priority, optimizing resource utilization.

Inter-ARM resides at the logical interface between the architect agent, technician agents, and the other modules. Every emitted inter-agent message is intercepted, checked, possibly sanitized, and only then relayed to the recipient. Additionally, all updates are logged in the Experiment Knowledge Module, yielding an append-only DAG of events—a full “time machine” of experimental evolution.

2. Architectural Integration and Communication Interfaces

Curie’s architecture comprises two organizing axes: agents and modules. The agent set $$A = \{\text{Architect};\, \text{Technician}_1,\, \ldots,\, \text{Technician}_n\}$$ is supported by three modular engines: Intra-Agent Rigor Module (plan and execution validation), Inter-Agent Rigor Module (workflow control), and Experiment Knowledge Module (metadata/history).

Every inter-agent message $m_{ij}$ from $a_i \in A$ to $a_j \in A$ is routed via Inter-ARM. Depending on the message content and the state of the relevant plan partition, Inter-ARM may:

• Consult the partition’s current state,
• Invoke Intra-ARM for protocol-mandated validations,
• Issue a sanitized, protocol-conformant message $m'_{ij}$ to the next agent.

Meanwhile, every transcript and state change is persisted in the Experiment Knowledge Module, constructing a temporally ordered event DAG.

3. Formal Control-Flow and Scheduling Model

Inter-ARM’s rigor is defined by an explicit formal model:

• Partitions: $P = \{p_1, \ldots, p_k\}$, representing decomposed sub-experiments.
• States: $$S = \{\text{NEW}, \text{VALIDATED}, \text{ASSIGNED}, \text{EXECUTED}, \text{ANALYZED}, \text{COMPLETED}\}$$, through which each partition passes.
• Transitions: $\Delta \subseteq S \times S$, enumerating permissible state progressions.
• Priorities: $\pi:P \to \mathbb{N}$, assignment of priorities by the architect.
• Technicians: $T = \{t_1, \ldots, t_m\}$, available for subtask execution.

Transitions are managed by the relation

$m_{ij}$0

where $m_{ij}$1 yields all $m_{ij}$2 pairs allowed by $m_{ij}$3 and permitted agent assignments.

Scheduling is instantiated as a priority queue $m_{ij}$4 sorted by $m_{ij}$5. The core Inter-ARM loop (see pseudocode below) repeatedly extracts max-priority partitions, checks transition allowance, conducts any necessary validation, forwards the subtask, logs the transition, and re-inserts the partition if incomplete.

Inter-ARM Scheduling Pseudocode

$a_i \in A$4

“Choose” can be implemented by round-robin, priority order, or resource-aware strategies, but the paper’s implementation specifies hand-tuned and static policies.

4. Mechanisms for Rigor: Consistency, Completeness, and Enforcement

Inter-ARM ensures:

• Consistency: State transitions are strictly limited to those specified in $m_{ij}$6 and validated by Intra-ARM as necessary; illegal transitions are reported and blocked.
• Completeness: Every partition traverses all defined states unless validation fails, in which case it is sent back for revision, ensuring that all essential phases are executed.
• Methodological rigor: Step-by-step enforcement of the protocol grammar and repeated validation preclude any “skipping ahead”; for example, technicians cannot EXECUTE a partition prior to successful VALIDATION.

The logging of all transitions as a DAG in the Experiment Knowledge Module guarantees a fully auditable and interpretable experimental record.

5. Illustrative Application: LLM Reasoning Benchmark

A concrete demonstration from the LLM-reasoning benchmark clarifies Inter-ARM’s operational sequence:

1. Partitioning: The Architect agent emits a plan $m_{ij}$7 (e.g., chain lengths $m_{ij}$8 for models $m_{ij}$9), which Inter-ARM decomposes into 14 partitions $a_i \in A$0.
2. Validation: For each $a_i \in A$1, $a_i \in A$2 is computed and validation is invoked—for instance, the Setup Validator checks correct variable definitions and I/O structure.
3. Assignment: Once validated, the partition is assigned and dispatched to a technician for setup and implementation.
4. Execution and Re-validation: Post-setup, the Execution Validator ensures clean execution, captures reproducibility, and verifies log conformity.
5. Analysis: Technicians return results, which are routed by Inter-ARM to the Architect for evaluation and possible priority adjustment.
6. Completion: Upon reaching ANALYZED with no pending refinements, the partition transitions to COMPLETED.

Only after every partition completes the full rigor pipeline is a final scientific conclusion drawn. For example, the determination that “GPT-4o-mini at chain length 4 yields optimal accuracy–cost trade-off” is contingent upon this full process.

6. Empirical Impact and Comparative Evaluation

The quantitative impact of Inter-ARM’s enforcement is documented in performance benchmarks comparing Curie to OpenHands and Magentic. Key findings from Table 2 of (Kon et al., 22 Feb 2025):

Domain	Exec. (Curie / OH / Mag)	Align. (Curie / OH / Mag)	Con. (Curie / OH / Mag)
Weighted Avg	78.1% / 32.4% / 6.8%	73.4% / 40.2% / 35.2%	36.1% / 10.5% / 2.3%

The substantial increases in execution-setup success rate, implementation alignment, and conclusion correctness are primarily attributable to Inter-ARM’s rigorous protocol enforcement and repeated partition validation.

7. Current Limitations and Prospective Directions

• Static policy specification: Transition relations $a_i \in A$3 and scheduler policies are currently static and hand-crafted. Adapting these dynamically, for example via reinforcement learning, may further improve throughput.
• Resource modeling: The scheduler’s priority queue does not yet account for hardware quotas (e.g., GPU/CPU). Integration of cost models remains an open direction.
• Cross-experiment generalization: While exhaustive logs are preserved, knowledge reuse for accelerating future runs (“experiment meta-learning”) is not yet implemented.
• Domain extensibility: The present control grammars are optimized for computer science–style benchmarks. Broader domains, especially those requiring uncertainty quantification or statistical stopping rules (e.g., wet-lab settings), will necessitate richer state and control schemas.

In summary, the Inter-Agent Rigor Module is a formally grounded, auditable, and stateful engine at the core of Curie’s experimental robustness, ensuring every automated experiment is subjected to the systematic controls required for reproducible and trustworthy results (Kon et al., 22 Feb 2025).