kition

Kition brings Markdown documents, structured table files, infinite Boards, a tool-using AI agent, web research, and visual workflows into one desktop workspace. Instead of making every task begin in a blank chat, Kition gives the Agent editable project files, typed records, attachments, and visible processes to work with. This makes powerful AI operations easier to inspect, correct, and repeat without handing context between disconnected tools.

Kition is currently in beta. Back up important workspaces and review agent changes before relying on them in production workflows.

Why Kition

• Connected documents. Write Markdown with live preview, links, backlinks, callouts, code, math, diagrams, daily notes, search, and export.
• Structured data beside the knowledge. Turn research and content into typed records, formulas, filters, groups, views, attachments, and AI fields.
• Visual thinking with reviewable AI changes. Build diagrams, mind maps, flows, and freeform sketches on a Board, then review the Agent's changes before keeping them.
• An Agent that can act. Search the web, inspect documents and table schemas, update content, and save useful output into the active project.
• Reviewable document edits. Let the Agent edit the active document, inspect every addition and deletion, then accept or reject individual changes.
• Visible automation. Assemble trigger-and-action workflows, test steps, inspect run history, and resolve missing inputs before enabling a process.
• Kits for every kind of file. Sixteen kits in four product lines open sheets, slides, photos, films, CAD drawings, and more as ordinary workspace files, and the Agent works on them through each kit's tools. See Kits.

Let the Agent Edit—Keep the Final Say

Instead of returning another suggestion to copy and paste, the Kition Agent can read the active Markdown document, make scoped changes, and write the result back into the workspace. The document and the complete task trace remain visible together while the Agent works.

When a file changes outside the editor, Kition opens a document review surface that highlights additions, deletions, and rewrites. Each change can be accepted or rejected individually, or the complete edit can be reviewed as one set.

This creates a controlled document workflow: describe the goal in natural language, let the Agent edit the real file, inspect the diff, and decide exactly what remains in the final document.

Start With Work, Not a Blank Prompt

A capable Agent is useful, but a blank prompt still asks the user to design the task, describe every input, choose an output format, and recover when a step goes wrong. Kition moves that complexity into familiar work surfaces: documents, table fields, records, templates, and workflows.

The built-in scenarios below are ordinary .ktable files. Their prompts, field relationships, generated assets, and review states stay visible and can be adapted to a real project.

Generate campaign assets in batches

Start with a key message and a face photo. Typed fields keep the content type and intended emotion explicit, while AI fields generate linked 16:9 and 9:16 thumbnail variants for every record. The table becomes both the batch queue and the review surface.

Turn receipt images into searchable records

Drop receipt photos into an attachment field. Vision-powered fields extract the vendor, address, category, structured JSON, and plain OCR text directly into the same row. The results can then be filtered, corrected, summarized by the Agent, or passed into a review workflow.

Expand one product brief into a complete asset pipeline

One product concept can drive multiple design candidates, orthographic views, a feature image, a lifestyle shot, a style board, and launch copy. Each result remains attached to the source record, so the full chain is easier to compare, regenerate, and hand off than a collection of disconnected chat outputs.

These scenarios show the intended Kition loop: use documents for narrative context, tables for structured state, Boards for visual thinking, the Agent for uncertain work, and Workflows for steps that should become repeatable.

Product Tour

Write connected documents

Write Markdown with live preview, internal links, backlinks, tags, outlines, embeds, callouts, code, math, diagrams, templates, daily notes, tabs, and full-text search. Export finished work to PDF when it needs to leave the workspace.

Turn data into useful tools

Create structured table files with typed fields, attachments, formulas, filters, sorting, grouping, multiple views, and fast record editing. Use them for research, content pipelines, lightweight CRM, inventory, or project tracking.

Give the agent real context

Ask the Kition agent to read and update documents, inspect table schemas, create or modify records, search the web, use tools, and follow a plan. Agent output can be written back into the active workspace.

Think and plan visually

Build diagrams, mind maps, flowcharts, sticky-note clusters, and freeform sketches on an infinite canvas. Boards are .kboard files the Board kit edits, and the Agent works on them through the kit's tools, live or as a draft you review before it becomes part of the workspace.

Automate repeatable work

Build trigger-and-action workflows on a visual canvas. Start from a template, assemble a workflow manually, test individual steps, inspect run history, and resolve missing inputs before enabling it.

Kits

A kit is an editor for one kind of file. Its engine is compiled to WebAssembly and runs in a Web Worker, and the kit draws its own editor inside Kition. The Agent edits the same files through the kit's tools, so its changes stay visible and reviewable. Kition's kits come in four product lines; the packages Kition ships are pinned in kits/kits.lock.json.

Product line	Kit	Edits
Office	Note	Markdown notes
Office	Table	Structured .ktable data tables
Office	Board	Infinite canvas for diagrams, mind maps, and sketches
Office	Doc	Word documents (.docx)
Office	Sheet	Spreadsheets (.xlsx) with formulas
Office	Slide	Slides, including opening .pptx files
Office	PDF	PDF files
Office	HTML (Preview)	HTML pages
Design	Photo	Raster images and photo editing
Design	Vector	Vector graphics
Design	Design	Page layouts such as flyers and posters
Design	Fig (Preview)	Interface and screen designs
Media	Film	Video timelines
Media	Effect	Motion graphics
Engineering	CAD	CAD drawings, including DXF
Engineering	Cube (Preview)	3D scenes

Preview kits are early. HTML and Fig are not pinned in kits/kits.lock.json yet; they ship once their packages are published.

Each kit is developed in its own repository; see Kit SDK for how kits plug into Kition.

Also included:

• AI-assisted table fields for generating text, structured values, and media from record context.
• Email connections and inbox-to-table workflows. See Email Connections.
• Model, proxy, MCP, account, usage, update, and desktop integration settings.
• A seeded Getting Started workspace with practical document, table, and workflow examples.

Install

Desktop builds are published through GitHub Releases.

• macOS: download the latest .dmg.
• Windows: download the latest installer.
• Linux (experimental): download the latest x86_64 .AppImage.
• Previous versions: browse the complete release history.

Run From Source

Requirements:

• Node.js 22.19.0
• pnpm 10.33.0
• Rust (stable) and the Tauri system prerequisites for your platform

pnpm install --frozen-lockfile
pnpm dev

pnpm dev runs tauri dev, which compiles the Tauri desktop shell together with the Rust runtime in crates/ and starts the desktop client.

For renderer, component, editor, and style work that does not require runtime integration:

pnpm dev:web

The web preview runs the renderer against a mocked runtime and is the fastest path for most client-side contributions. More options are documented in Runtime development.

Open Source Boundary

Everything that makes up the Kition desktop app is open source in this repository:

• the React renderer (src/): document, table, Agent, settings, email, scenario, workflow, and kit-host UI;
• the Tauri desktop shell (src-tauri/) and desktop integration;
• the Rust runtime (crates/), which the shell runs in-process and which serves its HTTP API on loopback only. See Runtime development;
• the runtime contracts in contracts/runtime/, mocks, fixtures, and black-box tests;
• the kit pins (kits/) and packaging and release workflows.

Kits are developed in separate repositories. Kition ships each kit's published package, pinned by version and checksum in kits/kits.lock.json.

Technology

Area	Stack
Desktop	Tauri 2 (Rust)
Runtime	Rust, SQLite
Interface	React, TypeScript, Vite
Kits	WebAssembly engines in Web Workers, editors in iframes
Documents	Marked, Mermaid, KaTeX
Data and state	IndexedDB, TanStack Query, Zod
Testing	Vitest, Playwright

Contributing

Issues and pull requests are welcome.

1. Read CONTRIBUTING.md for setup, scope, and required checks.
2. Follow the Kition Development Standard, including the recommended Orca worktree workflow.
3. When a change crosses the renderer and the runtime, update the contract in contracts/runtime/, the renderer mock, and the runtime together.
4. Report security-sensitive issues through .github/SECURITY.md, not a public issue.

For product questions, account help, and private workspace concerns, see .github/SUPPORT.md.

Repository Layout

.
├── .github/                 # Community health files and CI workflows
├── contracts/runtime/       # Runtime HTTP API schemas
├── crates/                  # Rust runtime (kition-api and its feature crates)
├── docs/                    # Product, contributor, design, and runtime docs
├── e2e/                     # Playwright black-box tests
├── kits/                    # Kit pins (kits.lock.json) and kit SDK registry
├── packages/                # Source packages that also run outside Kition
├── public/                  # Static assets, onboarding files, and kit packages
├── scripts/                 # Repository checks and inspection entry points
├── src/                     # React application organized by feature domain
├── src-tauri/               # Tauri desktop shell and packaging
├── tooling/                 # Build, lint, and test configuration
└── package.json             # Development, test, and packaging commands

License

Kition, including its runtime in crates/, is licensed under the Apache License 2.0.