AISAC: AI Scientific Assistant Core

• AI Scientific Assistant Core (AISAC) is a modular, multi-agent system that integrates semantic retrieval and rigorous audit trails to support scientific research.
• Its architecture employs hybrid memory solutions and a structured StateGraph to streamline task routing and data provenance.
• The system enables domain-specific customization and reduces redundant computation, enhancing transparency and trust in scientific workflows.

An AI Scientific Assistant Core (AISAC) is a modular, multi-agent, and retrieval-grounded system architecture designed to enable transparent, reliable, and auditable AI-powered assistance for scientific research and engineering workflows. AISAC synthesizes practices from LLM orchestration, semantic retrieval, structured provenance tracking, and configuration-driven extensibility, with domain-specific customizability and rigorous auditability as central tenets (Bhattacharya et al., 18 Nov 2025). It supports heterogeneous workflows by integrating orchestration frameworks (e.g., LangGraph), hybrid memory backends (e.g., FAISS for vector search, SQLite for relational persistence), and a declarative manifest system for tool and prompt configuration, allowing deployment across multiple scientific disciplines and workflows.

1. System Architecture and Data Flow

AISAC employs a layered, multi-agent stack comprising orchestration, memory, retrieval, and user interface layers. Its core workflow is structured around a set of prompt-engineered agents—Router, Planner, Coordinator, Researcher, and (optionally) Evaluator—organized as nodes in a StateGraph (using LangGraph), with explicit edges representing conditional task routing and dependencies. A simplified architecture is:

[User Query] | [Router] --------> [Planner] --------> [Coordinator] | | | | v v | [Researcher] [Researcher] | ^ ^ +----> [Coordinator] --+ | [Evaluator (optional)]

• Router: Classifies query intent via semantic embedding similarity, retrieving relevant context from both relational (SQLite) and vector (FAISS) stores, then routes to Planner or Coordinator.
• Planner: Decomposes complex tasks into a sequence of structured subtasks, each tagged with requisite tool(s) and arguments.
• Coordinator: Executes subtasks, invokes external tools/plug-ins, collects output, checks for consistency, and synthesizes structured responses.
• Researcher: Performs retrieval-augmented generation (RAG), filtering evidence and returning provenance-tagged snippets.
• Evaluator: Optionally reviews the full decision trace for quality, consistency, and completeness, emitting JSON-encoded critiques.

All agent transitions, tool calls, and retrievals are serialized as trace events, forming a replayable, auditable episode history (Bhattacharya et al., 18 Nov 2025).

2. Memory, Retrieval, and Indexing

AISAC employs a hybrid memory system.

• Relational Memory (SQLite): WAL-mode SQLite tables index all session events, including prompts, plans, arguments, tool calls, and outputs, forming an episodic, queryable trace.
• Semantic Vector Memory (FAISS): Maintains:
  • RAG vector indices (scientific corpus, tool documentation).
  • Dialogue indices (tokenized embeddings of previous QA pairs).

Each query $e_q$ is embedded ($e_q \in \mathbb{R}^d$) and retrieved with cosine similarity against indexed vectors $e_i$: $$\mathrm{sim}(e_q, e_i) = \frac{e_q \cdot e_i}{\|e_q\|\|e_i\|}$$ Incremental RAG indexing is governed by a manifest: for each file, the system stores its SHA256 hash, modification time, and length. Unchanged files are not re-embedded, dramatically reducing redundant computation during corpus evolution.

Metadata-rich catalogs can index large or streaming tabular data (e.g., experimental logs) for on-demand, tool-based retrieval, rather than persistent embedding.

3. Agent Roles, Prompting, and Orchestration

All agents in AISAC are governed by strict versioned system prompts defining goal, required input fields, and a schema for JSON output. This enforces traceable, machine-readable exchanges and precludes prompt drift or hallucinated tool usage.

Router Example Prompt:

{ "role": "system", "content": "You are AISAC.Router. Input: {\"query\": string, \"history\": [...]}. Output only JSON with keys: 'route_to': ['Planner','Coordinator'], 'retrieval_ids': [string], 'similarities': [number]." }

• Planner: Receives structured intent, returns an ordered list of subtasks in JSON ("tool", "arguments").
• Coordinator: Accepts a subtask, invokes specified tools, synthesizes and validates outputs, tracking every call in the trace log.
• Researcher: Exposes granular retrieval APIs, providing evidence, similarity scores, and document provenance for downstream agents.
• Evaluator: Ingests the full trace, outputs critiques with severity in [0,1], and may trigger automatic re-routing on error detection.

All agent decisions and tool outputs are recorded, and the GUI displays live updating panes showing Planner task hierarchies, Coordinator execution steps, context panels (retrievals, file manifests), and Evaluator reviews (Bhattacharya et al., 18 Nov 2025).

4. Configuration, Extensibility, and Customization

AISAC supports domain-specific adaptation without core code modification via a configuration-driven startup layer:

• Project Manifest: Declares assistant name, target domain, data sources (embedded/catolog-only), and list of extension modules.
• Tool Modules: Custom tool APIs are loaded and registered as specified in the manifest.
• Prompt Overlays: Versioned prompt overlays allow custom system prompt text and few-shot examples.
• Dynamic Graph Augmentation: Core LangGraph topologies are extended via module-level graph builder scripts for workflow customization.

Upon startup, AISAC reads the manifest, loads tool modules, overlays prompts, builds the project-specific StateGraph, and initializes retrieval indices and the GUI. This architecture supports rapid deployment of specialized scientific assistants for materials informatics, reaction engineering, safety analysis, literature review, and more (Bhattacharya et al., 18 Nov 2025).

5. Provenance, Transparency, and Auditability

AISAC emphasizes full transparency and reproducibility through event-level provenance capturing:

• Every action (agent decision, retrieval, tool call) is timestamped, version tagged, and logged with context (input, retrieval metadata, tool arguments, output).
• GUI panes show synchronized, hierarchical traces—users can click into any node for raw config, provenance fields, retrievals, or model versions.
• Session export enables full trace playback or comparison between runs.
• Lessons learned highlight high user trust and auditing efficacy due to this transparency; e.g., the provenance panes accelerated troubleshooting and validation tasks for scientific end users (Bhattacharya et al., 18 Nov 2025).

6. Evaluation, Case Studies, and Lessons Learned

AISAC has been deployed across several domains at Argonne National Laboratory, including:

• Domain-specialized agents: with custom tool and prompt layers for waste-to-products conversion (FM4R2P) and energy process safety (AI-EPS).
• General-purpose scientific assistants: for literature analysis and research support using only the AISAC core.
• Meta-cognitive assistants: for system-level QA and continuous self-evaluation.

Reported outcomes:

• Up to 70% reduction in re-embedding time via manifest-driven incremental indexing.
• Rapid addition of new tools with minimal code changes.
• High trust in audit and validation from domain scientists.

Key lessons include the value of strict JSON I/O contracts and the impact of the Evaluator agent in preventing incomplete or spurious outputs before human review. Although the report does not tabulate end-to-end latency or retrieval accuracy, internal metrics support efficiency and transparency improvements (Bhattacharya et al., 18 Nov 2025).

---

AISAC represents a systems-engineering blueprint that composes multi-agent LLM orchestration, hybrid memory, incremental retrieval, and declarative extensibility into a robust, traceable core for scientific AI assistance. By rooting customization in manifests and extension modules while ensuring every reasoning step is reproducibly recorded, AISAC enables rapid deployment of domain-specialized research assistants under a common, transparent infrastructure.