Computing on your own terms

Kizaki is a local-first workspace where software is a medium. Build the tools your team runs on, think alongside live data in your notes, and let your own judgment shape how both behave.

Learn more about the product

Request early access

The product

One backbone, two surfaces

Kizaki is built on one substrate: microapps — small, fully custom full-stack applications — composed through a typed dependency graph, with computation in isolated sandboxes and your existing systems wired in once.

Persistent computation

Kizaki Platform

Where an organization's long-lived software lives: internal tools, workflows, and portals on a visual canvas where every microapp, sandbox, and arrow of data flow is explicit. New applications inherit your auth, security, and audit trail the moment they're created — and the dependency graph warns you what a change will break before it breaks it.

One-off computation

Kizaki Notebook

The same backbone inside your documents. Pull live data into a collaborative page, chart it, prototype an interface, and write your reasoning around all of it — computation as close at hand as a paragraph, shareable as a page or a PDF, and working offline just as well as at your desk.

Explore the product

Local-first and realtime

Your data lives on your devices and syncs in realtime. Offline just works, and every change is attributable and revertible.

Security by construction

Microapps have no network access by default. Each declares the capabilities it needs; sandboxes stay isolated and flows stay auditable.

Agents as collaborators

An agent's edits arrive as ordinary, attributable changes you can watch, diff, and revert — not a regenerated blob.

A judgment layer you own

Your corrections accumulate into a working model of how you decide — visible, testable against your history, and yours.

Open source

Built on Seaglass

We're building the data layer in the open. Seaglass is our open-source engine for local-first applications that need to be able to say no: mergeable, collaborative edits where you want them, and a typed authority that can reject an invalid write where you don't. TypeScript schemas, a Rust core, and a deterministic, auditable log underneath every workspace.

From the founders

Why we're building Kizaki

For twenty-five years, computing was something institutions ran and everyone else received. Banks were clearing your checks by 1959. Airlines were booking your seats by the early sixties. Companies too small for a mainframe rented computer time by the hour. Then came 1979 — VisiCalc, the first spreadsheet, and people started buying $2,000 Apple IIs just to run a program. The personal computer brought something different: computation you operated yourself.

Look at how the software you rely on actually runs today. An organization is hundreds of little tools stitched together — data flowing between services nobody has mapped, one team's change quietly breaking another team's dashboard, every new internal app another round of wiring, deployment, and security review. AI has made writing code nearly free, but it left everything around the code exactly as painful as before. The bottleneck was never typing the software. It was running it.

Kizaki is a workspace where software is a medium, built on one backbone: microapps — small, fully custom full-stack applications — composed through a typed dependency graph, with computation in isolated sandboxes and your existing systems wired in once. It has two surfaces. Kizaki Platform is where persistent software lives: internal tools, workflows, and portals that inherit your organization's auth, security, and audit trail the moment they're created — on a visual canvas where the dependency graph is explicit, so the platform warns you what a change will break before it breaks it. Kizaki Notebook is that same backbone inside your documents: pull live data into a page, chart it, sketch a prototype, write your reasoning around it, and share the whole thing — computation as close at hand as a paragraph.

There's a deeper layer too. Some work depends on personal judgment, and personal judgment cannot be outsourced — what you'd flag, what you'd wave through, why this one and not the nearly identical other one. That knowledge exists only in you, and it's the difference between an answer and your answer. In Kizaki, you start from a working workflow and simply use it: agree, disagree, say why. Your corrections accumulate into a working model of how you decide — visible, testable against your own history, and yours to keep, even as the workflow underneath keeps improving. We call this personally authored computing, or PAC.

All of it rests on ownership. Kizaki is local-first: your data lives on your devices and syncs in realtime, every change is attributable and revertible, and code stays the source of truth. The data engine underneath, Seaglass, is open source. The personal computer gave people computation they operated themselves; we're building the same thing for the software era — software you own and operate, instead of software that happens to you.

If that's a future you want, we'd love to have you request early access.

Cheers!

Joshua, Andy, and Bernice

The Kizaki Team

The company

Kizaki Corporation

We're a software company in Los Angeles, California, founded by Joshua Lau, Andy Zhang, and Bernice Zheng. We build the Kizaki workspace and Seaglass, its open-source engine.

About us

You should control the software you use.

Kizaki is in active development, and we're onboarding early users in waves. Leave your email to request early access.

team@kizaki.ai

Building in Los Angeles, California

© 2026 Kizaki Corporation