SECTION 01
Plans
Every Ozawa project starts with Plans. You describe what you want to build in plain language, and the Plans agent helps you shape it into a clear, structured plan that the rest of your agents can pick up and execute against. Think of it as sitting down with a thoughtful co-founder before you write a single line of code.
Starting a conversation
Open the Plans panel and describe what you want to build. It can be a full pitch ("I want a client portal for a law firm with case files, secure messaging, and voice-note transcription"), a rough idea, or even a single sentence. The Plans agent will ask follow-up questions until it understands enough to help.
Organizing your plan
Once the conversation has enough substance, click Organize. Plans distills everything you've discussed into a small set of structured documents — an overview, a data schema, an auth flow, a features list, and an environment-variables manifest. Each document lives as its own file inside your project so you (and your other agents) can reference them independently.
Organize is smart: it only rewrites what needs rewriting. Small tweaks become surgical edits to the affected file, not a full rebuild. If the plan already looks good, running Organize again is a fast no-op.
Referencing files with @
Type @ in the Plans input to pull up a picker of every plan file. Choose one (say @schema) and Ozawa will focus the next turn of the conversation on that file specifically. It's the difference between "can we add a fields to users?" and "in the schema, can we add a fields to users?" — same idea, but Plans knows exactly which document you mean.
Quick actions with /
Type / in the input to reveal a short list of quick actions: /organize to trigger Organize without leaving the keyboard, and other useful shortcuts as they arrive.
History & revert
Every plan file has a history. When you open a plan document, click History in the top-right — you'll see every past version of that file with a relative timestamp ("just now", "3 min ago", "yesterday"). Preview any version, and if you want to roll back, click Restore. The current version becomes a snapshot too, so you can always un-restore with one more click.
The Play button — dispatching your team
Once your plan is Organized, click the play button in the Plans header. Ozawa reads the plan and spawns the right task agents for the job — one for the front-end, one for the back-end, one for design, whatever the plan calls for. Each agent picks up its work directly from the plan files you just created and starts building.
Saving changes to the plan
Sometimes you'll change your mind mid-conversation and want Plans to update one of the files. When Plans proposes a change, a Save changes to plan chip appears. Click it to commit. If something goes wrong at any point — a crash, a wrong interpretation, anything — the previous version of that file is always one click away from the History view.
SECTION 02
Task agents
Task agents are the ones who actually build. Each agent has a role (designer, back-end engineer, generalist coder, and so on) and they can work in parallel while you watch. You don't have to babysit them — just tell them what to do, or let Plans hand them their work directly.
Spawning an agent
Click + Spawn agent in the canvas. Pick a role (or leave it general), give it a short brief, and it appears on your canvas as its own pane. You can spawn up to nine at a time; each one runs independently.
Every agent gets a friendly name (Sarah, Kai, Marcus, Iris — pulled from a small pool so you're not staring at "Agent 1, Agent 2, Agent 3"). Address them by name from the main prompt bar ("Sarah, add the auth flow") and Ozawa routes your request to the right pane.
Watching them work
Each pane shows the agent's thinking and output as it happens. When they finish a task, they'll summarize what they did. When they need help (a missing key, an unclear requirement) they'll ask you directly in the pane. You reply in the main prompt bar — Ozawa knows who you're talking to based on which pane you focused last.
Stopping or redirecting
If an agent is going the wrong way, click the red stop button in the pane's header. The agent halts cleanly. The next time you send it a message, it'll briefly check in with you before continuing — no ghost work happens between the stop and your next instruction.
Multi-agent parallel work
You can have a designer working on the visual system while a back-end engineer builds the API and a coder wires the front-end together — all at the same time. Ozawa keeps them from stepping on each other's toes, and the plan files they all reference stay in sync automatically.
SECTION 03
OZ
OZ is Ozawa's own agent. It watches everything happening across your project — what your agents are doing, what's failing, what just changed in your plan — and can talk to you about any of it. Think of OZ as a head-of-engineering type: it's not the one writing code, but it's the one who knows what everyone else is doing and helps you decide what to do next.
The OZ pill
At the top of your canvas you'll sometimes see a small purple pill with a short message — "Kai finished the schema." or "Two deploys failed in a row — want me to open Repair?". That's OZ narrating what's happening. It's unobtrusive on purpose: OZ only talks when something's worth telling you about. Click the pill to expand a small drawer showing the last twenty things OZ noticed.
Chatting with OZ
Click the OZ toggle in the toolbar to open a full chat panel. Ask OZ anything about your project — "what's Kai working on?", "is the schema ready for the front-end?", "what should I do next?". OZ can see your entire plan, every active agent, your environment variables (never the values — just which ones are set), and the most recent activity. It's the fastest way to get your bearings when you come back to a project after a break.
Show thinking
On supported models, click the menu inside the OZ chat panel and turn on Show thinking. You'll see OZ reason through your question in real time before it answers. Great for planning conversations where the reasoning is the point.
What OZ knows about your project
OZ has access to your plan files (in full), the list and status of every active agent, the environment-variables manifest (which vars exist and whether they're set — never the actual values), and a rolling log of what's been happening. It doesn't see your source code directly — that's your task agents' job. OZ is the coordinator, not the builder.
SECTION 04
Environment variables
Env-vars are the secrets your app needs to run — API keys, database URLs, service tokens. Ozawa keeps them separate from your code so they never accidentally end up in a commit, a screenshot, or a share link. Values live only on your machine.
The env-vars panel
Open the env-vars panel from the toolbar. You'll see every variable your plan identified — the name, a short description of what it does, which service it comes from, and whether you've set a value yet. Set values are always masked, and clicking the value never reveals it in plain text.
Required vs. optional
Some vars are required (your app won't run without them). Some are optional (they unlock features but the base app works without them). Ozawa marks each one clearly so you know what to prioritize.
Where each value comes from
For every required variable, Ozawa knows which service it belongs to (Stripe, Supabase, OpenAI, and so on) and shows you a direct link to the page on that service where you can copy the key. No more hunting through documentation.
Privacy
Values never leave your machine. They aren't sent to Ozawa's servers, they aren't included in the context your agents see, and they aren't stored anywhere except in a local file inside your project (which Ozawa automatically excludes from version control).
SECTION 05
Preview & Run
Once your agents have built something, click Run to see it work. Ozawa launches your project, waits for it to come online, and shows it live in the preview panel on your canvas — no separate browser tab needed.
Run the app
Click Run the App in the preview panel. Ozawa handles everything — installing any missing dependencies, starting the local server, finding the right port, waiting for the app to be ready — and shows you the live result. Rerun any time to pick up your latest changes.
Address bar
The preview panel has a small address bar at the top so you can navigate around your app while it runs. It behaves like a normal browser — back, forward, refresh, and clicking links all work.
Self-healing (Repair)
If your app fails to start, a small Repair chip appears. Click it to open a focused conversation with the Repair agent, which reads the error, explains what went wrong in plain English, and helps you fix it. Repair works this way anywhere in the app — deploy failures, browser errors, plan hallucinations. If something's wrong, Repair is one click away.
SECTION 06
Deploy
When you're ready to share what you've built with the world, click Deploy. Ozawa packages your project, publishes it to the internet, and gives you a live URL you can send to anyone. The parts of deploying that are usually painful — DNS, TLS, secrets, build configuration — are all handled for you.
One click
The Deploy button lives in the preview panel next to Run. Click it, wait a moment, and you'll get back a URL. That URL is yours — permanent, secure, and ready to share. Click Deploy again any time you want to publish an update.
Environment variables in production
Any env-vars you've marked as required are pushed to your live deployment automatically — never checked in, never logged. You'll always know which values are in production because the env-vars panel shows their status separately.
If something goes wrong
If a deploy fails, a Repair chip appears. Click it to have Repair walk you through what happened and how to fix it. Most deploy failures are one env-var away from resolved; Repair will tell you which one.