Version: 1.0.1 Authors: Yuhan Chen, Hongyi Lin, Tianyi Zhang, Venkatasubramanian Viswanathan License: MIT Paper:ElyteAgent: A Multi-Agent Workflow for Autonomous Electrolyte ExperimentationCode & data:https://github.com/BattModels/ElyteAgent.git
This repository contains ElyteOS, the experiment orchestration and
data-management layer for autonomous electrolyte research, together with the
Agent module (src/Agent/) that implements ElyteAgent — a
multi-agent, LLM-driven workflow for feasibility-aware autonomous
electrolyte experimentation, described in the accompanying paper.
ElyteAgent coordinates three experimental/software infrastructures:
- Clio — the robotic platform that prepares electrolyte samples by mixing predefined feeder solutions and measures transport properties (ionic conductivity, density, viscosity).
- SALSA — an automated solubility-testing add-on that determines experimentally accessible salt concentration bounds via an excess-solvent, camera-monitored dissolution workflow.
- ElyteOS (this repo) — the software layer that handles device control, experiment-token representation, inventory tracking, scheduling, logging, database storage, and visualization.
Rather than a single monolithic automation script, ElyteAgent divides an experimental campaign into four specialized LLM agents that translate natural-language scientific objectives into validated, executable, solubility- and inventory-constrained robotic experiments — recovering from tool-level and hardware-level errors along the way.
ElyteAgent is organized around four agents (see Fig. 1 of the paper),
implemented on top of LangGraph (v0.4.8) with GPT-4o-mini
(snapshot 2024-07-18) as the underlying LLM:
| Agent (paper) | Log tag (code) | Responsibility |
|---|---|---|
| Conversation Agent | CONVERSATION_AGENT | Parses natural-language requests into a structured electrolyte design space (solvents, salts, concentration bounds) and generates initial candidate compositions via hit-and-run sampling. Writes design-space metadata and composition tokens to the session file. |
| Manager Agent | MONITOR_AGENT | Validates candidate compositions from the Conversation or Optimization agent against feeder-solution inventory, remaining volume, and SALSA-derived solubility bounds. Rejects infeasible formulations, queues feasible ones, tracks Experiment Agent status, and stores completed results in the database. |
| Experiment Agent | EXPERIMENT_AGENT | Executes validated experiments through ElyteOS, routing to Clio (electrolyte prep/property measurement) or SALSA (solubility characterization). Maintains a status tracker (progress, results, equipment status, errors); retries failed steps and, if unrecoverable, reports to the Manager Agent — resuming from the last checkpoint once resolved rather than restarting. |
| Optimization Agent | OPTIMIZATION_AGENT | Proposes new candidate formulations from accumulated results using Bayesian Optimization (upper-confidence-bound acquisition function over a k-nearest-neighbors surrogate model), balancing exploration and exploitation. Runs until convergence, the requested trial count is reached, or feeder solutions are exhausted. |
Every experiment is represented as a shared composition token:
solvent identities|solvent fractions|salt identities|salt molalities
e.g. H2O|100|NaNO3|5.39 — a 100% H₂O solvent with 5.39 mol/kg NaNO₃. This
token, plus a shared session file (design space, sampled/queued/completed
experiments, optimization state), lets all four agents exchange experiment
definitions without manual translation.
Design-level errors (invalid tokens, missing solvents/salts, out-of-bound concentrations, insufficient inventory) are caught by the Manager Agent before anything reaches the hardware. Hardware-execution errors (device faults, communication failures, failed measurements) are caught by the Experiment Agent, which retries and, if needed, escalates while preserving state for resumption.
EEG-Clio-Database-master/
├── Main-backup.py
├── requirements.txt
├── License.txt / NOTICE.txt
└── src/
├── Main.py # Dash GUI entry point
├── Agent/ # ElyteAgent: LLM multi-agent orchestration layer
│ ├── Agent.py # agent graph (LangGraph), logging, Azure OpenAI setup
│ ├── Tools.py # design-space / composition-ID tools (Conversation Agent)
│ ├── Experiment_Tools.py # hardware-control tools (Experiment Agent)
│ ├── BeysianOptimization.py # Optuna/BO-based optimizer (Optimization Agent)
│ ├── JSONHelper/ # system prompts + tool descriptions
│ ├── Generated JSON/ # saved experiment queues / session files
│ └── conversation_history/ # per-run agent execution logs
├── Equipment_Control/ # Serial/HID drivers for pumps, valves, balance,
│ # potentiostat, viscometer, thermometer, camera (Clio/SALSA hardware)
├── Database/ # Solvent/salt molar mass tables, DB pipeline
├── Db/ # SQLite databases
├── pspython/ # PalmSens potentiostat Python bindings
└── assets/ # Dash static assets (logo, CSS)
- Operating System: Windows 10
- Python Version: Python 3.8 or higher
- (Agent layer only) An Azure OpenAI resource with a deployed chat-completion
model (the published results use a GPT-4o-mini snapshot,
2024-07-18)
- Open a terminal and navigate to the project folder.
- Install the core (GUI + equipment control) dependencies:
pip install -r requirements.txt
- Install the additional dependencies required by the Agent layer (not
currently pinned in
requirements.txt):pip install langchain langchain-core "langgraph==0.4.8" langchain-openai openai optuna opencv-python - Locate your Python package install directory:
Look for the
pip show dash
Location:line in the output and copy that path. - Move the
pspythonfolder into that install directory (needed for PalmSens potentiostat communication):move pspython /path/to/python/site-packages/
- Configure Azure OpenAI credentials for the Agent layer as environment
variables before launching the app:
or place them in a local
set AZURE_OPENAI_ENDPOINT=https://<your-resource-name>.openai.azure.com/ set AZURE_OPENAI_API_KEY=<your-key>
.envfile that is excluded from version control via.gitignore.
- End-to-end automated pipeline for lab equipment (Clio, SALSA) to conduct electrolyte experiments.
- Natural-language experiment design, feasibility validation, execution monitoring, and error recovery via ElyteAgent.
- Bayesian-optimization-driven, closed-loop suggestion of new experimental conditions (upper-confidence-bound acquisition on a k-NN surrogate).
- Durable storage of all experiment data, metadata, and session state.
- Data retrieval, filtering, and visualization through the GUI.
- Open a terminal and navigate to the project folder.
- Run:
python Main.py
- Open a browser to
http://localhost:8050.
Instead of manually building a composition ID, describe the campaign in natural language — e.g. "Explore aqueous NaNO3 with molality ≤ 9 mol/kg and Li2SO4 with molality ≤ 2.5 mol/kg" — and:
- The Conversation Agent infers H₂O as the (fixed, 100%) solvent, sets NaNO₃/Li₂SO₄ as design variables with the given bounds, and hit-and-run samples initial candidate compositions into the session file.
- The Manager Agent checks each candidate against feeder-solution inventory and SALSA-derived solubility limits, rejecting infeasible formulations (e.g. two salts that numerically fit their own bounds but together exceed available feeder volume) and queuing the rest.
- The Experiment Agent runs the physical Clio/SALSA sequence
(
prepare → start_new_experiment → make_solvent → measure_mass → measure_conductivity → measure_viscosity → measure_temperature → finish_measurement, or the solubility variant:add_salt → add_solvent → stir_liquid → detect_dissolution_status), reporting results or surfacing hardware errors (e.g. "Vial cannot be detected") for you to resolve — you can then say "Please resume the experiment" to continue from the last checkpoint rather than starting over. - The Optimization Agent uses completed results to propose the next batch of candidate compositions, closing the loop until convergence, the requested trial count, or feeder-solution exhaustion.
Agent conversations and tool calls are logged per-run under
src/Agent/conversation_history/, and each generated experiment queue /
session file is saved as timestamped JSON under src/Agent/Generated JSON/.
This work was supported by the Toyota Research Institute.
The code is licensed under MIT.