Bohrium+SciMaster: Agentic Science Stack

• Bohrium+SciMaster Stack is a two-layered infrastructure for agentic science, combining a managed capability hub (Bohrium) with a workflow orchestrator (SciMaster) for traceable, modular research.
• The platform leverages a scientific intelligence substrate featuring hierarchical models, a provenance-aware knowledge graph, and community tools to standardize data, compute, and experiments.
• Demonstrated improvements include order-of-magnitude cycle time reductions and enhanced reproducibility, making it ideal for complex multi-agent scientific workflows.

Bohrium+SciMaster Stack refers to a two-layered infrastructure and ecosystem designed for agentic science at scale—an operational paradigm wherein AI agents execute multi-step, tool-interleaving scientific workflows with high traceability, governance, and modularity. This stack comprises the Bohrium infrastructure hub and the SciMaster orchestration layer, integrated via a scientific intelligence substrate encompassing hierarchical models, a provenance-aware knowledge graph, and open-source community-contributed capabilities. The platform supports diverse scientific reading, computing, and experimental workflows with end-to-end auditability and has demonstrated order-of-magnitude reductions in scientific cycle time through application to a broad array of master agents and tasks (Zhang et al., 23 Dec 2025).

1. System Architecture

Bohrium+SciMaster is structured in two coordinated tiers:

• Bohrium (Infrastructure Layer): Functions as a managed, traceable capability hub analogous to a "HuggingFace of AI for Science." It standardizes diverse scientific data, software, compute, and laboratory assets into governed, agent-ready callable capabilities. Bohrium aggregates:
  • Data ingestion (Science Navigator) for constructing a unified evidence substrate.
  • Tool invocation and compute scheduling (Lebesgue) that exposes models/solvers as services.
  • Experiment execution (UniLabOS) rendering laboratory protocols as transaction-safe, schedulable jobs.
  • Execution tracing and governance, recording every agent invocation as a tuple $$\tau = ((t_1, a_1, \text{in}_1, \text{out}_1), ...)$$ to support auditability and replay.
• SciMaster (Orchestration Layer): Consumes the Bohrium catalog and the scientific intelligence substrate to assemble and govern explicit workflow DAGs and stateful sessions. SciMaster provides:
  • Workflow specification and scheduling.
  • Multi-agent session management.
  • Error handling, re-verification, and branching for robust scientific automation.

The intelligence substrate mediates between these layers, facilitating composition, auditability, and workflow improvement.

┌─────────────────────────┐ ┌─────────────────────────┐ │ Human & Agentic │ │ Open AI4S Community │ │ Users (Clients) │ │ (DeepModeling, etc.) │ └────────────┬────────────┘ └────────────┬────────────┘ │ │ ┌───────┴─────────┐ ┌─────────┴─────────┐ │ SciMaster │ Orchestration│Scientific │ │• Workflow spec │ 〈〈〈〈〈〈〈〈 Intelligence │ │• Scheduling │ 〉〉〉〉〉〉〉〉 Substrate │ │• Multi-agent │ │(models, KG) │ └───────┬─────────┘ └─────────┬─────────┘ │ │ ┌───────┴─────────┐ │ │ Bohrium │───── Agent-Ready ───────┘ │• Capability Hub │ Reading/Computing/Experiment │• Compute & Lab │ (Science Navigator, Lebesgue, │• Registry, │ UniLabOS) │ Tracing │ └─────────────────┘

2. Scientific Intelligence Substrate

Sitting between infrastructure and orchestration, the scientific intelligence substrate is composed of three pillars:

• Hierarchy of Models: Encompasses general-purpose foundation models (“Innovator”), domain-specific models (e.g., Uni-Mol, DPA³), and pipeline/application models (e.g., Uni-Parser, Uni-QSAR). Each model $M_i$ is registered as $M_i: \mathcal{X}_i \to \mathcal{Y}_i$, with $\mathcal{X}_i, \mathcal{Y}_i$ (input/output) defined via JSON-schema and performance constraints: $\text{cost}(M_i) \leq C_i$, $\text{latency}(M_i) \leq L_i$, $\text{success-rate}(M_i) \geq R_i$.
• Knowledge Graph (SciencePedia): Stores science concepts and dependencies as provenance-anchored triples $(\text{node}_1\text{—[relation]}→\text{node}_2)$, each justified with a Long-Chain-of-Thought (LCoT). For example, reaction rates can be encoded as:

$$\mathrm{ReactionRate}(T, E): \bigl(T\in \mathbb{R}^+,\;E\in\mathbb{R}^+\bigr)\;\to\;\mathbb{R}^+,\quad \mathrm{Rate} = A\,e^{-E/(k_B T)}.$$

• Open-Source Community (DeepModeling): Provides engines (DeePMD-kit, ABACUS), tools (DP-GEN, dflow), and pipelines (APEX, CrystalFormer), all encapsulated as Bohrium capabilities with versioned interfaces and validation contracts.

3. Bohrium Capabilities: Definitions and Governance

Bohrium transforms heterogeneous assets into capabilities $C_i = (I_i, O_i, P_i, E_i)$, where $I_i$ and $O_i$ are input/output JSON-schemas, $P_i$ is an execution policy (quota, safety bounds), and $E_i$ is the execution envelope (docker, HPC kernel, protocol). Core mechanisms include:

• Stable Interface Definitions: Capabilities are callable via standardized schemas with minimal contracts: $f_i(\text{in}) \to \text{out} \in O_i$ or error.
• Execution Logging & Traceability: Each call is logged as a tuple in $$L \subset \mathcal{T} \times \mathcal{C} \times \mathcal{X} \times \mathcal{Y}$$, facilitating provenance and cost accounting.
• Governance & Accounting: Resource quotas, priorities, and safety envelopes are enforced by Lebesgue and UniLabOS; outputs are linked to input commits and container hashes for robust reproducibility.

4. SciMaster Workflow Orchestration and Execution

SciMaster composes agentic workflows as explicit DAGs with typed, verifiable steps:

• Workflow Language:

$$W ::= \mathrm{Task}(q) \;\Rightarrow\; S^*;\quad S ::= \mathrm{Invoke}(C_i, p_i) \mid \mathrm{Verify}(v) \mid \mathrm{Branch}(cond)$$

Each $S$ is typed and guarded by verification gates.

• Runtime Logic (excerpt):

def run_workflow(query): session = Session(state={}) plan = Innovator.plan(query) for step in plan.steps: try: result = Bohrium.invoke(step.capability, step.params) except ExecutionError as e: step = SciMaster.handle_error(step, e, session.state) continue if not SciMaster.verify(step.verify_spec, result): step = SciMaster.revise(step, result, session.state) continue session.log(step, result) return session.outputs

• Scheduling & Verification: Steps are scheduled via Lebesgue's resource policies; runtime guards ensure JSON-schema and semantic correctness (e.g., mass balance). Failures trigger workflow branching or rollback.

5. Master Agents and Scientific Use Cases

Eleven master agents instantiate diverse end-to-end workflows:

Agent Name	Domain/Function
AMTechMaster	Additive manufacturing—sim-driven optimization
FlowXMaster	CFD—image/text→mesh→solver pipeline
MatMaster	Materials design—Read–Compute–Experiment
ML-Master	Automated ML experiments under time budget
OPT-Master	Operations research—optimization from NL
PaSaMaster	Cross-disciplinary literature retrieval
PDEMaster	Text→PDE discretization→FEM simulation
PharmMaster	Patent parsing/Markush extraction/FTO assessment
PhysMaster	Large-scale physics workflow automation
SpecMaster	Multi-spectral structure elucidation
SurveyMaster	Citation-grounded literature survey drafting

Exemplar: MatMaster proceeds through literature retrieval (PaSaMaster), design space generation, simulation (DFT or surrogates), candidate ranking, laboratory experimentation (UniLabOS), and feedback integration. Execution trace samples include agent-calls to “DFT-Workflow” ($\tau_1$ at $t=10:05$), “SurrogatePredictor” ($\tau_2$), and laboratory experiment ($\tau_3$), yielding an 80% reduction in invalid runs and cycle time contraction from 8 weeks to 3 days.

Exemplar: PDEMaster ingests natural-language PDEs, queries SciencePedia for weak-form patterns, invokes symbolic assembling, schedules computational jobs on Lebesgue, self-checks residuals, and iterates mesh refinement, compressing formerly multi-day expert workflows to less than one hour.

6. Performance, Scaling, and Feedback

Empirical results report order-of-magnitude cycle time reductions:

Agent	Conventional	Bohrium+SciMaster
SurveyMaster	1 month	4 hours
PharmMaster	10 days	<1 day
PDEMaster	Multi-day	<1 hour

Platform-wide, Bohrium processes over $10^{6}$ agent invocations monthly, each tracked with cost $C$, latency $L$, and success flag $s\in\{0,1\}$. These execution-grounded signals inform routing policy updates:

$$\pi(C_i~|~\text{query}) \propto \frac{\text{estimated\_success}(C_i)}{\text{cost}(C_i)}$$

A tightly-coupled online–offline flywheel iteratively refines packaging, orchestration, and models based on trace-driven feedback:

$$\underbrace{\text{Online Execution: }C_i\mapsto \tau}_{\text{Trace Generation}} \;\xrightleftharpoons[\text{Backward}]{\text{Forward}} \underbrace{\text{Offline Refinement: }\tau\mapsto \{\text{Packaging, Policies, Models}\}}_{\text{System Improvement}}$$

7. Observability, Portability, and Systemic Challenges

Key systemic obstacles and their engineered solutions include:

• Weak Observability & Reproducibility: Mitigated by uniform agent invocation tracing $\tau$ and versioned registries.
• Heterogeneous, Non-Agent-Ready Tools: Addressed by uniform capability packaging $(I_i, O_i, P_i, E_i)$ and enforced interface contracts (JSON-schema).
• Portability and Reuse: Ensured by standardized execution substrate and containerized workflow encapsulation.
• Feedback Deficit: Overcome via large-scale signal logging—informing subsequent routing, packaging, and substrate knowledge/model updates.

Cumulatively, Bohrium + SciMaster establishes scientific research as an executable, traceable production pipeline (Zhang et al., 23 Dec 2025). Standardization, orchestration, and knowledge integration enable agentic workflows to transition from bespoke prototypes to a scalable, continuously-improving Science-as-a-Service paradigm.