AGAPI-Agents: Autonomous API Platforms

• AGAPI-Agents are autonomous, open-access platforms that leverage LLMs and standardized API workflows for scientific materials discovery.
• They use a modular Agent–Planner–Executor–Summarizer design to execute deterministic, multi-step computational pipelines reliably.
• The system integrates various open-source LLMs with RESTful API endpoints, enabling reproducible and efficient scientific computations.

AGAPI-Agents are autonomous, open-access platforms designed to accelerate materials discovery by orchestrating LLMs and specialized computational tools through standardized API-driven workflows. The AGAPI-Agents system (AtomGPT.org API) deploys a modular Agent–Planner–Executor–Summarizer architecture, enabling LLMs to autonomously execute end-to-end scientific pipelines such as database querying, graph neural network predictions, force-field optimizations, tight-binding calculations, and diffraction analysis. The platform tightly integrates more than eight open-source LLMs and over twenty materials-science RESTful API endpoints within a transparent, reproducible, and scalable orchestration framework (Lee et al., 12 Dec 2025). The result is an environment where natural language queries drive credible, domain-grounded scientific computation, underscoring AGAPI-Agents as a distinct class of API-based LLM agents tailored for scientific and enterprise agentic workflows (Zhang et al., 14 Mar 2025, Tupe et al., 22 Jan 2025).

1. Formal Definition and Agentic Paradigm

AGAPI-Agents are defined as intelligent agents that employ LLMs as their cognitive engines to select, parameterize, and invoke one or more versioned, machine-readable REST API endpoints to fulfill user-specified materials science requests autonomously (Zhang et al., 14 Mar 2025). The defining properties include:

• Reliance on a curated, versioned set of API schemas (documented via OpenAPI 3.1)
• Structured (primarily JSON) calls to backend microservices
• Deterministic, reproducible execution enforced by deterministic LLM sampling (temperature=0) and version pinning
• Feedback-driven multi-step workflows, partitioned into reasoning (LLM), planning, execution, and summarization submodules

This approach contrasts with GUI-based agent paradigms, where LLMs act through simulated user interface interactions. AGAPI-Agents exemplify API-based agentic workflows: they achieve O(1) time complexity per workflow step, with high reliability due to the limited step depth and direct, schema-validated communication with computational backends (Zhang et al., 14 Mar 2025, Lee et al., 12 Dec 2025). The agent-environment interaction is mathematically formalized as $A: S \times O \to A'$, mapping agent state and observations to structured API actions (Tupe et al., 22 Jan 2025).

2. System Architecture and Orchestration

The AGAPI-Agents architecture modularizes agentic workflows into four distinct components (Lee et al., 12 Dec 2025):

1. Agent (LLM Reasoning Engine):
   • Interprets user intent using ReAct-style prompting, constructs structured tool calls as JSON adhering to OpenAPI-enumerated schemas.
   • Includes corrective feedback mechanisms for schema violations.
2. Planner (Workflow Decomposer):
   • Decomposes high-level queries into directed acyclic graphs of subtasks, managing dependencies such as sequence order, parameter propagation, and fallback strategies.
3. Executor (Asynchronous Orchestrator):
   • Dispatches API calls over HTTP, synchronously for fast operations or asynchronously for compute-intensive tasks with polling and token bucket rate-limiting.
   • Implements deterministic orchestration logic, including fallback (e.g., CHIPS-FF fallback if ALIGNN-FF is busy).
4. Summarizer (Response Synthesizer):
   • Aggregates results, validates physical consistency (e.g., checks formation energy sign), and formats outputs into tables, plots, interactive visualizations, and natural language reports.

Each subsystem operates over a unified context managed by feedback loops, ensuring that intermediate outputs dynamically inform downstream steps. Updates to reasoning (swapping in improved LLMs) and execution (expanding computational tools) are decoupled, allowing independent evolution and scalability.

3. Integrated Models, Tools, and API Endpoints

AGAPI’s agentic framework is underpinned by a diverse suite of LLMs and domain-specific microservices (Lee et al., 12 Dec 2025):

Category	Examples / Endpoints	Notable Features
LLMs	Llama-3.2-90B-Vision, DeepSeek-V3, Qwen3-Next-80B, Gemma-3-27B, Kimi-K2, GPT-OSS-20B, -120B, Phi-4	GPT-OSS-20B favored for speed/accuracy
Databases	/jarvis_dft/query, /mp/query, /aflow/query, /oqmd/query (via OPTIMADE), /pdb/query, /alphafold/query	Composition/property/elastic constants
GNN Property Prediction	/alignn/query	$f_{GNN}(X)=ALIGNN(X)\to\{\mathrm{properties}\}$
Force-Field Optimization	/alignn_ff/query, /chips_ff/query	$E(\vec{r}) = \sum_i U_i + \sum_{i<j} V_{ij}$
Electronic Structure	/slakonet/bandstructure	$H = \sum_{ij} t_{ij} c_i^\dagger c_j$
Diffraction/Spectroscopy	/pxrd/query, /saxs/query, /tem/query	Integration with DiffractGPT/MicroscopyGPT
Structure Manipulation	/generate_interface, /supercell, /vacancy, /substitution	Zur algorithm, defect/solution builder
Literature/Visualization	/arxiv/query, /visualize/3d	Interactive POSCAR/CIF rendering

Each endpoint validates input/output schemas (FastAPI/Pydantic), supports synchronous and asynchronous operations, and ensures deterministic execution through role-based configuration.

4. Workflow Patterns and Practical Applications

Representative AGAPI-Agents workflows span multi-step tasks in computational materials science, maintaining scientific credibility by linking each agentic action to a physically-validated calculation or data retrieval (Lee et al., 12 Dec 2025). Key workflows include:

• Semiconductor Defect Engineering (10 steps): Initiating with bulk GaN search, supercell construction, atomic substitution (e.g., Al doping), force-field relaxation, simulated XRD, property prediction, band structure, and narrative comparison of pristine vs. doped systems.
• Heterostructure Interface Design: Selecting polymorphs, generating interfaces with constrained lattice mismatch using the Zur algorithm, relaxation, and reporting atomic positions and strain metrics.
• Powder XRD Pattern Analysis: Structure retrieval, XRD simulation, peak identification, and phase purity assessment.

The Planner dynamically adapts workflow decomposition in response to prior outputs, invalid input triggers, and tool registry metadata. Error-handling includes intelligent fallbacks (e.g., downsizing supercells) and iterative recovery.

5. Evaluation, Metrics, and Performance Benchmarks

Quantitative evaluation of AGAPI-Agents leverages over thirty test prompts, measuring both tool-augmented and baseline (LLM-only) workflows against experimental reference values across key material properties (Lee et al., 12 Dec 2025). Benchmark results:

• Bulk modulus: MAE drops from 7.876 GPa (no tools) to 5.732 GPa (with tools); $R^2$ improves 0.984→0.994.
• Bandgap: MAE increases from 0.353 eV (no tools) to 0.495 eV (with tools); tool access degrades accuracy, suggesting specialized knowledge in LLMs may surpass raw database values for this property.
• Superconducting $T_c$: MAE increases five-fold with tool augmentation.
• SLME/Dielectric constant: Significant degradation with tool use, interpreted as a function of database coverage.

Throughput, latency, and success-rate metrics are defined as $\lambda = N_\mathrm{calls}/\Delta t$, $$L = t_\mathrm{response\_end} - t_\mathrm{request\_start}$$, and $$\mathrm{SR} = N_\mathrm{successful}/N_\mathrm{attempted}$$, respectively (Tupe et al., 22 Jan 2025). The overall workflow cost scales linearly with the number of directed steps; each API invocation incurs $O(1)$ overhead.

6. Principles Underlying Agentic API Integration

AGAPI-Agents operationalize enterprise API principles essential for robust agentic workflows (Tupe et al., 22 Jan 2025). Core design strategies include:

• Intent-Based and Context-Aware APIs: Endpoints interpret structured agent intent; session and context IDs reduce redundant information transfer and support asynchronous, multi-turn dialogues.
• Dynamic Discovery and Orchestration: OpenAPI/GraphQL schemas facilitate machine-readable, real-time function discovery.
• Governance and Observability: Role-based access control (RBAC), audit logging, and resource monitoring ensure operational reliability and security for autonomous agent clients.
• Event-Driven and Conversational Patterns: Support for event streams, webhook callbacks, and conversational interfaces optimize for agent-driven interaction complexity.

These patterns ensure that AGAPI-Agents can operate efficiently and securely in high-throughput, multi-step settings, maintaining clear separation between reasoning, planning, and execution.

7. Accessibility, Reproducibility, and Broader Implications

AGAPI-Agents are natively open-access, open-source, and designed for reproducibility (Lee et al., 12 Dec 2025). Deterministic execution is enforced through version control (LLMs, tools), temperature pinning, and comprehensive logging of every prompt, tool call, and answer. An OpenAPI 3.1 specification, public codebase (https://github.com/atomgptlab/agapi), and rich documentation (Jupyter/Colab examples, Python client, interactive web interface) foster transparency and replicability. This model supports community contributions (e.g., to new simulation endpoints) and broad adoption.

The AGAPI-Agents paradigm reifies lessons from related agentic architectures, including those highlighted in comparative analyses with GUI agents and hybrid agentic models (Zhang et al., 14 Mar 2025). The platform’s architecture is representative of a trend toward modular, context-aware, and standardized agent–API ecosystems, with specific implications for scalable, autonomous scientific discovery and cross-domain workflow automation (Tupe et al., 22 Jan 2025).

---

References:

• "AGAPI-Agents: An Open-Access Agentic AI Platform for Accelerated Materials Design on AtomGPT.org" (Lee et al., 12 Dec 2025)
• "AI Agentic workflows and Enterprise APIs: Adapting API architectures for the age of AI agents" (Tupe et al., 22 Jan 2025)
• "API Agents vs. GUI Agents: Divergence and Convergence" (Zhang et al., 14 Mar 2025)