# Kition: the agent edits the real file, and a review surface shows the diff

> Kition is an AGPL-3.0 desktop workspace that puts Markdown documents, typed tables, a Whiteboard and a tool-using agent in the same project, and its central bet is that an agent should write into your files and show you every change rather than hand back text to paste.

**KitionAI/kition** — Kition brings Markdown, DataTable, WhiteBoard, a tool-using AI agent, browser research, and visual workflows into one desktop workspace. 

- Repository: https://github.com/KitionAI/kition
- Website: https://kition.ai
- Stars: 401 · Forks: 30
- Language: TypeScript
- License: AGPL-3.0
- Published: 2026-09-17 · Updated: 2026-09-17 · Language: en
- Canonical page: https://hysenlabs.com/projects/kitionai-kition

## The agent writes into the file, and a review surface shows every change

This is the mechanism the rest of the product is built on. Instead of returning another suggestion for you to copy and paste, the Kition agent can read the active Markdown document, make scoped changes, and write the result back into the workspace, with the document and the complete task trace remaining visible together while it works. The review side is what makes that acceptable. When a file changes outside the editor, Kition opens a review surface that highlights additions, deletions and rewrites, and every individual change can be accepted or rejected, or the whole edit can be reviewed as one set. The documented workflow is therefore describe the goal in natural language, let the agent edit the real file, inspect the diff, and decide what remains. That is a different contract from the copy-paste loop most assistants offer, and it is the one thing here worth judging the project on.

## The agent gets typed records instead of a blank prompt

The argument is made explicitly: a capable agent is still not much use if a blank prompt asks you to design the task, describe every input, choose an output format and recover when a step goes wrong. Kition moves that work into surfaces you already know, being documents, table fields, records, templates and workflows. The built-in scenarios are not sealed demos either, they are ordinary `.kitable` files, so their prompts, field relationships, generated assets and review states stay visible and can be adapted to a real project. Underneath sits a five-way division of labour: documents for narrative context, tables for structured state, Whiteboards for visual thinking, the agent for uncertain work, and workflows for steps that should become repeatable. The agent's own capabilities match that split, since it can research in browser tabs, inspect documents and table schemas, update content and save useful output into the active project.

## Receipts and campaign thumbnails are the two scenarios that show the table working

Two of the four shipped scenarios are worth reading closely because they show what a typed field buys. The receipt one drops photographs into an attachment field, and vision-powered fields extract the vendor, the address, a category, structured JSON and plain OCR text directly into the same row, after which the results can be filtered, corrected, summarized by the agent or passed into a review workflow. The campaign one starts from a key message and a face photograph, where typed fields keep the content type and the intended emotion explicit and AI fields generate linked 16:9 and 9:16 thumbnail variants for every record. In both cases the table is doing two jobs at once, acting as the batch queue and as the review surface, which is the structural difference from a folder of generated images.

## Design Studio turns a record or a board frame into an editable poster

The fourth scenario is a design pipeline rather than an extraction one, and a fifth covers going from one product brief to many assets. A single product concept is described as driving multiple design candidates, orthographic views, a feature image, a lifestyle shot, a style board and launch copy, with every result staying attached to its source record so the chain can be compared, regenerated and handed off rather than being a pile of disconnected outputs. Design Studio is the surface that turns a table record, a Whiteboard frame or a generated image into an editable poster. Its templates bind the workspace brand kit, size variants hold one composition across poster, story, square and landscape formats, and the agent proposes text and layout changes as a reviewable preview rather than applying them. Exports then go back into documents and tables, and the format has its own documentation file.

## Nine READMEs and seven translations to keep in step

The repository ships the README in nine languages. English is the default, with dedicated files for Simplified Chinese, Russian, Japanese, Vietnamese, French, German and Spanish, each named with its locale suffix in the repository root. That is more translation surface than most desktop projects take on, and it is backed by tooling rather than goodwill, because the scripts include a check dedicated to it among the Python-based checks. Other roots add up quickly as well: a `.codex/` directory for agent tooling, a `contracts/` directory, an `e2e/` directory, a `patches/` directory, a `tooling/` directory with the build configuration, an `electron/` directory, a `build/` directory, `AGENTS.md` and `CONTRIBUTING.md`, plus a small `pelican-bike.svg` at the top level that appears to be the project mark.

## The governance checks are Python scripts run through pnpm

The script list is where the project's habits show. Type checking is a plain no-emit tsc pass, and the test script delegates to a unit test target. Beyond that there is a family of checks that are not tests at all: one verifies branding, one checks product language, one checks internationalisation, one looks for blank comment blocks, and all four are Python scripts invoked by name. Two more are baselines rather than gates in the usual sense. One runs the knip unused-code check against a stored baseline, with a sibling script that updates it. Another runs dependency-cruiser over the source tree with a known-violations file, in an output mode that reports errors, plus an update target for refreshing the baseline. So unused exports and layer violations are tracked as a reviewed list rather than as an ever-failing build, which is a pragmatic choice with an obvious failure mode.

## Private in npm terms, versioned in git terms

The manifest is worth reading for what it rules out. The package is marked private, so nothing is published to a registry, and the desktop build is fetched from the GitHub Releases page instead. It is still versioned, at 0.1.49, with the visible release history stepping through 0.1.45, 0.1.47 and 0.1.49, so the numbering is dense and skips numbers between tags. The engine constraint is narrow on purpose: Node from 22.19.0 up to but not including 23, and pnpm from 10.16.0 up to but not including 11, with the package manager field pinning pnpm 10.33.0 inside that range. The license field says AGPL-3.0-only, matching the licence file, and the author is listed as a company rather than a person, with a support address pointing at the same domain as the product site.

## Four surfaces, one workspace, and a beta warning worth reading twice

The product tour fills in the rest. Documents are Markdown with live preview, internal links, backlinks, tags, outlines, embeds, callouts, code, math, diagrams, templates, daily notes, tabs and full-text search, exporting to PDF or DOCX when work has to leave the workspace. Tables are structured files with typed fields, attachments, formulas, filters, sorting, grouping, multiple views and fast record editing, aimed at research, content pipelines, lightweight CRM, inventory or project tracking. Whiteboards take diagrams, mind maps, flows and freeform sketches, with agent proposals reviewed before they are applied. Workflows are trigger-and-action processes where you can test steps, inspect run history and resolve missing inputs before enabling anything. Over all of it sits the warning that Kition is currently in beta, that you should back up important workspaces, and that you should review agent changes before relying on them in production workflows.

## Conclusion

Kition fits someone who wants an agent working inside a project of files rather than in a chat window, and who is willing to read diffs, since the review surface that accepts or rejects individual additions, deletions and rewrites is the feature everything else hangs off. It fits badly if you want an agent with a general shell, and it fits badly for unattended production automation while the beta caveats stand. Three things to know before relying on it. The project states that it is currently in beta and tells you to back up important workspaces and review agent changes before using it in production workflows, so the review step is not optional in the intended design but also not yet a guarantee. Distribution runs through GitHub Releases rather than a package registry, the manifest is marked private, and the engine range admits only Node 22. And the shipped scenarios are editable files rather than a fixed feature set, which means the fastest route to value is opening a built-in table file and adapting its prompts and fields, since those files are documented as staying visible and modifiable rather than being sealed scenarios. AGPL-3.0, last pushed on 29 September 2026.

## FAQ

### What is Kition?

A desktop workspace that brings Markdown documents, structured table files, an infinite Whiteboard, a tool-using AI agent, browser research and visual workflows into one place, licensed AGPL-3.0 and distributed through GitHub Releases. The stated aim is to stop every task from beginning in a blank chat prompt.

### How does Kition handle AI edits to a document?

The agent can read the active Markdown document, make scoped changes and write the result back into the workspace instead of returning text to copy. When a file changes outside the editor, a review surface highlights additions, deletions and rewrites, and each change can be accepted or rejected individually or reviewed as one set.

### What is a .kitable file in Kition?

The built-in scenarios ship as ordinary .kitable files, which are the structured table files. Their prompts, field relationships, generated assets and review states all stay visible and can be adapted to a real project, so they are working files rather than sealed demos.

### What can the Kition agent do with its tools?

It can research in browser tabs, inspect documents and table schemas, create or modify records, update content, follow a plan and save useful output into the active project. Visible automation is handled separately, through trigger-and-action workflows where you can test steps and inspect run history before enabling a process.

### Is Kition ready for production use?

The project states that it is currently in beta and advises backing up important workspaces and reviewing agent changes before relying on it in production workflows. It is versioned 0.1.49 and distributed from GitHub Releases rather than a package registry, with the manifest marked private.

## Sources

- [KitionAI/kition on GitHub](https://github.com/KitionAI/kition)
- [License: AGPL-3.0](https://github.com/KitionAI/kition/blob/main/LICENSE)
- [Project website](https://kition.ai)
- [README](https://github.com/KitionAI/kition/blob/main/README.md)
- [Releases](https://github.com/KitionAI/kition/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/kitionai-kition