Every way in
Kition SDK
Free
embed (in your page or by link), script, headless, MCP · no key
Kition SDK · for developers and their 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
A person reviewsA 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.
01 · Choose your path
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).
npm i @kition/embed# 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/wasmimport { 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,
})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.
npm i @kition/embed-serverimport { 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)}`<iframe
src="https://docs.example.com/v1/open?token=ko1.…"
allow="clipboard-read; clipboard-write; fullscreen"></iframe>02 · Built for 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.
_inspectthe document as JSON, with a rendered preview on request_commandssearch the kit’s commands by keyword_runrun command steps in order, then save_checkwhat the kit finds wrong with the file_query, _batchread and edit objects through the object model_draft_readyedits go to a draft a person reviews| 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.
03 · Kits
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).
Commands per kit from the kit matrix of 2026-10-30. Formats are what each kit opens and saves.
Published today: the Note and Table kits’ packages. The other kits run here as previews; their packages are not published yet.
04 · Script
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.
/** 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
})
}// 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()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()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 one option and the people in your app edit the same file together, with presence and comments.
KitionEmbed.mount(element, {
kit, file, storage, identity,
// optional: co-editing
collaboration: { server: 'wss://sync.example.com/v1/sync' },
})06 · Built with
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 OneBuilding on the Kition SDK? Tell us and we’ll list it here.
07 · Pricing
Every way in
Free
embed (in your page or by link), script, headless, MCP · no key
Self-hosted co-editing
$3,000
per year, Business · Enterprise $15,000
Hosted co-editing
By usage
billed in credits
08 · FAQ
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.
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.
@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.
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.
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.
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.
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.
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.
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.
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.
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.