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.
Request early access
Request received.
We'll be in touch soon.
The product
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
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
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.
Your data lives on your devices and syncs in realtime. Offline just works, and every change is attributable and revertible.
Microapps have no network access by default. Each declares the capabilities it needs; sandboxes stay isolated and flows stay auditable.
An agent's edits arrive as ordinary, attributable changes you can watch, diff, and revert — not a regenerated blob.
Your corrections accumulate into a working model of how you decide — visible, testable against your history, and yours.
Open source
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
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
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 usYou 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.
Request received — we'll be in touch.