---
title: "Kition SDK — real editors in your app, the same files for your AI agents"
description: "Embed a kit’s editor in your page with npm i @kition/embed or by a signed iframe link, script the same files in Node or headless, and let Claude, Cursor or any MCP client edit them with the same engine. Open source (Apache-2.0), free, no key. 16 kits: Note and Table are published, the rest are live previews."
canonical: "https://developer.kition.ai/"
---

> Canonical HTML: [https://developer.kition.ai/](https://developer.kition.ai/)

Kition SDK · for developers and their agents

# Real editors in your app. The same files for your AI agents.

Embed a kit’s editor in your page with one npm package or by a signed iframe link, script the same files in Node or headless, and let agents edit them over MCP: one engine per kit, free, no key.

`npm i @kition/embed`

[Connect your agent](https://developer.kition.ai/agents) [Open playground](https://developer.kition.ai/playground)

1.  Write up the weekly sync, tick off the finished actions and comment on one decision.
2.  note\_inspect { path: "weekly-team-sync.md" }
3.  the document as JSON: a new file
4.  note\_run { path: "weekly-team-sync.md", draft: true, steps: \[
5.  **note.write** markdown: ---\\ndate: 2026-11-09\\nprojec…
6.  \] }
7.  1 command run in the draft · preview
8.  note\_run { path: "weekly-team-sync.md", draft: true, steps: \[
9.  **tasks.list**
10.  **task.toggle** line: $before.tasks.0.line, done: true
11.  **task.toggle** line: $before.tasks.3.line, done: true
12.  \] }
13.  3 commands run in the draft · preview
14.  note\_run { path: "weekly-team-sync.md", draft: true, steps: \[
15.  **property.set** key: status, value: reviewed
16.  \] }
17.  1 command run in the draft · preview
18.  note\_run { path: "weekly-team-sync.md", draft: true, steps: \[
19.  **comment.add** quote: Older data is dropped on la…, body: Should we keep the last vie…
20.  \] }
21.  1 command run in the draft · preview
22.  note\_check { path: "weekly-team-sync.md", draft: true }
23.  the kit’s diagnostics for the draft
24.  note\_draft\_ready { path: "weekly-team-sync.md" }
25.  state: ready
26.  Draft ready — a person reviews and merges

weekly-team-sync.mddraft · ready for review

![Weekly Team Sync, as the Note kit rendered it: Comment on the offline-data decision](https://developer.kition.ai/assets/4-V0ibgblc.webp)A person reviews

4 / 4 · Comment on the offline-data decision

A recording, not a live agent: the kit commands and the pictures the kit rendered come from a kition-showcase sample, sent here as the KHP calls an agent makes. note/weekly-team-sync · 6 commands · commit 2537034c4d

## Kition SDK in numbers

-   16kits: an editor, its engine and agent tools for each kind of file.[See the kits](#dev-editors)
-   5,626commands across the 16 kits, from the kit matrix of 2026-10-30.
-   30/30multi-turn slide edits clean with KHP, vs 18/30 with flat MCP tools, in a published pilot benchmark.[kitharness.org/benchmark](https://kitharness.org/benchmark/)
-   Freeno key, in development and in production.
-   Apache-2.0the Kition SDK and the Note kit are open source, on GitHub.[github.com/KitionAI/kition-sdk](https://github.com/KitionAI/kition-sdk)

Works withReactVueSveltePlain JSNodeNext.jsClaudeCursorAny MCP client

01 · Choose your path

## Pick a way in

[All docs](https://developer.kition.ai/docs)

Two ways to put a real editor in your product, on your storage and your users: mount it in your page, or frame a signed link from the embed server you run.

Mount the editor on an element of your page; co-editing and your agent in the open document come with it. The steps use Note, one of the two kits whose packages are published (Note and Table).

1.  **Install**One package for the page, no dependencies.
    
    `npm i @kition/embed`
    
2.  **Host the kit package on your CDN**Static files: the editor and its WebAssembly engine. Put them on your CDN, on an origin that is not your page’s, so the sandboxed editor cannot reach your page’s cookies or storage; the browser downloads them from there when someone opens a file.
    
    terminal · kition-note release
    
    ```
    # 1. the Note kit package, from kition-note's release
    curl -LO https://github.com/KitionAI/kition-note/releases/download/package-v0.1.0/kition-note-0.1.0.tgz
    tar -xzf kition-note-0.1.0.tgz
    # → note-ui/: index.html, assets/, engine/ (the .wasm), fonts/
    
    # 2. upload note-ui/ to your CDN, object storage or static host,
    #    on an origin that is not your page's, e.g.
    #    https://cdn.example.com/kition/note-ui/
    
    # 3. check the engine is served as WebAssembly
    curl -sI https://cdn.example.com/kition/note-ui/engine/kition_note_kit_bg.wasm | grep -i content-type
    # content-type: application/wasm
    ```
    
3.  **Mount**Point kit.url at that folder. One call on an element; reads and writes go through your storage.
    
    embed.ts · docs/sdk/embed.md
    
    ```
    import { KitionEmbed } from '@kition/embed'
    
    const editor = await KitionEmbed.mount(element, {
      kit: {
        id: 'kit.note',
        // static files on your CDN: the editor and its WebAssembly engine
        url: 'https://cdn.example.com/kition/note-ui/',
      },
      file: { id: 'plan-2026', name: 'Plan.md' },
      // your StorageProvider:
      // read, stamp, write (versioned), create
      storage,
      // your IdentityProvider:
      // token, user, users, permissions
      identity,
    })
    ```
    

[Read the quick start](https://developer.kition.ai/docs/quick-start) [Compare the two ways](https://developer.kition.ai/embed)

Your page holds one iframe. The embed server you run shows the editor and reads and saves the file through signed callbacks to your storage. Single-user.

1.  **Run the embed server**On your server, with Node 20.6 or later; or with no code, npx @kition/embed-server and a config file.
    
    `npm i @kition/embed-server`
    
2.  **Sign a link**For one person and one file, with edit, comment or view from your own permissions.
    
    your server · docs/sdk/url.md
    
    ```
    import { signOpenToken } from '@kition/sync/openToken'
    
    const token = await signOpenToken({
      iss: 'acme.app', aud: 'docs-example', tenant: 'acme',
      sub: user.id, name: user.name,
      file: 'res-42',            // your immutable file id
      version: 'v7',             // the version you open
      doc_key: 'res-42.g3',      // the file's generation: change it when the file is replaced
      perms: { edit: true, comment: true, download: true, share: false, export: true },
      watermark: null,           // or { text: 'Ann · Confidential' }
      iat: now, exp: now + 300,  // at most an hour; a few minutes is enough
    }, 'acme-1', privateKey)
    const src = `https://docs.example.com/v1/open?token=${encodeURIComponent(token)}`
    ```
    
3.  **Frame it**Answer the signed HEAD, GET and PUT callbacks; the editor saves through them.
    
    your page · docs/sdk/url.md
    
    ```
    <iframe
      src="https://docs.example.com/v1/open?token=ko1.…"
      allow="clipboard-read; clipboard-write; fullscreen"></iframe>
    ```
    

[Embed by link](https://developer.kition.ai/url) [Read the guide](https://developer.kition.ai/docs/url)

02 · Built for agents

## Agents edit the same files

[Kits for agents](https://developer.kition.ai/agents)

Every kit is an MCP server with basic KHP support. Your agent inspects the file, runs real commands, works in a draft and checks its own output, so a person reviews a finished change.

-   `_inspect`the document as JSON, with a rendered preview on request
-   `_commands`search the kit’s commands by keyword
-   `_run`run command steps in order, then save
-   `_check`what the kit finds wrong with the file
-   `_query, _batch`read and edit objects through the object model
-   `_draft_ready`edits go to a draft a person reviews

**Multi-turn slide edits, 30 runs each**Each run revisits earlier slides. p = 0.0001.

-   KHP tools
-   Flat MCP tools

**Runs that finished clean**

KHP tools

30 of 30

Flat MCP tools

18 of 30

**Runs that damaged other content**

KHP tools

0 of 30

Flat MCP tools

12 of 30

Show as a table

| Runs out of 30 | KHP tools | Flat MCP tools |
| --- | --- | --- |
| Runs that finished clean | 30 | 18 |
| Runs that damaged other content | 0 | 12 |

Pilot results from khp-bench, run by KHP’s maintainer: [method, limits and how to reproduce](https://kitharness.org/benchmark/).

03 · Kits

## Real editors, not viewers

Each kit is a professional editor and the engine behind it, for one kind of file. Put it in your product with one `KitionEmbed.mount` or one signed iframe link, on your storage and your users. Professional depth: hundreds of commands per kit (photo 770, film 622, doc 479).

-   Package published
-   Preview, live on this site
-   Preview

Commands per kit from the kit matrix of 2026-10-30. Formats are what each kit opens and saves.

[

NotePackage published

119commands

.md.markdown.html.pdf

](https://kition.ai/kits/note)[

TablePackage published

54commands

.ktable.csv.md

](https://kition.ai/kits/table)[

PhotoPreview · live here

770commands

.psd.psb.kphoto.png.jpg.tiff.webp

](https://kition.ai/kits/photo)[

DocPreview · live here

479commands

.docx.pdf.png

](https://kition.ai/kits/doc)[

SheetPreview · live here

328commands

.xlsx.pdf.csv.html

](https://kition.ai/kits/sheet)[

SlidePreview · live here

246commands

.pptx.kslide.pdf.png.jpg

](https://kition.ai/kits/slide)[

VectorPreview

682commands

.kvector.svg.ai.eps.pdf.png

](https://kition.ai/kits/vector)[

FilmPreview

622commands

.kfilm.mp4.mov.webm

](https://kition.ai/kits/film)[

MotionPreview

619commands

.kmotion.mp4

](https://kition.ai/kits/motion)[

DesignPreview

510commands

.kdesign.fig.sketch.svg.png.jpg.pdf

](https://kition.ai/kits/design)[

LayoutPreview

431commands

.klayout.idml.pdf.png.jpg.html.epub

](https://kition.ai/kits/layout)[

ScenePreview

311commands

.kscene.glb.gltf.fbx.usdz.obj.stl.png

](https://kition.ai/kits/scene)[

CadPreview

305commands

.dxf

](https://kition.ai/kits/cad)[

PdfPreview

98commands

.pdf

](https://kition.ai/kits/pdf)[

BoardPreview

47commands

.kboard.png.svg.pdf

](https://kition.ai/kits/board)[

HtmlPreview

5commands

.html.htm

](https://kition.ai/kits/html)

Published today: the Note and Table kits’ packages. The other kits run here as previews; their packages are not published yet.

04 · Script

## Same engine everywhere

[Scripts and headless kits](https://developer.kition.ai/headless)

One engine per kit, in the browser, in Node, on a server and behind MCP: the same open, edit, check and export. Write a script against the object model once. The same script runs in a page, in Node, and headless.

review.mjs · the shared script

```
/** Adds a review section with a task, puts "Q3 " before its heading, and checks the task off. */
export async function quarterlyReview(note) {
  return note.run(async (context) => {
    // A command with domain logic: the kit appends a section at the end of the note.
    context.commands.run('block.append', {
      markdown: '## Quarterly review\n\n- [ ] Share the revenue numbers',
    })
    const root = context.root
    root.load(['body'])
    await context.sync()
    // ... find the section, insert "Q3 " before its heading,
    // check its task off, then sync
  })
}
```

**In a page**

main.ts · @kition/embed

```
// an editor mounted with model: true
const note = await editor.document(noteKit, {
  origin: {
    kind: 'extension',
    principal: 'example:quarterly-review',
  },
})
const result = await quarterlyReview(note)
note.close()
```

**In Node**

run-node.mjs · WebAssembly engine

```
import { openKitPackage } from '@kition/script/node'

const notes = await openKitPackage(join(kits, 'note-ui'))
const file = notes.create('Review.md')
const note = await file.model()
const done = await quarterlyReview(note)
const bytes = file.save()
```

**Headless**

run-headless.mjs · native kition-note

```
import { openHeadless } from '@kition/script/node'

// kition-note, through kition-kits serve
const file = await openHeadless(binary, path)
const note = await file.model()
const done = await quarterlyReview(note)
await file.save()
await file.shutdown()
```

05 · Collaboration

## Add co-editing

[Kition Server and Kition Cloud](https://developer.kition.ai/collaboration)

kition-sheet · Sales.xlsx · 2 editing

Add one option and the people in your app edit the same file together, with presence and comments.

embed.ts

```
KitionEmbed.mount(element, {
  kit, file, storage, identity,
  // optional: co-editing
  collaboration: { server: 'wss://sync.example.com/v1/sync' },
})
```

-   Real-time co-editing through Kition Server or Kition Cloud.
-   Kition Server: free for up to 8 people, no key.

06 · Built with

## Built with the Kition SDK

### Kition One

Kition One is built on the Kition SDK. A team workspace on your own servers: every editor in it is a kit from this SDK, with accounts, spaces, permissions and backups on top.

[See Kition One](https://one.kition.ai/)

Building on the Kition SDK? [Tell us](https://kition.ai/contact) and we’ll list it here.

**Kition One**the team workspace

**Kition SDK**

**Kition Server**real-time rooms, presence, sync

07 · Pricing

## Kits are free

[Full pricing](https://developer.kition.ai/pricing)

Every way in

### Kition SDK

Free

embed (in your page or by link), script, headless, MCP · no key

Self-hosted co-editing

### Kition Server

$3,000

per year, Business · Enterprise $15,000

Hosted co-editing

### Kition Cloud

By usage

billed in credits

08 · FAQ

## Questions

Can I embed the editor without a module in my page?

Yes. Two ways to embed a kit’s editor: in your page with @kition/embed, or by link with @kition/embed-server. Both are free, open source and need no key. By link, your server signs a link for one person and one file, your page frames it, and the embed server you run reads and saves the file through signed callbacks to your storage. Co-editing, your agent in the open document and draft review come with @kition/embed in your page; embedded by link, the editor is single-user.

What is the licence?

Every use of the Kition SDK is free, in development and in production, and needs no key. Apache-2.0: the Kition SDK and the Note kit are open source, on GitHub. Published today: the Note and Table kits’ packages. The other kits run here as previews; their packages are not published yet. Real-time co-editing is the paid part: Kition Server on your own machines, or Kition Cloud, by usage.

Which packages are on npm?

@kition/embed, @kition/script and @kition/embed-server, with @kition/sync and @kition/kdm under them. A kit package is not an npm package: it is a static folder you host, and Note’s and Table’s are on kition-note’s and kition-table’s GitHub releases. The MCP launcher @kition/kits-mcp is on npm too; without npm, each SDK release on GitHub has kition-kits-mcp and the kits’ executables for macOS, Linux and Windows, with their SHA-256 sums.

Where are the kits hosted?

On your CDN. A kit package is static files, the editor and its WebAssembly engine, that you host on your own CDN, on an origin apart from your page. The browser downloads it from there when someone opens a file, not from a Kition server. Kition does not host kit packages for your product: Note’s is on kition-note’s GitHub releases, ready to unpack and upload. This site’s demos load theirs from kits.kition.ai, which only this site may frame.

How do AI agents use it?

Every kit is an MCP server with basic KHP support. Your agent connects to kition-kits-mcp, a stdio server on a workspace folder, and inspects, edits and checks files there with the same engine as the editor. With drafts on, its edits go to a draft that a person compares and merges.

How big is it?

In your page, @kition/embed is about 90 KB. The Note kit package is about 22 MB the first time someone opens a note, most of it the WebAssembly engine and fonts, then it comes from the browser’s cache. The browser downloads a kit package from your CDN only when a person opens a file of that kind; in this site’s live demos a kit and its sample take about 22 to 37 MB the first time. The replay at the top of this page loads none of that.

Which browsers does it support?

Current desktop browsers. The editors run WebAssembly in a worker inside an iframe, so the page and the kit origin must allow scripts, workers and WebAssembly; the embed reference lists the exact headers.

Does it work offline?

Single-user editing needs no Kition service at all: the editor reads and saves through your storage. With co-editing, edits made while offline sync when the connection comes back.

How is the editor sandboxed?

Each kit runs in a sandboxed iframe from the kit origin. The handshake is pinned to that origin, and after it everything travels over a private MessagePort. Your identity tokens, the sync connection and your storage stay in your page; the kit sees only its own document.

Does it work with server-side rendering?

Yes. KitionEmbed.mount is a browser DOM call: render the element on the server, then mount the editor into it on the client (in a useEffect, onMounted or the framework’s equivalent). Scripts and headless kits run in Node.

How are versions handled?

The SDK has one version, recorded in each package. Each npm package keeps its own semver, and each kit package is a pinned version. The protocols have their own versions: a minor SDK release adds features, a major one breaks a contract.

## Get notified

One email when a new kit is published, then the occasional big release. No spam.

EmailWhat are you interested in? (optional)Interested in… (optional)The desktop appKition One for teamsKits for developers
