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.

  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 decisionA 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
  • 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
  • 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
Works withReactVueSveltePlain JSNodeNext.jsClaudeCursorAny MCP client

01 · Choose your path

Pick a way in

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. InstallOne package for the page, no dependencies.
    npm i @kition/embed
  2. Host the kit package on your CDNStatic 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. MountPoint 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,
    })

02 · Built for agents

Agents edit the same files

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
Multi-turn slide edits, 30 runs eachEach 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 30KHP toolsFlat MCP tools
Runs that finished clean3018
Runs that damaged other content012

Pilot results from khp-bench, run by KHP’s maintainer: method, limits and how to reproduce.

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.

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

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-sheet · Sales.xlsx · 2 editing
Sales.xlsxAB2 hereABCDE1RegionQ1Q2Q3Total2North1,2401,3101,4023,9523South9801,0451,1903,2154East1,1051,1601,2333,4985West8609201,0152,7956Total4,1854,4354,84013,460AnnBen

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

Building on the Kition SDK? Tell us and we’ll list it here.

07 · Pricing

Kits are free

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.