tiararodney/cire-ontology

Cloud Infrastructure Ontology

A vendor-neutral ontology of cloud infrastructure. This dataset classifies resource types, their properties, and their relationships into a shared primitive hierarchy across multiple cloud providers.

The ontology has three classification domains:

• Resources: what a thing is (e.g. Compute/VirtualMachine)
• Properties: what attributes a thing has (e.g. Network/AddressRange)
• Relationships: how things connect (e.g. Structural/ContainedBy)

Each domain uses a two-level Category/Primitive taxonomy. The taxonomy files contain all primitives with descriptions and framework references:

• resources.json (13 categories, 51 primitives)
• properties.json (8 categories, 21 primitives)
• relationships.json (5 categories, 14 primitives)

Primitives are grounded in published standards: NIST SP 500-292, TOSCA v2.0, ArchiMate 3.2, CNCF Cloud Native Landscape, DMTF CIM, TOGAF TRM, ISO/IEC 42010, and ISO/IEC 30131.

Purpose

Cloud providers have thousands of resource types in their Infrastructure-as-Code tooling. No provider uses a shared way to classify those resources, their attributes, or their relationships. Services change frequently. Manual classification is not feasible at this scale.

This dataset assigns every resource type a shared ontology label. The same label applies whether the resource comes from AWS CloudFormation, Azure Resource Manager, Terraform, or another provider. This makes it possible to do cross-provider comparison, migration reasoning, and infrastructure analysis without provider-specific logic.

The dataset is the intermediate representation (IR) for the CIRE Atomspace (Cloud Infrastructure Reasoning Engine on OpenCog Hyperon Atomspace). CIRE translates the classified entries into typed atoms in a Hyperon atomspace for formal reasoning over infrastructure.

Why coarse primitives?

The taxonomy is deliberately coarse. 51 resource primitives cover thousands of provider-specific resource types. This is a design choice, not a limitation...

The ontology feeds a Hyperon atomspace where a STRIPS-style planner generates infrastructure transformation sequences and PLN (Probabilistic Logic Networks) propagates confidence through inference chains. Both systems reason over types. A STRIPS action like "replace any Storage/ObjectStore with an EncryptedBy edge to a Security/Secret" works because it operates at the primitive level. If the taxonomy were fine-grained enough to distinguish S3 from Blob Storage from GCS, every rule and every planner action would need provider-specific variants. The combinatorial explosion makes planning intractable and rules unmaintainable.

Coarse primitives also make pattern mining useful. When the atomspace contains thousands of real infrastructure templates typed at the primitive level, the miner finds patterns like "a Compute/Function almost always has a TriggeredBy edge to an Integration/EventBus". That pattern holds across AWS Lambda, Azure Functions, and Google Cloud Functions. A fine-grained taxonomy would fragment the corpus and the miner would find provider-specific patterns instead of cross-provider ones.

Coverage

I haven't yet automated coverage statistics, so this is a roughly calculated estimate on the distribution of classifications:

Domain	Heuristic	LLM	Unclassified
Resources	0%	92%	8%
Relationships	28%	61%	11%
Properties	0%	93%	7%

Some classifications must occur manually and I already consider that within the classification pipeline, however haven't yet started doing so.

Source Data

Classifications come from provider IaC schemas. Each schema defines a resource type, its attributes, and its references to other resources.

Source	Provider	Schema Count
AWS CloudFormation	Amazon Web Services	35 regions
Terraform	hashicorp-aws	2,394
Terraform	hashicorp-azurerm	1,499
Terraform	ionos-cloud-ionoscloud	173
Terraform	stackitcloud-stackit	232
Azure Resource Manager	microsoft-azure	284 providers

Source schemas are in data/tiararodney/cire/ontology/infrastructure/source/schema/.

Generation

The CIRE Atomspace IR Generator produces all classifications. The generator uses multi-backend classifier chains with multiple independent model runs and arbitration to maximize data quality.

Model evaluation

Before running classification at scale, I evaluated multiple local LLMs on a fixed sample of 10 property classification entries. Each model received the same prompt, taxonomy, and entries. Results were compared against a reference run, which I afterwards scored manually (Poolside Laguna XS 2, a Mixture-of-Experts model with approx. 3B active parameters per token).

The evaluation focused on three metrics: classification accuracy (exact match against reference labels), average time per entry, and token efficiency.

Model	Publisher	Params	Architecture	Accuracy	Avg time/entry	Avg tokens/entry
laguna-xs.2 (ref)	Poolside	33B / ~3B active	MoE (256 experts, 8 active)	baseline	~1.2s	n/a
gemma4:31b	Google	31B	Dense	10/10	70.4s	n/a
muse-glimmer:30b	Meta	28B	Dense	9/10	33.1s	n/a
command-r:35b	Cohere	35B	Dense	7/10	30.6s	4
nemotron-3.5-lightning	NVIDIA	33B / ~6B active	MoE (128 experts, 6 active + 1 shared)	7/10	49.8s	1,540 *
nemotron-3.5-lightning (think=false)	NVIDIA	33B / ~6B active	MoE (128 experts, 6 active + 1 shared)	7/10	1.5s **	4
gemma4:26b	Google	26B / ~4B active	MoE	6/10	28.7s	1,320 ***
gemma4:26b (think=false)	Google	26B / ~4B active	MoE	6/10	1.6s ****	4
phi4:14b	Microsoft	14B	Dense	6/10	0.5s	4
devstral-small-2	Mistral	24B	Dense (multimodal)	5/10	25.6s	5
granite4.1:30b	IBM	29B	Dense	5/10	12.9s	4

Observations:

• Models below 28B parameters lacked the capacity to distinguish fine-grained taxonomy boundaries (e.g. Naming/Label vs Naming/Identifier, or Control/Toggle vs Control/Mode). phi4 (14B) was fast but consistently wrong on these edge cases.
• nemotron-3.5-lightning is an MoE model (128 experts, 6 active + 1 shared), not dense as initially assumed. With thinking enabled (the default via the OpenAI-compatible endpoint, which does not support think: false), the model generated 900 to 4,800 hidden thinking tokens per entry at 49.8s average. Retesting via the native Ollama API with think: false reduced inference to 1.5s average (0.4s per entry after initial model load) with identical accuracy (7/10). The thinking tokens added zero value for this classification task.
• devstral-small-2 is a code-focused model (Mistral). It produced minimal tokens but misclassified half the entries. Code models do not generalize well to semantic classification tasks.
• command-r:35b (Cohere) scored 7/10 at 30.6s per entry. Same accuracy as nemotron but 75x slower. Dense 35B models offer no advantage over MoE at this task.
• gemma4:26b is an MoE variant of Google's Gemma 4 family with approx. 4B active parameters per token. With thinking enabled, it generated 1,320 tokens per entry at 28.7s average and scored 6/10. With thinking disabled, accuracy remained 6/10 at 0.4s per entry (after model load). The active parameter count is too low for reliable fine-grained classification.
• MoE models can be significantly faster than dense models of similar total parameter count because only a fraction of parameters activate per token. laguna (256 experts, 8 active, ~3B active params) processes approx. 100 tok/s. nemotron (128 experts, 6 active) achieves 0.4s per entry with thinking disabled, making it the fastest model tested at 7/10 accuracy. gemma4:26b matches that speed but drops to 6/10.
• The evaluation excluded models from Non-Western vendors (Qwen, DeepSeek, Yi, and others) due to personal preference.

* Tested via OpenAI-compatible endpoint with thinking enabled (cannot be disabled via that endpoint).

** Retested via native Ollama API with think: false. Average includes model load time on first entry (11.7s); subsequent entries averaged 0.4s.

*** Tested via OpenAI-compatible endpoint with thinking enabled (default).

**** Retested via native Ollama API with think: false. Average includes model load time on first entry (12.8s); subsequent entries averaged 0.4s.

Based on these results, the classification pipeline uses laguna-xs.2 and muse-glimmer:30b as the two independent classification models, and gemma4:31b as the arbitration judge.

Multi-pass classification

Each domain uses a classifier chain that runs backends in priority order. The chain accepts the first classification that meets the confidence threshold and maps to a valid label.

Pass 1: Heuristic rules (deterministic, confidence 1.0). Known patterns in resource names, attribute names, or relationship triples map directly to primitives. For example, a relationship attribute vpc_id maps to Structural/ContainedBy without calling an LLM.

Pass 2: LLM classification (low temperature). The model receives the flat list of Category/Primitive labels and the entry to classify. It returns only the label. No reasoning, or scaffolding. This keeps responses short and format-reliable.

Pass 3: Emotive reasoning (higher temperature). The model receives the entry and the classification from pass 2. It produces emotive reasoning: strong conviction when certain, visible hesitation when unsure. This pass exists only to generate scoreable text.

Pass 4: NLI confidence scoring (local model). A local DeBERTa zero-shot model scores the reasoning text from pass 3 against "certain" vs "uncertain". This gives a confidence score that is independent of the LLM. The score reflects how convincingly the model can justify its own answer, not whether the answer is correct.

The multi-pass design keeps token consumption low. Not all entries reach the LLM. Heuristic rules (pass 1) handle entries with known patterns at zero token cost. The fraction that reaches the LLM varies by domain.

For entries that reach the LLM, pass 2 uses about 265 tokens (the label list in the system prompt is the largest part, with about 5 tokens of output). Pass 3 adds about 125 tokens for entries that received a valid classification. The LLM classifies almost all entries it receives, so the effective cost is about 390 tokens per LLM entry.

Arbitration

Two independent classification runs use different models. A third model acts as a blind judge to resolve disagreements.

Why two runs: A single model run can have systematic biases. A model might consistently misclassify a class of resources because of how it was trained (this surfaced multiple times during evaluation with low temperature settings). A second run with a different model catches these biases when its classifications disagree.

Why a blind judge: The judge receives only the entry identity, the two candidate labels, and the taxonomy descriptions. It does not see the reasoning from either run. This prevents conviction bias, where confident but wrong reasoning persuades the judge. The judge decides based on what the entry is, not on how well either model argued.

Agreement handling: When both models agree on a label, the entry passes through without arbitration. Agreement between two independent models is a strong signal.

Provenance: Every arbitrated entry keeps full provenance inline. The output record contains both candidates' model, label, confidence, and timestamp, plus the judge's decision.

Token consumption

The multi-pass approach with narrow outputs uses far fewer tokens than a single-pass approach that generates reasoning before the answer. Output tokens per LLM entry are about 65 (5 from pass 2, 60 from pass 3). A single-pass approach with reasoning-first would use about 150 output tokens per entry. The saving compounds across tens of thousands of entries.

Schema

The full schema is in schema.json (JSON Schema 2020-12).

Each JSONL file contains one entry per line. An entry has these fields:

Field	Description
label	Two-level classification: Category/Primitive
confidence	0.0 to 1.0. For deterministic classifiers: 1.0. For LLM classifiers: NLI score
ecosystem	Source ecosystem (e.g. terraform-hashicorp-aws, aws-cloudformation)
classifier_type	Which backend produced the entry (prefix, llm, manual, edge-prefix, edge-llm)
classifier_meta	Backend-specific metadata (model, NLI model, prompt hash, or rules hash)
reasoning	Raw reasoning text from pass 3. Null for non-LLM classifiers
timestamp	UTC timestamp of classification

A null entry means no classifier could map that resource type, property, or relationship to the taxonomy.

Files

Classified output is organised by pass and domain under data/tiararodney/cire/ontology/infrastructure/classified/<pass>/schema/. Each region or provider directory contains up to three JSONL files:

• resources.jsonl for resource classifications
• relationships.jsonl for relationship classifications
• properties.jsonl for property classifications

Use the resources, relationships, or properties config to load a single domain. Each config exposes one split per classification pass (e.g. pass-1, pass-2).

Ecosystems

Current and planned coverage:

• Amazon Web Services (CloudFormation)
• Amazon Web Services (Terraform)
• Microsoft Azure (Terraform)
• Microsoft Azure (Azure Resource Manager)
• IONOS Cloud (Terraform)
• STACKIT Cloud (Terraform)
• Google Cloud (Terraform)
• Google Cloud (Deployment Manager)

NOTE: Input data quality of most Terraform specifications is bad (flaky documentation, namespacing inconsistencies). This dataset treats each provider as a separate ecosystem and does not enhance data quality through cross-referencing (e.g. CloudFormation to Terraform). For a stronger signal on correctness, cross-reference resources as a post-processing step.

Intended Uses

• Train or evaluate infrastructure-aware ML models
• Cross-provider resource mapping for migration tooling
• Infrastructure ontology research
• IaC static analysis and linting
• Input data for formal reasoning systems (Hyperon atomspace, knowledge graphs)

Limitations

• Some resource types, properties, and relationships have no mapping and appear as null entries.
• LLM classifications depend on the model and prompt. Confidence scores show reasoning certainty, not classification correctness. Until a real-world cloud council commences, that is just the reality of the classification...
• Property classifications do not distinguish between input attributes (configurable) and output attributes (computed after creation). This distinction is available in the source schemas.

Energy and Cost

This dataset requires sustained GPU inference. The numbers below should give an idea of what it takes me to generate and maintain the dataset...

Hardware: I'm using two NVIDIA V100 32GB GPUs (64GB VRAM total) in a local server. Total peak system draw during inference (GPUs, CPU, fans, networking, etc.) is approx. 600W, or 0.8 kWh with overhead.

Throughput: At approx. 830 entries per hour (4 workers, single model), one classification pass over AWS CloudFormation (approx. 23,000 entries across three domains) takes roughly 28 hours. Full coverage of all providers with two independent model runs and arbitration takes approx. 10 to 14 days of continuous inference.

Energy: Two weeks of continuous operation consumes roughly 270 kWh. At my residential electricity rate of 0.31/kWh EUR, the total energy cost is approx. 84 EUR per full generation run.

Comparison with cloud inference: An equivalent run on cloud GPU instances (e.g. NVIDIA A100 at 2 USD/hour) would cost roughly 670 USD for the same workload. A faster GPU does not proportionally reduce wall time for this task. The bottleneck is sequential token generation per entry, not batch throughput. Each entry requires multiple LLM passes with short outputs (5 to 60 tokens). The time to generate 5 tokens is dominated by the model load latency and prompt evaluation, not by how fast the GPU can decode... An A100 is roughly 2 to 3x faster per entry than a V100 for this workload, but not 7x. The cost difference however: 84 EUR in electricity vs ~340 USD in cloud rental for the same result. Local hardware also reduces the marginal cost of re-runs, taxonomy revisions, and new provider onboarding to the cost of electricity only.

Carbon: At the German grid average of 380 g CO2/kWh (2024), one full run produces around 103 kg CO2. This is comparable to a single economy-class flight of 600 km. I source my electricity through ENTEGA, a German provider of 100% renewable energy tariffs.

License

This dataset is licensed under Creative Commons Attribution-ShareAlike 4.0 International (CC BY-SA 4.0).

You are free to share and adapt this dataset for any purpose, including commercial use, as long as you give appropriate credit and distribute derivative works under the same license.

Sponsoring

This dataset is free (free, as in libre), generating it is not.

Each full classification run costs me around 84 EUR in electricity and takes 10 to 14 days of continuous GPU inference. That is almost 10 Döner Kebaps and 0.5cm of hair growth... If this dataset is useful to you and you have compute to spare, consider supporting this effort:

Access to GPU instances for running classification passes cuts the biggest cost directly. Contact me if you can provide GPU time.

Contact: tiara@byteb4rb1e.me