Overview

kis stands for Keep It Simple, and the name is the product strategy rather than a flourish. kis.ai is about keeping IT simple with AI: taking the accumulated complexity of enterprise technology — the services, the integrations, the compliance surface, the code nobody remembers writing — and reducing it, using AI to do the reducing.

It is an AI-native platform for building and running enterprise applications in regulated industries, on your own infrastructure, on-prem or air-gapped.

You describe what the application should do; the platform assembles it from blocks — production services for identity, data, secrets, content, AI, workflow and the rest — and generates the code that binds them together. What you maintain is configuration and the small amount of custom logic that is genuinely yours.

Keep It Simple is a philosophy, not a tagline

Simple is not the same as easy, and it is not the same as small. A simple system is one you can hold in your head, reason about, and change without fear — and staying that way under enterprise requirements takes constant, deliberate effort, because every force pushes the other way.

That effort shows up as a small number of stances the platform holds to everywhere:

Because we keep it simple	The platform
Code you did not write is code you cannot forget to maintain	Generates it from declarations, and hands you the source
A thing you can read is a thing you can review	Puts configuration in YAML with a schema, not in a UI or a database
One way to do something beats five	Routes every model call through one gateway, every secret through one vault
A part you can remove is a part you understood	Ships independent blocks, not a monolith you adopt whole
A surface you choose from can be used correctly; one you tune cannot	Prefers named choices over tuning knobs

The last one is the sharpest test, and it is why an interface here usually offers you a verb rather than a number to calibrate. It is also why these ideas are written down at length rather than assumed — see Philosophy, which is versioned separately because the principles outlive any release.

The idea: configuration over code

Every block is declared in YAML and extended with scripts where declaration runs out. That matters for three reasons that compound in regulated environments:

Less code to own. An entity definition that produces REST, GraphQL and gRPC endpoints is a few dozen lines you review once, not a service you maintain for five years. Code you did not write is code you do not have to keep correct.

It stays reviewable. YAML with a schema is diffable, lintable and auditable. A reviewer can see what a change does without reading an implementation.

No proprietary format to escape. Configuration is YAML, customisation is JavaScript, Lua, Go, Starlark or WASM, and the generated code is ordinary code — readable, and yours.

How a product fits together

   your product
        │
        ├── Meta          what the product is made of
        ├── Config        configuration and service discovery
        │
        ├── BaaS Blocks   identity, data, secrets, content, gateway,
        │                 workflows, jobs, notifications, audit, usage
        │
        ├── AI Blocks     model gateway, flows and agents, bots,
        │                 knowledge, memory, evals
        │
        └── Dev Blocks    testing, code quality, IDE support
                          — with Ops Blocks to run it all

Two dependencies are not optional. Config is how every block finds its settings and its peers, so it comes up first. Vault holds every credential — no block’s YAML contains a literal secret, only vault: references resolved at the point of use.

What is distinctive

Every model call goes through one gateway. Bot cascades, flow tasks, embeddings, memory compaction — all of it routes through AI Gateway. That is what makes per-tenant budgets, a single audit trail and a real cost story possible, and it is why no block holds a provider API key of its own.

Cost is designed in rather than discovered. AI Bot resolves most messages before a generative model is involved. Agentic loops will not compile without a budget bound. Usage measures whether the AI actually saved time instead of assuming it did.

Tenancy is structural. Isolation is enforced in storage and identity, not by a filter applied on the way out.

The supply chain is governed. Artifacts come from a registry you control, with whitelisting and revocation; source is scanned by Code Quality before it is built.

Where to go next

If you want to…	Start at
Install the toolchain	Install
Try it in five minutes, no services	Quickstart
Get something running	Getting Started
Understand the design stance	Philosophy
Browse the building blocks	Blocks
Use the command line	CLI
Look up an endpoint	API Reference