Hardwire your contracts to your clusters.

The Unified SaaS Control Plane for Engineering, Product, and Sales. Stop maintaining fragile mapping tables between your billing, your feature flags, and Infrastructure. Kaiten provides the only Control Plane that ruthlessly separates technical risk from commercial revenue.

Get Notified on OSS / GA

Billing & Invoicing

Where subscription and usage state originate.

StripeLago

CRM & Business APIs

Customer and deal context for access rules.

HubSpotSalesforceAttio

Kaiten Control Plane

Business-to-Infrastructure State Controller

Licenses & EntitlementsQuotas & Access
OpenFeatureVariant, Rollouts, A/B testing
OrchestrationDeployments, Components, Releases
Kaiten Dashboard & APItenant_id (BYO-ID)

DevSecOps Platform

Pipelines and deployment enforcement.

GitHubGitLabAzure DevOps

Customer Instance & Edge

Zero-latency Local Evaluation

OpenFeatureEntitlementsGo, Python […]

Feature Flags • Entitlements • Real-time Metering • Usage-Based Billing • Zero-Setup Analytics • GitOps Ready

The Architecture of Truth: Separate Risk from Revenue.

Licenses & Entitlements (Long-term Revenue)

Transform your commercial packaging into hard infrastructure rules. Customer access rights are dynamically calculated against their valid contract.

Feature Flags (Short-term Risk)

Decouple deployment from release. Mitigate engineering risks with short-lived toggles for progressive rollouts and operational kill-switches.

Instances (The Infrastructure)

Whether multi-tenant (Cloud) or isolated (VPC), every instance obeys the exact intersection of your Feature Flags and your Entitlements.

Stop opening Jira tickets for customer access.

While Engineering automates the infrastructure, your business teams get absolute visibility and control over the customer lifecycle via the Kaiten Dashboard.

For Product Managers

Define packaging, set entitlement limits, and trigger progressive feature rollouts independently. Stop guessing if a feature is used or begging developers for custom tracking events. You get real-time feature adoption metrics directly from actual code execution.

For Account Managers & Sales

No more blind renewals. Instantly see what a customer is actually paying for, what version they are running, and when they hit their usage quotas. Get alerted the exact second they hit their entitlement limits, empowering you to trigger data-driven upsells with absolute confidence.

For Engineering

Stop maintaining custom tracking pipelines for Stripe or Mixpanel. When you evaluate a rule at the edge (0ms latency), Kaiten automatically batches and streams the telemetry. You enforce the infrastructure; we handle the observability.

Code once. Obey the Contract.

Supported SDKs: Go | Python | TypeScript | .NET

Native OpenFeature Support via OFREP. Don't couple your core application to a proprietary vendor SDK. Kaiten natively supports the OpenFeature standard. Inject your tenant key, resolve the client, and evaluate your flags. If you ever want to leave us, you don't have to rewrite your codebase.

using OpenFeature;
using OpenFeature.Providers.Ofrep.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// 1. Configure Kaiten via the standard OpenFeature Remote Evaluation Protocol (OFREP)
builder.Services.AddOpenFeature(featureBuilder =>
{
    featureBuilder.AddOfrepProvider(options =>
    {
        options.BaseUrl = "https://api.kaiten.sh/";
        options.Headers["Authorization"] = $"Bearer {builder.Configuration["Kaiten:TenantKey"]}";
    });
});

var app = builder.Build();

// 2. Resolve the standard feature client
var featureClient = app.Services.GetRequiredService<IFeatureClient>();

// 3. Evaluate context safely. 
// Kaiten automatically intercepts this standard call to track telemetry.
// -> Product gets feature adoption metrics.
// -> Sales gets real-time usage data. No custom tracking required.
bool isMyAwesomeFeatureEnabled = await featureClient.GetBooleanValueAsync("my-awesome-feature", defaultValue: false);

Bring your own GitOps. We provide the brain.

We know your DevOps teams have built robust deployment pipelines. Kaiten doesn't try to replace ArgoCD, Flux, or GitHub Actions. It orchestrates them.

The Trigger (Webhooks): When a business event occurs (e.g., a plan upgrade), Kaiten translates this contract update into an infrastructure command and wakes up your existing pipelines.
The Ground Truth (Kaiten CLI): Once the deployment is complete, your CI/CD uses our CLI to push the actual state of the instance back to Kaiten. The loop is closed.
kaiten CLI
$ kaiten instances push-state \
    --tenant-id="stripe_cus_9876" \
    --release-version="v2.4.1" \
    --status="deployed"

Built to be a standard. Not a prison.

The core Kaiten engine (Control Plane & Data Plane) will be released under an Open Source license at the end of our Early Access program. Why? Because a critical infrastructure primitive that dictates your revenue should never be a black box.

  • Total Auditability: The code managing your access gates will be public.
  • Zero Vendor Lock-in: If Kaiten Cloud no longer meets your needs, fork the engine and run the orchestration within your own infrastructure.
Join the Open Source Waitlist