Execute a chain of ROBOT commands in a single process.

Ontology objects pass in-memory between steps — much more efficient than writing intermediate files. Only the first step typically needs an input key and only the last step needs an output key.

Each step is a dict with:

• command: the ROBOT command name (e.g. "merge", "reason")

• All other keys are command arguments. Use the long flag name without leading dashes, with hyphens replaced by underscores.

Argument mapping rules:

• Underscores become hyphens: ontology_iri → --ontology-iri

• list values repeat the flag: {"input": ["a.owl", "b.owl"]} → --input a.owl --input b.owl

• bool values become "true" / "false" strings

• str / int values become a single flag-value pair

Example steps::

[
    {"command": "merge", "input": ["edit.owl", "base.owl"]},
    {"command": "reason", "reasoner": "ELK"},
    {"command": "annotate", "ontology_iri": "https://example.org/my.owl"},
    {"command": "convert", "format": "ofn", "output": "result.owl"}
]

Tip: to discover available flags for a command, pass "help": true in a step, e.g. [{"command": "merge", "help": true}].

Merge one or more OWL ontology files into a single ontology.

Combine multiple ontology files. Each input path or input_iri IRI is loaded and merged. Use inputs for glob patterns like "edit*.owl". By default, import closures are merged and owl:imports statements are removed.

Remove axioms from the first ontology that appear in subsequent ontologies.

Provide multiple input files: the first is the base ontology, and axioms from the remaining inputs are subtracted from it.

Add metadata annotations to an ontology.

Set the ontology IRI, version IRI, and add annotation properties. Each annotation value is a string like "rdfs:comment 'Example ontology'". Use link_annotation for IRI-valued annotations and language_annotation for language-tagged literals.

Convert an ontology between formats.

Supported formats (by extension or format flag): owl (RDF/XML), ofn (OWL Functional), omn (Manchester), owx (OWL/XML), ttl (Turtle), obo (OBO Format), json (OBO Graphs JSON). Gzip compression is supported by appending .gz to the output path.

Run an OWL reasoner to classify the ontology and check consistency.

Reasoner choices: ELK (default, fast, OWL 2 EL), HermiT (full OWL 2 DL), JFact, Whelk, EMR (Expression Materializing Reasoner), Structural. The axiom_generators flag controls which inferred axioms to assert (e.g. "SubClass EquivalentClass DisjointClasses").

Remove redundant subClassOf axioms using a reasoner.

After reasoning, some asserted subclass relationships become redundant because they can be inferred through other paths. This command strips those redundancies to keep the ontology minimal.

Relax equivalence axioms into weaker subclass axioms.

Converts EquivalentClasses axioms to SubClassOf axioms, making the ontology less restrictive while preserving the subclass hierarchy. Commonly used before reduce in pipelines like reason → relax → reduce.

Extract a subset module from a larger ontology.

Methods:

• STAR: minimal module with seed terms and direct relationships

• BOT: seed terms plus all superclasses

• TOP: seed terms plus all subclasses

• MIREOT: hierarchy-preserving extraction with upper/lower boundaries

• subset: seed terms with materialized existential relationships

Specify seed terms via term (list of CURIEs/IRIs) or term_file.

Selectively copy axioms from an ontology (inverse of remove).

Specify terms to include via term or term_file. Use select to control which related terms to include (e.g. "self parents descendants annotations"). The trim flag controls whether axioms require ALL or ANY objects in the target set.

Remove selected axioms from an ontology (inverse of filter).

Specify terms whose axioms should be removed via term or term_file. Use select to control which related terms are included in the removal set (e.g. "self descendants").

Rename entity IRIs via full replacement or prefix-based renaming.

Use mapping for individual IRI replacements (e.g. "obo:BFO_0000051 ex:partOf"). Use mappings to point to a TSV file of old→new mappings. Use prefix_mappings for bulk prefix replacement.

Execute SPARQL queries against an ontology.

Use query for pairs of query-file and output-file (e.g. ["cell_part.sparql", "results/cell_part.csv"]). Use queries with output_dir for batch execution. Use update for SPARQL UPDATE operations that modify the ontology.

Query types: ASK (true/false), SELECT (tabular CSV), CONSTRUCT (RDF). Use tdb for large ontologies to use disk-backed storage.

Check an ontology for rule violations using SPARQL SELECT queries.

Each query file should contain a SPARQL SELECT. If the query returns any results, those are violations. ROBOT exits with a non-zero code when violations are found (controllable via fail_on_violation).

Run quality control SPARQL checks and generate a violation report.

Executes a set of QC queries (default or custom profile) and reports violations at three severity levels: ERROR, WARN, INFO. Use fail_on to set the threshold (e.g. "ERROR" or "WARN").

Check ontology conformance to an OWL 2 profile.

Profiles: EL, RL, QL, DL, Full. The output contains any violations found. ROBOT exits with non-zero code if the ontology does not conform to the specified profile.

Compare two ontologies and report semantic differences.

Specify ontologies via file paths (left/right) or IRIs (left_iri/right_iri). Output formats: plain (default), pretty, html, markdown. Use labels to include human-readable entity labels in the diff output.

Compute minimal axiom explanations for inferred statements.

Useful for debugging classification issues. Modes: entailment (explain why an axiom is entailed), inconsistency (explain why the ontology is inconsistent), unsatisfiability (explain why a class is unsatisfiable).

The axiom parameter takes a Manchester-syntax axiom string like "'uvular muscle' SubClassOf 'muscle organ'".

Compute ontology metrics (entity counts, axiom counts, complexity).

Metric sets: essential (default), extended, all, reasoner-essential, reasoner-extended, reasoner-all. Output formats: tsv, csv, json, yaml, html.

Materialize inferred superclass relationships using a reasoner.

Similar to reason but focused on asserting existential restrictions. Use term or term_file to restrict which properties to materialize.

Collapse class hierarchies by removing intermediate classes.

Classes with fewer than threshold (default 2) subclasses are removed, and their subclasses are promoted. Use precious or precious_terms to protect specific classes from removal.

Expand shortcut annotation properties (macros) into OWL axioms.

Use expand_term to specify which macro properties to expand. Use no_expand_term to exclude specific properties. Set annotate_expansion_axioms to mark generated axioms.

Export ontology data to a table (CSV, TSV, JSON, HTML, XLSX).

The header defines columns using pipe-separated names like "ID|LABEL|SubClass Of". Use include to specify entity types (classes, individuals, properties). Use sort to order by column.

Mirror (cache) external ontology imports locally.

Downloads all imported ontologies to directory and generates a catalog XML file at output for offline use. Prevents network failures from breaking builds.

Fix common ontology problems.

Repairs include: updating references to deprecated classes (replacing them with their replacements), merging duplicate axiom annotations, and fixing invalid references.

Convert tabular data (CSV/TSV) into OWL ontology format.

The template file has: row 1 = headers, row 2 = template strings (e.g. ID, LABEL, SC % for subclass), rows 3+ = data. Use merge_before or merge_after to control how template output combines with the input ontology.