Product
Kizaki is built on one substrate — microapps, sandboxed computation, and a typed dependency graph. Platform is where the software your team runs on lives. Notebook is where your everyday thinking happens, with that same software one block away.
The unit of software in Kizaki is the microapp: a fully custom, full-stack application — replicated state joined to an interface. A microapp can be a full-screen internal tool, a block embedded in a page of notes, or anything in between. Microapps compose through a typed dependency graph that carries data between them, triggers effects, and runs schedules; heavier computation runs in isolated sandboxes; and connectors wire your existing systems in once, so everything you build afterward can use them.
Everything is code. A workspace is a real codebase, and code stays the source of truth: the visual views render from it, and changes made through the platform write back to it. There's no export cliff between "no-code" and software your engineers can actually maintain.
Persistent computation
Platform is where an organization's long-lived software lives: internal tools, operational workflows, dashboards, and small portals. Most organizations already run on hundreds of little applications stitched together — data flowing between services nobody has mapped, where one team's change quietly breaks another team's tool. Platform makes that web explicit. A visual canvas shows every microapp, every sandbox, and every arrow of data flow between them; click into a microapp and you're in its actual interface.
Because the graph is explicit, the platform can protect it. Change something that other workflows depend on, and Kizaki tells you what you're about to break before you break it. Because state runs through Seaglass, every accepted operation lands in a durable log — so what happened, and who did it, is auditable by default. And because new applications are built inside the workspace, they inherit your organization's authentication, capability enforcement, and connectors instead of each one being wired, deployed, and security-reviewed from scratch. An internal tool that used to take a dev team months takes days.
Not everyone needs to see the graph. Builders can publish plain pages and flows, so a sales team just opens a link and uses their tool — the machinery stays out of sight until someone needs it.
One-off computation
Notebook is the same backbone inside your documents. Microapps become blocks in collaborative pages, connected to the same data and connectors as everything else in your workspace. Want to analyze usage patterns from your database, chart the result, sketch a prototype interface, and write your reasoning around all of it? That's one page — no snapshot dumps, no separate scripts, no stitching screenshots into a doc. When the data changes, the page does too.
It's built for the one-off work that persistent software shouldn't absorb: an analysis, an experiment, a prototype, a report. Ask an agent for a visualization and it lands in your notes with your data behind it — live, editable, and shareable as a page or a PDF. And because it's local-first, your notebook works on a plane just as well as at your desk.
Your data lives on your device and syncs in realtime. Work offline and changes merge when you reconnect. Collaboration, presence, and history are part of the substrate — every change is attributable and can be reverted.
Documents and canvases merge like collaborative text. State that carries invariants — balances, inventory, approvals — runs through server-checked typed operations that can reject an invalid write. Authors declare which class each piece of state belongs to; the platform supplies the machinery.
Wire external systems — Postgres, Slack, Salesforce, Stripe, and more — into the workspace once. Every microapp can then build against them, and the dependency graph records exactly which ones a workflow touches.
An AI agent in Kizaki is just another collaborator. Its changes arrive as ordinary, attributable edits with presence — something you can watch, diff, and revert — not a regenerated blob you have to accept or discard whole.
As you use a workflow — approving, rejecting, correcting, saying why — Kizaki accumulates a working model of how you decide. That model is a first-class artifact: visible, testable against your own history, and yours. It persists when the underlying workflow updates, and it leaves with you.
Microapps have no network access by default. Each one declares the capabilities it needs and the platform enforces them: computation runs in isolated sandboxes, connectors are typed, and the dependency graph shows what a workflow reads and writes — and provably nothing else.
Open source
We're building the data layer for all of this in the open. Seaglass is our open-source engine for local-first applications that need to be able to say no. Collaborative state wants mergeable edits; guarded state — budgets, workflows, inventory — wants an authority that can reject an invalid write. Seaglass gives an application both in one typed schema.
Developers declare schema, authorization, operations, and subscriptions as typed documents in TypeScript; a Rust core owns validation and canonical semantics. Accepted operations form a deterministic, auditable log, and each device holds exactly its subscribed, authorized slice of the data — so what's absent locally is honestly absent, not silently missing.
Kizaki is in active development as a desktop application, and we're onboarding early users in waves. Leave your email and we'll reach out when your spot opens.
Request early access