SciBORG: Distributed & Agentic Framework

• SciBORG is a dual framework that combines fault-tolerant, distributed CP search with a modular LLM-based agentic system for scientific research.
• Its distributed module utilizes dynamic model splitting and complete provenance tracking to ensure full search-space coverage and fault tolerance.
• The LLM-based agentic component employs state-aware planning, FSA memory, and multi-agent orchestration to execute reliable and interpretable workflows.

SciBORG (Scientific Bespoke Artificial Intelligence Agents Optimized for Research Goals) denotes two distinct yet foundational frameworks for distributed scientific computation and autonomous agentic reasoning. The term first referred to a large-scale, fault-tolerant distributed AI search system for combinatorial problems across heterogeneous infrastructures (Kotthoff et al., 2012); subsequently, it identified a modular LLM-centric agentic framework engineered for robust multi-step planning and tool integration in scientific workflows, leveraging state and memory models to guarantee reliability (Muhoberac et al., 30 Jun 2025).

1. Distributed Combinatorial Search Infrastructure

The original SciBORG framework, introduced by Kotthoff, Kelsey, and McCaffery, provides a highly robust, minimal-infrastructure environment for distributing constraint programming (CP)–based search across disconnected and heterogeneous computational resources (Kotthoff et al., 2012). It is architected for long-running combinatorial problems, employing batch systems (Condor) or volunteer middleware (BOINC) without imposing hardware homogeneity or continuous connectivity.

Key Architectural Elements

Component	Functionality	Features
Master controller	Maintains job queues, injects work, reconciles results, tracks provenance	Lightweight daemon; provenance for every split model
Worker nodes	Execute Minion CP models within fixed time slices	Heterogeneous, self-contained; behind NAT/firewall possible
Task queue	Schedules jobs and file transfers	Uses Condor/BOINC; supports auto requeuing; models + timeouts as units
Verification module	Ensures search completeness/correctness	Traverses model DAG; checks for gaps, overlap, provenance

The process involves master submission, worker execution (Minion solver to exhaustion or timeout), and returning of outputs and possible further splits. No peer-to-peer node interaction occurs; all synchronization is via the submit machine.

2. Model Splitting, Provenance, and Robustness Guarantees

SciBORG’s central technical innovation is dynamic model splitting with complete parent/child provenance. Upon timeout or voluntary split, a worker partitions its variable’s domain $D$ into $n$ disjoint subsets ($n=2$ typical), generating new Minion models each with subset constraints and accumulated restart “nogoods”. Each new model tracks inherited constraints and its parent, forming a searchable history (graph) that guarantees full coverage and non-overlap:

• At any point, the search state is encoded by the text model plus nogoods, and any lost work is bounded by $|workers|\cdot T_{max}$.
• Fault-tolerance is ensured as assignment of identical subtasks is rare and discarded via model file matching.
• Finished runs can be audited by walking the parent-child DAG to check for full search-space partitioning and absence of missed regions.

This approach enables the recovery and auditability uncommon in previous distributed CP frameworks.

3. Data Structures, State Encoding, and Performance Models

Problems are encoded as Minion model files generated from succinct mathematical descriptions, with variables $X$ and constraints $C$. Each model file, possibly paused, includes not only operational state but the history of explored branches. All intermediate and final state is externalized as human-inspectable files with parent pointers.

Formally, for a CSP $(X,D,C)$, the overall search space after splitting can be described as $S=\bigcup_{i=1}^m S_i$ with $S_i\cap S_j=\emptyset$ and $S_i$ determined precisely by accumulated constraints and partitioning. Parallel speedup is $S_p=T_1/T_p$, typically sublinear, limited by straggler subproblems and file I/O overhead. The robustness metric is the worst-case work loss: $Lost\_work \leq p\cdot T_{max}$ (Kotthoff et al., 2012).

4. LLM-Based Agentic Framework with State-Aware Planning

A convergence in nomenclature, the most recent instantiation of SciBORG frames a modular, agentic architecture for autonomous execution of scientific, physical, and data-driven tasks (Muhoberac et al., 30 Jun 2025). This framework is anchored by several key modules: dynamic “toolkit” construction, FSA-driven memory, hierarchical planners, and integration with both physical hardware and web resources.

Core System Components

• Infrastructure Constructor: Parses source code (docstrings) via LLM chains to extract valid commands, data types, and microservices, outputting a runtime “toolkit.”
• Planning Chains: Two-stage pipeline translates user goal $G$ into an abstract sequence of subgoals ($\langle g_1, ..., g_n\rangle$) and then executable JSON workflows.
• Agent Core (TAO Loop): Iterative Thought → Action → Observation sequence, scriptable in JSON, that guides tool invocation and direct response.
• Memory Manager: Maintains chat (verbatim), action-summary (compressed tool traces), and pseudo-FSA (formal state automaton) buffers.
• Document-Embedding Retriever (RAG): FAISS-based retrieval of relevant context chunks from domain corpora.
• Command Interpreter: Orchestrates tool and hardware actions from workflow instructions.
• Agent Orchestrator: Facilitates agent-to-agent delegation and selection among specialized agents, e.g., PubChem retrieval versus instrument control.

The layered memory substrate—including explicit FSA modeling—allows for accurate persistent state tracking, error recovery, and robust multi-step planning.

FSA Memory Formalization

Pseudo-FSA memory is defined as $M=(S, \Sigma, \delta, s_0, F)$, where $S$ is a Cartesian product of device or workflow state attributes (e.g., session, lid state, vial loading, thermal/control parameters), and $a_t\in\Sigma$ are tool actions; state $s_{t+1}=\delta(s_t,a_t)$. Memory updates after each tool invocation, supporting context recovery and interpretable logs (Muhoberac et al., 30 Jun 2025).

5. Planning, Reasoning, and Integration Protocols

SciBORG’s LLM-driven reasoning system employs:

• High-level planners for abstract task decomposition from user goals,
• Low-level planners for precise mapping to the dynamically constructed toolkit schema,
• An internal ReAct (Thought-Action-Observation) loop for instrumented execution,
• Context augmentation via document-embedding retrieval for literature- or protocol-grounded subtasks,
• Multi-agent orchestration for modular, composable workflows.

Interfacing spans microservice JSON APIs (e.g., instrument control) and RESTful calls (e.g., PubChem query and retrieval), unified under a generic agent–tool protocol schema. Tool execution is schema-validated (JSON) and failure-handling automatically replans using current FSA state and error traces.

6. Empirical Validation and Comparative Results

Evaluation of SciBORG in both historical and recent settings demonstrates robust performance:

• For combinatorial search, SciBORG enabled enumeration of all non-equivalent semigroups of order 10 (search space $10^{100}$), achieving workload distribution over $\approx150$ CPU cores and sustaining 133 core-years of computation with wall time $\approx$ 18 months (Kotthoff et al., 2012).
• Recent LLM-based SciBORG agents validated on both virtual laboratory instruments (microwave synthesisers) and data retrieval (PubChem) exhibit significant improvements in path and state success rates when FSA memory is enabled (90% path success vs 50–65% for chat or no memory) and maintain smaller, interpretable buffers (197 vs 756 chars). Document-embedding retrieval yielded ≥95% success for parameter extraction tasks.

A plausible implication is that explicit state modeling and dynamic agent construction are critical to sustaining long-horizon reliability and adaptability in both physical and data-driven scientific applications.

7. Limitations and Prospects

The distributed search framework requires manual tuning of split granularity (static $T_{max}$), and all state management occurs in external files, which may become an I/O bottleneck at scale (Kotthoff et al., 2012). No continuous dynamic estimation of subproblem cost or load is built-in. For the LLM agentic framework, memory ablations suggest that success is highly dependent on the completeness and correctness of FSA schemas; chat-only memory provides suboptimal reliability.

Future directions include the incorporation of adaptive splitting heuristics, extension to broader volunteer pools (via BOINC), public release of agent control infrastructure, and application to a wider range of scientific workflows in AI planning, configuration, and computational science (Kotthoff et al., 2012, Muhoberac et al., 30 Jun 2025). The frameworks collectively establish a robust, generalizable foundation for distributed search and autonomous AI agents in complex, heterogeneous environments.