The platform beneath everything
The programmable platform and public API behind Kaitoi Studio. Build AI-native applications as composable nodes instead of one monolithic codebase, on the same foundation we run in production.
{ "projectId": "proj_abc123", "targetNodeIds": ["enhance"], "inputOverrides": { "enhance": { "scale": { "type": "number", "value": 4 } } } }
{ "status": "succeeded", "outputs": { "enhance": { "type": "image", "outputId": "out_3c4d…" } }, "executionTimeMs": 6200 }
Kaitoi Core turns AI models, software, services, agents, and domain tools into programmable building blocks that can be composed, automated, and extended on demand. We handle the graph engine, model routing, media, sandboxed execution, permissions, and billing, so developers can focus on the workflow they actually want to ship.
Why build features as nodes
Point a coding agent at a blank repo and it has to hold the whole application in its head at once: state, execution, error handling, and every interaction between them. One change can ripple anywhere. A node is the opposite. Its scope is contained, its inputs and outputs are a defined contract with the rest of the graph, and it can be built, run, and verified on its own.
That is a far smaller surface to get right, for you and for the agent writing it, so features land faster and break less. You compose reliable pieces instead of maintaining one fragile codebase, and Core handles everything around each node, execution, model routing, media, retries, permissions, and scale, so a node only ever has to do its one job.
The hard parts of AI infrastructure, built in.
Route across image, video, audio, 3D, and language models through one managed key and interface.
Build AI agents and realtime voice into your workflows, running on the same graph as everything else.
Drop into Python anywhere. Extend the platform with your own logic and packages.
A dependency-aware engine runs your nodes in parallel, caches results, and recomputes only what changed.
Every node runs isolated in its own environment, with CPU, memory, and dependency limits enforced.
Built-in storage, signed URLs, uploads, and transcoding for production-scale assets.
Connect external services and expose your own workflows as programmable endpoints.
Scoped API keys, rate limiting, and access control enforced on every request.
Per-run cost metering, provider markup, and team spend caps handled for you.
Studio is our own production app, built on Kaitoi Core, the same development platform available to teams building custom AI-native applications. The Kaitoi CLI runs on it too. If we can build a full product platform on Core, you can build on it as well.
Kaitoi Core is accessed through Kaitoi Studio. Create an account, grab your keys, and build.
Sign up for Kaitoi Studio to set up your workspace.
Generate keys and read the Core documentation from your Studio account.
Call the API to power your own AI-native applications.