Your contracts enforce themselves.

THE GAP

Three systems, one customer, no agreement.

Every B2B SaaS that sells to enterprises ends up running three systems that do not talk: the deal in a CRM, the switches in a flag tool, the deployment in a pipeline. Nothing holds them to the same answer.

THE CONTROL PLANE

One plane in the middle. Everything else keeps its job.

Your CRM still closes deals. Your billing engine still invoices. Your pipeline still deploys. Kaiten holds the one answer they need to agree on: what each customer bought, can use and runs.

WHO IT IS FOR

One model. Every team that touches the customer.

Engineering wires Kaiten in once; product, sales and customer success read the same answer. Pick a team to see what it stops doing by hand.

DevDevOpsProductSales & RevOpsAccount Manager

Developer / SDK Integrator

Integrate once. Read the contract everywhere.

“Report usage, evaluate flags, receive events — without wrestling the integration.”

The person who wires Kaiten into the SaaS. Flags evaluate through the OpenFeature SDK you already use, usage goes through one call, and every change comes back as a typed event. Types generated from your catalog and React components are on the roadmap.

Today

• Plans hard-coded as if statements across the codebase
• A flag tool and a billing tool that each hold half the answer
• Every new plan means a code change and a deploy

With Kaiten

• OpenFeature-standard evaluation: the app never couples to a vendor SDK
• One call reports usage; past the limit, a 409 the SDKs surface as a typed error
• Typed clients for Go, TypeScript and Python, generated from the OpenAPI contract

/integrations/webhooks

What Dev ships with

• Feature Flags over OFREP
• Usage Reporting
• Go, TypeScript & Python SDKs
• Event Stream & Webhooks
• MCP Server
• Service Accounts & Tokens

ONE DATA MODEL

One data model. Four pillars.

Every customer, license, flag and release in one queryable graph, behind one API. Kaiten does not replace your billing engine or your CRM — it gives them one answer to agree on.

Kaiten Edge, which will enforce the same contract inside air-gapped sites, is in private preview, by invitation. About Kaiten Edge →

HOW IT WORKS

Kaiten decides. Your code and pipelines act.

Four moments, and where each one is enforced. Kaiten never touches your clusters: it keeps the record, and your pipelines do the work.

IN YOUR CODE

A standard protocol, not a proprietary client.

Kaiten speaks OpenFeature over OFREP, so leaving does not mean rewriting your codebase. Where a typed client helps — reporting usage, reading a license — there is one for Go, one for TypeScript and one for Python.

package main

import (
	"context"
	"log"
	"os"

	sdk "github.com/kaitencloud/sdk-go"
)

func main() {
	client, err := sdk.NewClient(
		"https://app.kaiten.sh/api",
		sdk.WithBearerToken(os.Getenv("KAITEN_API_TOKEN")),
	)
	if err != nil {
		log.Fatal(err)
	}

	instances, err := client.Instances.List(context.Background(), nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("%d instances", len(instances))
}

package main

import (
	"context"
	"log"
	"os"

	sdk "github.com/kaitencloud/sdk-go"
)

func main() {
	client, err := sdk.NewClient(
		"https://app.kaiten.sh/api",
		sdk.WithBearerToken(os.Getenv("KAITEN_API_TOKEN")),
	)
	if err != nil {
		log.Fatal(err)
	}

	instances, err := client.Instances.List(context.Background(), nil)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf("%d instances", len(instances))
}

OPEN SOURCE

Your revenue gates should never be a black box.

The engine is open source under Apache 2.0 — the full control plane, the console, the event pipeline and the MCP server — and so are the SDKs and the CLI. Audit it, fork it, run it — if we disappear, your SaaS keeps working.

• ✓No billing provider, and no usage reported to us — console sign-in is the one hosted service it needs today
• ✓The hosted offer lives in a separate repository and calls the same public API you do
• ✓Go’s internal-package rule keeps the hosted layer out of the engine’s internals