κοινή (Old Greek for Koine) comes from ancient Greek, meaning “common” or “shared.” It was used to describe a language understood across regions and cultures. You might wonder, what relationship has that with technology? Well, let's have a look at Continuous Integration and Delivery(CI/CD).
The Problem with tool-coupled pipelines
In CI/CD, we never really reached that level of abstraction. Pipelines are still directly connected to the tools that execute them. A deployment step is written for a specific CD system, a scan step for a specific security tool, and notifications for a specific communication platform. The structure of a pipeline is largely determined by the toolchain behind it.
In practice today, a deployment step is tightly coupled to a specific tool. A GitHub Actions workflow might call a deployment action, while another team uses a Jenkins pipeline with a completely different plugin. The outcome is comparable, but the implementation is not interchangeable. Moving between those setups means rewriting the pipeline logic, even though the underlying action, such as deploying a service, has not changed. In a model like Koine, that step would be expressed as a function. The pipeline defines the action, and the execution layer resolves how that action is carried out.
This idea was introduced in one of the CDF ambassadors' meetings by Dadisi Sanyika (CDF Governing Board), and is still under investigation and development.
Why pipelines break when tools change
That limitation becomes visible the moment something changes. Replacing a tool is rarely just a configuration change. It usually means rewriting parts of the pipeline, because the logic is not expressed independently from the implementation. What should be stable delivery behavior is mixed with tool-specific integration details.
In other parts of software engineering, this problem has already been addressed. APIs introduced a contract between consumers and implementations. As long as the contract remains stable, the underlying system can change without affecting the consumer. That separation is largely missing in CI/CD pipelines, where most interactions still happen directly against tool APIs.
Introducing a contract layer for CI/CD
The idea behind Koine is to explore what happens if that separation is introduced into the delivery process itself. Instead of pipelines integrating directly with tools, they express intent through a set of functions that represent common delivery actions. The pipeline describes what needs to happen, while an execution layer determines how and with which tool that action is performed.
This shifts the responsibility for tool selection and integration away from the pipeline definition. A deployment step no longer needs to know which CD system is used. A scan step does not need to be aware of a specific security product. The pipeline interacts with a contract, and the execution layer resolves that contract to an actual implementation.
This concept is currently being explored within the community around the Continuous Delivery Foundation. The material is not publicly available and is still evolving. What can be discussed is the underlying idea, which addresses a structural issue seen in many environments.
How this relates to existing approaches
There are clear parallels with existing approaches. GitOps introduced declarative deployment models, but remains tied to specific controllers and ecosystems. Platform engineering abstracts infrastructure and developer workflows, but often leaves pipeline behavior coupled to tools. Event-based standards describe state changes, but do not define a uniform way to express actions.
What makes this hard
Introducing a contract layer for delivery actions raises a number of questions. Not every action can be standardized without ambiguity. Security context, authorization, and policy enforcement differ between environments. State management and side effects need to be handled consistently. In multi-tenant environments, routing and isolation add further complexity.
At the same time, the current situation shows consistent patterns. Pipelines become harder to maintain as integrations grow. Tooling decisions influence pipeline design more than necessary. Migrating between tools requires rework that is not directly related to the delivery process itself.
A Direction, not a solution
Koine does not provide a finished answer to these problems. It is better understood as an exploration of a different model, where pipelines are written against a shared contract instead of a collection of tool-specific integrations.
Special thanks to Dadisi Sanyika, CDF Governing board chair, for his useful insights and one of the contributors to this initiative.
.png)
