Getting Started

Koios (pronounced "KEE-os") is an edge platform for industrial AI. It connects to your devices, collects data in real time, runs pre-trained machine learning models against that data, and lets you build custom logic — all on-premises, without sending data to the cloud.

The name comes from Greek mythology — Koios (Κοῖος) was the Titan of intellect and inquiry, associated with the celestial axis around which knowledge of the heavens revolved. It felt like a fitting name for a platform built to make sense of industrial data.

This page introduces the main things you can do with Koios and links to the detailed guides for each.

Data Collection: Devices and Tags

Getting data into Koios starts with two concepts: devices and tags.

A device is a connection to an external data source — a PLC, an OPC-UA server, a Modbus controller, a database, or a REST API. It defines how Koios communicates: the protocol, the hostname, the credentials, and the scan rate (how often to poll for new values). Koios supports several industrial protocols including OPC-UA, Modbus TCP, EtherNet/IP, SOAP, REST, and Microsoft SQL.

A tag is a single data point within a device — one temperature sensor, one pressure register, one database column. Tags define what to read (or write). Each device can have hundreds or thousands of tags, and each tag produces a live value that updates on every scan cycle.

The key difference: devices handle the connection, tags handle the data. You create a device to establish communication with a piece of equipment, then add tags to specify which data points you care about.

Learn more: Device Introduction | Tag Introduction | Creating a Device | Creating a Tag

Historization

Once tags are collecting data, Koios automatically records every value to its time-series database. This historization is what makes trends, AI inference, and long-term analysis possible — you get a continuous record of every data point at whatever scan rate you configure.

Koios uses Swinging Door Trending (SDT) compression by default to keep storage manageable. Values that don't meaningfully change the trend are discarded, while significant changes are always preserved. You can tune compression globally or override it per tag, and configure retention policies to manage how long data is kept.

You can export historical data as CSV, JSON, or Parquet from the Trends page — useful for analysis, reporting, or collecting training datasets for your AI models.

Learn more: Data Retention | Exporting Data

AI Models

Koios is an inference engine — it runs pre-trained models against live data, but it does not train models. You train your models externally using whatever tools and environment suit your workflow (PyTorch, TensorFlow, scikit-learn, Jupyter notebooks, cloud ML platforms), then export the trained model and upload it to Koios.

Supported Formats

Koios accepts models in two formats:

Your model file must follow specific tensor shape conventions — inputs are shaped as [1, input_depth, num_inputs] (a window of historical time steps) and outputs as [1, num_outputs]. See Model Inference Requirements for the full specification.

How Inference Works

Once uploaded, you connect the model to your data by creating bindings — mappings between the model's input/output slots and your tags. On every scan cycle, the model:

1. Reads current and historical values from its input tags
2. Normalizes them to match your training pipeline
3. Runs the model file to produce predictions
4. Writes predictions to output tags

This runs continuously at the model's configured scan rate. Models can also run in on-demand mode to synchronize with fresh device reads, or be grouped in a scan group for batched execution across multiple models.

Learn more: Model Introduction | Training a Model | Inference Requirements | Creating a Model | Assigning Bindings

Components

The component system lets you deploy custom Python logic that runs in real-time inside Koios. Components are useful for things that don't fit neatly into a pre-trained model — PID controllers, data transformations, state machines, alarm logic, custom protocol adapters, and more.

Libraries

Components are packaged into libraries — .kcl (Koios Component Library) files that you upload to Koios. Each library contains one or more component types. Koios ships with a Core Library of common building blocks (math operations, boolean logic, comparisons, signal processing), and you can build and upload your own using the Koios Component Builder.

Environments and Instances

To run components, you create an environment — an execution context with a shared scan rate. Inside the environment, you add instances of components from your uploaded libraries onto a visual canvas. Each instance is a running copy of a component type with its own configuration.

Wiring to Tags

Component instances have typed inputs and outputs. You wire these to tags (or to other component instances) on the canvas. On every scan cycle, the component engine reads all input values, executes each component in dependency order, and writes the results to output tags. This is how components integrate with the rest of the platform — they read from and write to the same tags that devices collect and AI models use.

Learn more: Component Introduction | Libraries | Environments | Canvas | Building Components

Trends

Trends are multi-tag time-series charts for visualizing both historical and live data. You can add any combination of tags to a trend, configure multiple Y-axes for different scales, and watch values update in real time.

Trends are also where you export data — select a time range, choose your format (CSV, JSON, or Parquet), and download the raw historical data for any set of tags.

Learn more: Trends | Traces & Axes | Settings & Export

System Administration

The System section provides tools for managing the platform itself:

• Users & Roles — create accounts, assign permissions, and control access
• Backup & Restore — schedule automatic backups and restore from snapshots
• Data Retention — configure storage monitoring, compression, and cleanup policies
• Services — monitor the health and status of all platform services
• System Health — track CPU, memory, and disk usage with configurable alarms
• Network Diagnostics — test connectivity and inspect network interfaces
• Logs — stream real-time service logs for troubleshooting
• API Clients — manage credentials for external system integrations

Learn more: System Overview | Licensing

Putting It All Together

A typical Koios deployment follows this flow:

Devices (connections)
  └── Tags (data points)
        ├── AI Models (inference on live data)
        ├── Components (custom real-time logic)
        └── Trends (visualization and export)

1. Connect to your industrial equipment by creating devices
2. Define the data points you care about by adding tags — and make sure they're historizing
3. Deploy pre-trained models for AI inference, or build custom components for control logic and data processing
4. Monitor everything through trends, dashboards, and the system tools