Skip to content
Get packs

Guide · Agent skill

How to use the Tellurium kinetic experiments agent skill

Updated · written with AI from the project's own documentation and checked against our catalogue data

The tellurium skill gives an AI agent a tested workflow for simulating biochemical reaction networks, such as how drug or metabolite concentrations change over time. It is written for researchers and students who have a local SBML or Antimony model and want reproducible simulation results. After this guide you will know what the skill does, how to install it, how to phrase a request that triggers it, and what files it produces.

Tellurium Kinetic ExperimentsK-Dense-AI/scientific-agent-skills · MIT

Quick start

  1. 1Download and unzip. Download the tellurium ZIP from this page and unzip it into ~/.claude/skills/ or a project's .claude/skills/ folder.
  2. 2Create the Python environment. Run uv venv --python 3.11 kinetic-env and install the pinned Tellurium, libRoadRunner, Antimony, libSBML, libSEDML and libCombine versions.
  3. 3Prepare your model and experiment. Have an SBML or Antimony model file and an experiment JSON using the documented keys and SBML species IDs.
  4. 4Ask in plain language. Describe the reaction network, the species to measure and the parameter to vary, using a request like the skill's use cases.
  5. 5Review the warnings. Check the units and validation findings in report.json before interpreting the curves.
  6. 6Verify the replay. Confirm the COMBINE archive replay differences in report.json are as expected, and repeat at stricter tolerances if small differences matter.

What is an agent skill and what does this one do?

An agent skill is a folder of instructions, scripts and reference files that an AI agent can load when a task matches the skill's description. This one, named tellurium, covers deterministic kinetic models: it simulates a reaction network from an SBML or Antimony model file using Tellurium and libRoadRunner.

The skill checks the model's SBML consistency and units, runs a baseline scenario plus scenarios with changed global parameters, and exports the exact SBML for each condition together with a SED-ML experiment and a COMBINE archive. It then replays that archive to confirm the replayed values match the direct simulation.

  • Simulates concentration time courses from SBML or Antimony models
  • Checks units and reports model warnings, including undefined units
  • Compares baseline and constant-parameter changes, each from a fresh model
  • Exports SBML, SED-ML and COMBINE archive files and writes report.json

Install the tellurium skill

Download the skill ZIP from this page and unzip it. To make it available to Claude Code for all your projects, place the folder in ~/.claude/skills/. To limit it to one project, place it in that project's .claude/skills/ folder.

In the Claude apps you can instead upload the ZIP under Settings → Capabilities → Skills.

  • Personal use across projects: ~/.claude/skills/
  • Single project: .claude/skills/ inside the project folder
  • Claude apps: Settings → Capabilities → Skills, then upload the ZIP

Set up the Python environment

The skill needs Python 3.11 and specific pinned packages: Tellurium 2.2.13.1, libRoadRunner 2.10.0, Antimony 3.2.0, python-libsbml 5.21.2, python-libsedml 2.0.34 and python-libcombine 0.2.20. The skill suggests uv for creating the environment. Network access is needed only for this installation step.

The skill's documented setup creates an environment named kinetic-env with these commands. The native wheels were tested on macOS ARM64.

  • Python 3.11 is required
  • Packages must match the pinned versions listed in the skill
  • Headless runs can set MPLBACKEND=Agg; the helper opens no plotting window
uv venv --python 3.11 kinetic-env uv pip install --python kinetic-env/bin/python tellurium==2.2.13.1 libroadrunner==2.10.0 \ antimony==3.2.0 python-libsbml==5.21.2 python-libsedml==2.0.34 python-libcombine==0.2.20

Run the included reference example

The skill ships a controlled example: a closed reaction A → B in a constant 1-L compartment, starting with A=1 and B=0 mol/L, with k=0.2 per second. The experiment file runs a baseline and a scenario with k=0.4 per second from 0 to 10 s. Run the command from the skill directory, pointing to the environment you created.

The reference output directory must be new, because existing output directories are not reused.

  • Model file: assets/first-order.ant
  • Experiment file: assets/experiment.json
  • Output: kinetic-reference directory
MPLBACKEND=Agg kinetic-env/bin/python scripts/kinetic_experiment.py \ --model assets/first-order.ant --format antimony --experiment assets/experiment.json \ --output kinetic-reference

Use your own SBML model

For your own work, give the agent an SBML file and an experiment JSON. The skill's SBML branch takes model.xml and experiment.json and writes to a new output directory. Replace the filenames with your actual inputs.

Experiment JSON must use only the documented keys: end_time, points, relative_tolerance, absolute_tolerance, species and scenarios. Species must be SBML IDs, and scenarios may only change constant global parameters.

  • Output selections must be concentration species; amount-only species are rejected
  • Zero-dimensional compartments and rate-rule models are rejected
  • Parameters with initial assignments cannot be changed by the helper
MPLBACKEND=Agg kinetic-env/bin/python scripts/kinetic_experiment.py \ --model model.xml --format sbml --experiment experiment.json --output kinetic-analysis

Trigger the skill with natural requests

You do not need to name the skill. Describe a reaction-network simulation in plain terms that match the skill's use cases: reaction-network time courses, kinetic parameters, concentration dynamics and reproducible simulation experiments. Mention your model file and what you want to vary.

Good requests say what the model is, what to measure and which parameter to change. The agent should then check units, run the scenarios and report the archive and CSV files.

  • "Simulate the concentration of species A over 10 seconds in model.xml and compare k at 0.2 and 0.4."
  • "Run this Antimony reaction model, export a SED-ML COMBINE archive, and confirm the replay matches."
  • "Check the units in my SBML kinetic model and tell me which warnings matter."

Read the outputs

Each run writes CSV curves, the exact SBML for each condition, the SED-ML experiment, a COMBINE archive and report.json. The report lists versions, checksums, parameters, units, validation findings and the differences between direct and replayed results. The libSEDML findings are parse diagnostics, not certification that every SED-ML feature works in every simulator.

  • baseline.csv and other scenario CSVs: time and selected concentrations
  • model_<scenario>.xml: the exact SBML used for each condition
  • experiment.sedml and experiment.omex: the SED-ML experiment and archive
  • report.json: versions, checksums, units, warnings and replay differences

Safety and limits

The skill runs scripts, so review them before use. It does not use the network during analysis and needs no credentials or external services. The skill itself warns that a smooth curve or zero archive-replay error does not prove that a model is valid or its parameters are identifiable, and that stochastic, event-driven, delayed or rate-rule models are not covered by its tests.

For steady-state constraint-based metabolic flux analysis, the skill directs you to cobrapy instead.

  • Runs scripts: yes. Uses network: no (except optional installation).
  • Does not clip negative concentrations to hide problems; it reports them.
  • Check solver sensitivity with stricter tolerances when small differences matter.

What people use it for

  • Compare how fast a drug or metabolite concentration falls under two rate constants
  • Run reproducible parameter sweeps and archive each condition's exact SBML and SED-ML
  • Check whether an SBML model's units and consistency warnings are safe to interpret
  • Export concentration time courses as CSV for plotting or further analysis

Frequently asked questions

Is the tellurium agent skill free?

The skill is released under the MIT licence, as listed on its page. Tellurium and the other packages it installs are separate open-source projects, each with its own licence, which you should check before use.

What do I need to use the tellurium skill?

You need Python 3.11 and the pinned packages: Tellurium 2.2.13.1, libRoadRunner 2.10.0, Antimony 3.2.0, python-libsbml 5.21.2, python-libsedml 2.0.34 and python-libcombine 0.2.20. Network access is needed only to install them. The skill suggests uv for setup.

How do I install the tellurium skill?

Download the ZIP from this page and unzip it into ~/.claude/skills/ for personal use or a project's .claude/skills/ folder. In the Claude apps, you can upload the ZIP under Settings → Capabilities → Skills.

Can the skill simulate stochastic or event-driven models?

No. The skill covers deterministic reaction-network models. Its tests do not cover stochastic, event-driven, delayed or rate-rule models, and the rate-rule case is explicitly rejected.

What should I use instead for metabolic flux analysis?

For steady-state constraint-based metabolic flux analysis, the skill itself says the task belongs to cobrapy. Use the tellurium skill for time-course kinetic simulation of reaction networks.

Why does my experiment fail or get rejected?

Common causes listed in the skill are amount-only species in the output selection, zero-dimensional compartments, rate-rule models, parameters that do not exist or are not constant, and parameters with initial assignments. Also check that the output directory is new.

New agent skills, repos and AI tools — every week

The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.

Our verdict

Use this skill if you are a researcher, student or computational biologist modelling deterministic reaction kinetics from a local SBML or Antimony file and need reproducible, archived simulations. Pick a different tool for stochastic or event-driven models, for steady-state metabolic flux analysis (use cobrapy), or for any clinical or safety decision, since a clean-looking curve does not prove a model is valid.

Download the skill