Why these terms get confused

A chemistry assistant may retrieve a PubChem record, calculate RDKit descriptors, submit a simulation, and summarize the results in one conversation. From the user's perspective, everything looks like a single capability. Underneath, different components supply data, expose functions, describe procedures, and decide what happens next.

The confusion increases when one project spans several roles. An agent framework can expose an MCP server; a hosted platform can offer a Python API; a Skill can bundle executable helpers. These labels are therefore not mutually exclusive product categories.

The useful distinction is responsibility: an API defines access, MCP standardizes exchanges with AI applications, a Skill packages procedural knowledge, and an agent coordinates task-directed actions. None of these labels alone establishes chemical accuracy, comprehensive tool coverage, or unrestricted autonomy. This guide explains classification and selection, rather than deployment architecture.

Four definitions, four different responsibilities

API—Application Programming Interface. An API specifies how software requests functionality or data and receives results. In this guide, PubChem and RCSB illustrate hosted data APIs, while Rowan illustrates access to hosted calculations. An API can also belong to a local library or framework; “API” does not necessarily mean a remote web service.

MCP—Model Context Protocol. MCP defines exchanges between an AI application's clients and servers that provide tools, resources, and prompts. The host manages client connections; a server exposes the functionality or context. The official architecture overview explicitly separates the protocol from how applications use language models or manage context. MCP is not itself a chemistry engine or planning strategy.

Skill. In the Agent Skills format, a Skill is a folder centered on SKILL.md, containing metadata and task instructions, optionally accompanied by scripts, references, or templates. A compatible host can discover relevant instructions and load them when needed. The Skill describes how to work; execution still needs suitable tools, dependencies, and permissions. Host support differs, so loading instructions does not guarantee that bundled code can run.

Agent. Here, an agent is a software system that coordinates tools and task state toward a goal, potentially choosing or revising its next action. Its behavior may be tightly constrained, human-supervised, or more flexible. Autonomy depends on implementation, available tools, approval rules, and permissions—not on the word “agent.” For further discussion of instruction packages versus coordinating systems, see Agents and Skills.

Compare the caller, executor, and planner

The table separates interface responsibilities from implementation choices. A server can perform substantial computation without deciding the overall research plan.

Layer Typical caller or consumer What it contributes Where execution happens Who decides the next step?
API Script, client library, application, or wrapper Defined operations, inputs, and responses Service or underlying software Usually the caller; the implementation may manage its internal workflow
MCP server MCP client within an AI host Discoverable tools and contextual material Server and its libraries or connected services Host/application policy; an exposed tool may itself run a workflow
Skill Skills-compatible host or agent Instructions, references, and optional helpers Whatever runtime the host can access Host/agent, guided but not guaranteed by the instructions
Agent User, application, or another coordinator Task state, orchestration, and tool selection Agent runtime plus connected executors Agent workflow, within permissions and human checkpoints
Hosted platform Browser user or API client Managed calculation environment and analysis workspace Hosted infrastructure and scientific engines User or calling workflow; internal automation depends on the service

This avoids misleading absolute statements such as “APIs cannot execute” or “agents always plan autonomously.” An API may submit a complex calculation, while an agent may follow a fixed sequence.

What the six chemistry resources actually provide

PubChem PUG REST retrieves selected chemical records, identifiers, properties, and assay information through HTTP operations. Its documented compound inputs include CID, names, SMILES, and InChI. Retrieval and structure-search operations have operation-dependent output formats. It is the hosted API, not an agent or third-party MCP wrapper.

RCSB PDB Data API retrieves structure metadata through REST and GraphQL. REST supplies fixed object representations; GraphQL selects fields and traverses relationships. Entry, entity, chain-instance, assembly, and chemical-component identifiers have different meanings. This service retrieves annotations; it does not predict structures or perform simulations. The separate rcsb-api Python client is not the hosted service itself.

RDKit MCP Server (TandemAI) exposes RDKit functions through MCP and includes an OpenAI-powered CLI client, a tool-listing utility, and an evaluation suite. Its stated ambition to expose every function in RDKit 2025.3.1 is not demonstrated coverage. Inspect the actual tool inventory before choosing it for a specific operation.

RDKit Skill (K-Dense) provides instructions for parsing, validation, descriptors, fingerprints, substructure work, and molecular manipulation. It names three Python helpers for properties, similarity screening, and substructure filtering. Those helpers require an installed rdkit package. The Skill is neither RDKit itself nor an independently running agent.

ChemGraph is an agent framework connecting natural-language requests with molecular construction, calculations, analysis, and reporting. It provides CLI, asynchronous Python, Streamlit, and MCP access. Its default single_agent workflow differs from its checkpointed main_agent, which can discover Skills and delegate to configured specialists. Available calculators depend on the environment.

Rowan is a hosted platform whose official product page lists molecular modeling, property prediction, and protein–ligand workflows. Its Python API supports scripted submission, monitoring, and analysis. These are vendor-described capabilities, not independent accuracy findings. The API is an access route to hosted engines, not evidence of a standalone local implementation.

How the layers can work together

A proposed combination is: researcher question → agent coordinator → API requests or MCP tools → scientific executor → recorded results. A Skill can guide validation and interpretation throughout that sequence; it is not necessarily another network hop.

For example, a coordinator could retrieve identifiers through PUG REST, follow RDKit Skill guidance to validate structures, and invoke a suitable RDKit MCP tool for calculations. Alternatively, a deterministic script could call the data API and RDKit directly, without either MCP or an agent.

ChemGraph documents both serving and consuming MCP tools, demonstrating that agent and interface roles can coexist. However, this does not establish interoperability with every listed resource. Connecting the specific TandemAI server, K-Dense Skill, RCSB API, or Rowan service into one workflow remains a proposed integration requiring evaluation. Current MCP documentation also does not prove that an older project implements the current protocol behavior.

Proposed example: an auditable aspirin descriptor exercise

This is a suggested evaluation, not a completed scientific test. The goal is to retrieve an aspirin structure, calculate selected descriptors, and produce a traceable report—not to establish potency or safety.

  1. Specify inputs. Use PubChem CID 2244, request the original structure, and define the intended outputs: molecular formula, InChIKey, molecular weight, LogP, and TPSA. Decide whether the exercise will preserve the retrieved representation unchanged or apply an explicitly recorded standardization policy.
  2. Retrieve evidence. PUG REST documents an SDF request for CID 2244 and a formula/InChIKey JSON request. Retain the source identifier, request, retrieval date, and original response.
  3. Choose the calculation route. Use RDKit directly under Skill guidance, or first inspect the TandemAI server's tools and schemas. Proceed through MCP only if the needed operations and molecular inputs are actually exposed. Do not invent tool names.
  4. Validate before calculating. Check parsing and sanitization. Quarantine an invalid record with its source ID and error; do not silently replace it with a guessed structure.
  5. Produce outputs. Propose a descriptor table, an input/provenance record, and an exception log. Record descriptor definitions and the installed environment. Explain any discrepancy before accepting a comparison with database properties.
  6. Gate further work. If geometry optimization becomes relevant, separately evaluate ChemGraph's available calculators or Rowan's hosted workflows. Confirm method, molecular state, charge, spin, and permissions before submission. A descriptor exercise does not automatically justify a simulation.

RCSB is unnecessary for this small-molecule exercise. It becomes relevant when a separate question requires identified protein-structure metadata; that does not establish that aspirin binds a selected structure.

Choose the smallest layer that solves the problem

For scientific-data retrieval, prefer a direct API when inputs and requested fields are already known. Choose PUG REST for supported PubChem record operations and RCSB for identified structure annotations. Natural-language orchestration adds little to a fixed retrieval task.

For cheminformatics, use a Skill when the main need is reusable procedural guidance in a compatible host. Choose an MCP server when the host needs discoverable RDKit tools, after checking actual coverage. A direct library workflow remains an alternative for controlled, repeatable calculations.

For computational chemistry, consider an agent framework when tool selection, calculation management, and reporting require coordination. Consider a hosted platform when managed submission and analysis fit the research setting. Neither choice replaces method assessment.

In ChemAI Atlas, the primary type expresses the resource's main role: apis for PubChem and RCSB, mcp for TandemAI's server, skills for K-Dense's instruction package, agents for ChemGraph, and platforms for Rowan. Secondary types can describe overlapping roles without changing what the resource fundamentally is. Task labels are editorial navigation aids, not execution guarantees.

Handle failures and scientific limitations explicitly

Separate access failures from chemistry failures. For PUG REST, respect documented limits and dynamic throttling, use bounded retries, and switch to suitable bulk retrieval rather than unrestricted per-record calls. For RCSB GraphQL, inspect response errors as well as HTTP status; missing annotations must not become invented values.

For RDKit work, retain original structures and identifiers. Canonical SMILES does not settle tautomerism, protonation, salts, or unspecified stereochemistry. Fingerprint similarity is not identity. The K-Dense helper's historical pains option contains illustrative motifs, not the published PAINS catalogue. Failed conformer generation should stop downstream optimization.

For calculations, review settings, units, convergence, and applicability. ChemGraph describes EMT as useful for setup checks rather than general high-accuracy chemistry. Its workspace shell access is not confined to the workspace, so action reviews are not a sandbox. Hosted calculation availability likewise does not demonstrate accuracy for a particular system.

Finally, inspect rights separately from access. The K-Dense Skill declares BSD-3-Clause while its repository license is MIT; clarify scope before redistribution. An accessible API or repository does not by itself establish software or data reuse rights.

Reader checklist

  • Identify the missing responsibility: data access, tool exposure, instructions, coordination, or hosted execution.
  • Confirm exact inputs, outputs, tool coverage, and dependencies.
  • Check host support and protocol compatibility rather than assuming them.
  • Define molecular-state policies and preserve original identifiers.
  • Set approval boundaries, retry limits, and stop conditions.
  • Retain results, exceptions, calculation settings, and provenance.
  • Evaluate scientific suitability independently of interface convenience.

Continue with these related guides: MCP for Chemistry: What It Is and Why It Matters · AI Agents for Chemistry: From Chatbots to Autonomous Research · AI Skills for Chemistry: What They Are and How They Work · How to Build a Chemistry AI Agent Stack.

Sources