Kyvos: A Developer-Friendly Semantic Layer for Modern Engineering Teams

For data engineering teams, a semantic layer cannot be a UI-driven modeling tool that sits off to the side of the real software development lifecycle. They expect semantic logic to behave exactly like source code: versioned in Git, reviewed through pull requests, validated in automated pipelines and deployed with confidence.

Kyvos embraces this philosophy directly. It treats every element of the semantic layer—data source definitions, schemas, conversational metadata, governance rules and security configurations—as artifacts that engineers can manage programmatically.

What emerges is a semantic layer designed for analytics consumers as well as engineers who build and operate the data platform.

End-to-End Automation of BI-Ready Semantic Models

Kyvos enables engineering teams to construct semantic models entirely through APIs, starting from the moment data is connected to the platform. Connections, datasets and schema registrations can all be created through programmatic interfaces, ensuring deterministic onboarding of new data without manual intervention.

Once data is registered, engineers define the entire semantic model in the same automated fashion. Every detail can be pushed through APIs, be it schema design, dimensions, hierarchies, measures, KPIs, derived attributes or even processing logic. This leads to a software-development workflow, where semantic definitions live in Git, follow review workflows and move through environments in a controlled, traceable pipeline.

Users can create a perspective or semantic model as well as save, update, delete or process the semantic model easily. Engineers can trigger full builds, incremental refreshes or targeted updates through scripts, schedulers or orchestration frameworks. Kyvos ensures these automated builds remain consistent and fast, making them safe to embed in nightly runs or CI workflows without jeopardizing performance.

Administrative APIs: Security, Governance and Observability

Kyvos exposes extensive administrative APIs that give engineering teams full control over governance and operational workflows. User provisioning, role assignments, user group management and permissions can all be handled programmatically, integrating cleanly with enterprise IAM systems.

Security policies, such as row-level filters and column-level masking, are also API-driven, allowing organizations to treat data protection rules as deployment-ready code. This enables consistent enforcement across environments and supports change-review processes before promoting new security rules into production.

Operational observability isn’t limited to cluster health or system uptime. Kyvos exposes rich performance telemetry—query latency, aggregate usage, build durations, user activity and model-level usage—directly through its REST APIs. Engineering teams can pipe this data into monitoring systems or custom dashboards to identify regressions, validate deployments or track adoption. Field lineage APIs further provide traceability from semantic fields back to their underlying sources, enabling proper impact analysis before any upstream schema modification is deployed.

Adding new user groups in Kyvos

AI-Ready Semantics with Context Metadata

As organizations adopt natural language analytics and AI agents, the semantic layer must evolve into a context engine. Kyvos supports this shift by allowing conversational metadata and contextual definitions to be managed via APIs, too.

Developers can enrich models with entity mappings, domain-specific vocabulary, synonyms, descriptive metadata and other structures that help AI systems interpret business meaning accurately. This context is imported and exported through APIs, enabling teams to version-control AI metadata along with the semantic model itself.

This approach ensures that AI agents, LLM-based analytics tools and BI dashboards all resolve queries through the same governed semantic foundation, avoiding the drift that often emerges when AI metadata is managed manually.

Querying APIs for Applications

As Kyvos is built for engineering workflows, it offers multiple programmatic interfaces for interaction across the data and analytics stack. REST APIs provide flexible programmatic experience and the most complete capabilities, covering lifecycle management, metadata operations, processing triggers, governance actions and query execution. They support operations on metadata objects, like workbooks and worksheets. Developers can programmatically load, rename, copy or move worksheets, adjust workbook parameters or embed semantic models directly into workbook definitions. These APIs are ideal for CI/CD workflows, orchestration tools and custom services.

For SQL-driven applications and mainstream BI tools, Kyvos exposes a JDBC interface that presents the semantic model through a standard SQL surface. Queries run as SQL, while Kyvos applies governed semantics—hierarchies, relationships, measures and access controls—behind the scenes.

Kyvos also supports an OLAP4J interface for systems that depend on true multidimensional analysis. OLAP4J enables MDX-style, cube-native querying, allowing clients to navigate hierarchies, levels and members exactly as they would in a traditional OLAP engine. It is intentionally scoped to query execution only, without lifecycle or metadata operations.

How to Build a CI/CD Workflow Around the Semantic Layer

Every artifact in Kyvos, from semantic models to contextual metadata, security rules and configuration objects, can be exported and imported. As a result, engineering teams can build fully automated continuous integration/continuous delivery (CI/CD) pipelines around the semantic layer.

A common pattern begins by storing all semantic and contextual definitions in Git. A pull request triggers CI tasks that validate schema changes, check lineage, run aggregation-plan verification and ensure that security rules remain consistent. Approved changes generate CAB files—a single deployable bundle with exported semantic artifacts—that represent a complete semantic state. CD pipelines then import these artifacts into staging or production, after which automated monitoring checks build completion, query responsiveness and adoption patterns.

The result is a semantic layer that behaves as a first-class citizen in the software delivery lifecycle. Instead of being an isolated modeling tool, it’s an engineered component of the data platform.

Looking Ahead - A Semantic Layer Designed for Developers

Kyvos provides an API-first foundation that enables teams to build semantic logic with the same rigor they apply to application development. It supports automated model construction, AI context engineering, administrative control, multilayered querying interfaces and full CI/CD integration, moving semantics out of the UI and into software pipelines.