Each mode is a different way to work with the same project. Choose by the result you need now, then hand that result to another mode when the work changes shape.
One project, eight built-in surfaces
Switching modes does not mean starting over. Selected sources, useful outputs, and project memory remain inside the project boundary. Toolkit Settings can also add project-defined custom modes.
01ChatThink, research, decide, and draft
Choose Chat when
The question is still open, you need to understand source material, compare options, plan an approach, or draft language before committing to another format.
What it produces
Briefs, research notes, outlines, decisions, copy, implementation plans, and instructions that another mode can use.
Chat workflow
01
State the outcome
Name what you want to leave with: a decision, outline, draft, analysis, or plan.
02
Select the context
Attach only the project sources that matter and identify the authoritative file when versions conflict.
03
Ask for a tangible first pass
Specify the format, audience, constraints, and what a useful answer must include.
04
Review and narrow
Check claims against sources. Keep what works and request one focused revision at a time.
05
Route the result
Use the approved brief in Director, Design System, Code, Studio, Deck, or a repeatable Nodes workflow.
Useful request pattern
Using [sources], create [artifact] for [audience]. It must [constraints]. Return it as [format].
Move on when
The direction is stable enough to design, build, make, present, or automate. Stay in Chat while the core question is still changing.
02Design SystemDefine reusable product rules
Choose Design System when
Several screens, apps, or collaborators need one visual language, or an existing interface needs consistent foundations and component rules.
What it produces
Identity guidance; color, type, and layout tokens; icon, motion, gesture, and UI rules; component specifications; governance; an app registry; previews; and portable project files.
Design System workflow
01
Create or open a system
Name the product family, choose a recent system when one exists, and bring in the references that define the intended character.
02
Set the foundations
Define identity, color, typography, layout, and icon rules before solving individual screens.
03
Specify behavior
Document motion, UI, gesture, and component states so interaction is as consistent as appearance.
04
Review adoption
Use the overview, preview, changelog, governance, and app registry to find gaps and track where the system is used.
05
Export and hand off
Save or export the portable system, sync its tokens and generated files to the project, then open the implementation in Code.
Recommended section order
Identity -> foundations -> components and behavior -> governance -> app adoption. Build the rules from broad to specific.
Move on when
A developer or designer can apply the system without inventing missing values, states, or interaction rules.
03CodeBuild, run, and preview project files
Choose Code when
The deliverable is functioning software, a prototype, a web experience, a script, or a file-level change that must be executed and inspected.
What it produces
Project files, implementation plans, executable JavaScript or Python, HTML and CSS previews, console output, tested changes, and Git-aware work.
Code workflow
01
Open or link the project
Choose the working folder and confirm the file tree, runtime, network, and filesystem boundaries for the job.
02
Frame the change
Describe the expected behavior, affected files, constraints, and acceptance checks. Attach visual or source references when useful.
03
Review the plan
For larger work, use planning mode to inspect the proposed steps before execution begins.
04
Edit, run, and test
Work through the files, execute the relevant language or task, and use terminal and console output to fix the first real failure.
05
Preview and hand off
Inspect the rendered result, verify the acceptance checks, and keep the working files and branch ready for the next collaborator.
Useful request pattern
Change [behavior] in [project or files]. Preserve [constraints]. Verify with [tests or preview] and report the files changed.
Move on when
The change runs cleanly, the preview matches the intended behavior, and any remaining limitation is explicit.
04DirectorDevelop stories into production plans
Choose Director when
An idea, script, campaign, film, series, documentary, music piece, or fictional world needs narrative structure and a path into production.
What it produces
Concepts, characters, worlds, structured beats, scenes, scripts, visual direction, production notes, and handoff-ready creative plans.
Director workflow
01
Idea or files
Start with AI, describe an idea, upload source material, choose a template, or continue an existing project.
02
Guided setup
Set the format, audience, intent, creative constraints, and the questions the project still needs to answer.
03
Structure
Shape the premise into acts, beats, chapters, episodes, or another structure appropriate to the format.
04
Scenes
Turn the structure into concrete scenes with purpose, conflict, participants, setting, and transitions.
05
Script
Write and refine action, dialogue, narration, lyrics, or on-screen language while keeping continuity visible.
06
Visual direction
Define look, framing, rhythm, palette, references, and asset needs before generating production media.
07
Production
Review the complete plan, resolve gaps, and send shots or asset briefs into Studio and sequences into Editor.
Four starting points
Start with AI for guided discovery; use an idea or files when source material exists; use a template for a known format; continue when the project is already structured.
Handoff rule
Send specific visual briefs to Studio, assembled sequences to Editor, and pitch-ready story summaries to Deck.
05StudioGenerate and refine visual media
Choose Studio when
The result should be an image or visual asset: a concept, campaign visual, illustration, background, cover, product scene, or art direction study.
What it produces
Generated candidates, edited variations, crops, visual references, and approved media that stays with the project.
Studio workflow
01
Choose the generation path
Pick the workflow that matches the job - new image, reference-led variation, or edit - and set the intended format.
02
Write the visual brief
Describe subject, composition, camera or viewpoint, lighting, palette, texture, aspect ratio, and exclusions.
03
Generate candidates
Compare structure and art direction before inspecting tiny details. Select the strongest base, not a mixture of every option.
04
Refine without drift
Change one dimension at a time while restating the subject and composition that must remain fixed.
05
Approve and reuse
Keep the chosen output in project assets, then place it in Editor or Deck, or feed it into a Nodes workflow.
Useful brief order
Subject → composition → viewpoint → light → palette → material/style → format → what to avoid.
Move on when
The image works at its final crop and size. Keep alternates only when they support a real decision or downstream format.
06DeckShape a story into editable pages
Choose Deck when
You need a sequenced, editable presentation for an audience: a pitch, proposal, report, concept review, lesson, or internal decision.
What it produces
An editable page sequence with text, images, shapes, layout, speaker-ready pacing, and preview or delivery options.
Deck workflow
01
Frame the presentation
Name the audience, desired decision, page count, aspect ratio, tone, and delivery setting.
02
Choose the evidence
Select the brief, source files, approved Studio assets, and project facts the deck may use.
03
Build the story arc
Outline one job per page. For a short deck, start with problem → proof → next step.
04
Generate, then edit directly
Review the sequence first; then rewrite text, replace media, adjust layout, and reorder pages in the editor.
05
Preview and deliver
Read the deck from beginning to end, remove repetition, verify legibility, and test the intended viewing path.
Quality check
Every page should make one point, earn its place in the sequence, and remain understandable at presentation distance.
Move on when
The narrative survives a full preview without explanation. Return to Chat if the argument—not the page design—is still weak.
Video, images, audio, titles, shapes, or generated shots need to become a timed sequence that can be previewed and exported.
What it produces
Multi-track edits, clip timing and transitions, audio and spatial layers, titles and graphics, generated sequences, transcriptions, and rendered video.
Editor workflow
01
Bring in media
Add project assets and generated shots, then check format, duration, orientation, and audio before arranging the timeline.
02
Choose a timeline mode
Use Manual for direct placement, Magnet to match the preceding clip's style, or Sequence to generate a clip sequence from a prompt.
03
Build the sequence
Arrange video, audio, and spatial tracks; trim clips; set order and pacing; and keep related layers aligned.
04
Refine picture and sound
Add text or shapes, balance volume, generate or transcribe audio where needed, and use undo and redo while testing changes.
05
Preview and export
Play the full timeline, inspect the export settings, render the intended format, and review the final file outside the editor.
Timeline modes
Manual gives full placement control. Magnet carries visual style forward. Sequence turns a prompt into a generated run of clips.
Move on when
Picture, sound, and timing hold together in a full playback and the rendered file matches the delivery settings.
08NodesBuild visible, repeatable workflows
Choose Nodes when
The same multi-step job will run more than once, needs branching or review, uses several models or tools, or must be inspectable when something fails.
What it produces
A saved graph of inputs, transforms, tools, decisions, and outputs that you can test one step at a time or run as a whole.
Nodes workflow
01
Define the contract
Write down the input the graph receives, the final output it must return, and the conditions that count as success.
02
Lay out the smallest path
Start with input → transform → output. Add branches, tools, or review gates only when the basic path runs.
03
Configure and connect
Set each node’s required values and connect compatible output and input ports from left to right.
04
Test step by step
Run one node with representative data, inspect its result, then continue downstream. Fix the first missing or invalid output.
05
Run, guard, and save
Run the full graph, make failures visible, add human review before consequential outputs, and save the proven workflow.
Graph reading rule
Inputs enter on the left, work happens in the middle, and durable outputs leave on the right. Name every node by its job.
Debugging rule
Start at the first node without a valid output. A downstream node cannot repair empty or incompatible upstream data.
Presentations
Deck
Plan the arc, create pages, edit directly, and preview the sequence.
Create a three-page deck
Frame the job. Name the audience, decision, and page count.
Ask for the arc. Use problem → proof → next step.
Generate pages. Review the story before polishing elements.
Edit the page. Select text, images, or shapes and adjust them.
Preview. Read the deck in sequence and remove repetition.
The Chrome companion can pass relevant browser context into a project before you start.
Connect inputs, intelligence, tools, and outputs into a graph you can inspect.
Read the canvas
Each node does one job. Ports carry data between nodes, and edges make the order of work visible. A healthy graph reads from inputs on the left toward outputs on the right.
Build a workflow
Add an input or trigger.
Add the model or tool node that performs the work.
Connect compatible ports.
Set required values inside each node.
Run one node to test it, then run the graph.
Debug a graph
Start at the first node without an output.
Check that required inputs have values.
Inspect the data type crossing each edge.
Reduce the graph to the smallest failing path.
Build a reusable process
Workflows
Create a custom workflow, shape its workspace.
Look for the workflow icon
A workflow connects inputs, models, tools, decisions, and outputs into a process you can run again. Start from a built-in path, import compatible workflow JSON, or build your custom workflow in Nodes.
How to create a custom workflow
Choose a starting point. Open a built-in workflow, import JSON, use a saved template, or start from scratch and build your own custom nodes to create your workflow.
Open it in Nodes. Add the model, tool, transform, review, and output nodes the process needs.
Connect and configure. Join compatible ports, set dependencies and defaults, and make every required input explicit.
Shape the workspace. Use the Mode template to build to decide which tools, canvas, controls, actions, and handoffs appear.
Test the smallest path. Run one node, then one branch, then the full workflow. Add a review gate before publishing.
Save and reuse. Validate it and save it as JSON, Markdown, or a .kwib-template. Reuse it as a workspace add-in or schedule it as a Daily workflow.
Creative areas for custom workflows
Text to image
Generate original images from prompts and project context.
Inpaint + change
Replace, repair, extend, or selectively revise an image.
Style transfer
Apply a visual direction while preserving useful structure.
Control maps
Guide pose, depth, edges, composition, and constraints.
Vector
Create and transform scalable graphics and design assets.
Spatial + 3D
Build spatial, scene, and 3D-assisted generation paths.
Video
Generate, transform, assemble, review, and export motion work.
Every customizable workspace area
Top toolkit
Mode switcher, custom features, primary actions, and export.
Left toolkit
Sources, control maps, inputs, and custom tools.
Middle workspace
Canvas, preview, compare views, and the main creative surface.
Right toolkit
Models, history, runtime controls, settings, and output options.
Mode setup
Dependencies, defaults, packages, and workflow-level settings.
Actions + handoffs
Custom actions, exports, approvals, and send-to-mode routes.
Reusable delivery
JSON, Markdown, .kwib-template, workspace add-ins, and Daily scheduling.
Reliable workflow patterns
Linear generation: Input → transform → output. Use it for a direct creation task.
Generate and review: Input → generate → review gate → save. Use it before work becomes a durable project artifact.
Branch by condition: Input → classify → branch A or B. Keep each branch small and make the fallback path explicit.
Design rule
A workflow should make failure visible. Name nodes by their job, keep important outputs inspectable, and test one path at a time.
Goal-directed work
Agents
Give agents a bounded job, the right tools, and a review point.
Write a useful task
State the outcome, the project or files it may use, constraints it must respect, and what proof counts as complete.
Use checkpoints before publishing or irreversible changes.
Review generated artifacts, not only the final message.
Agent + Nodes
Use Nodes when an agentic task needs a visible, repeatable structure. The graph provides process; the agent handles judgment inside the bounded step.
Context management
.memory
Build useful context at global and project scopes, then review and refine it over time.
Where memory lives
Global: durable preferences across the workspace. Add, edit, and review memories in Settings → Memory.
Project: context shared by work inside one project (edit and review in Projects).
Chat: chats in workspaces add to both global and project context over time.
Review memories in Settings
Path: Settings → Memory. Filter memories by type and search by topic. Delete stale facts and update preferences that changed. Export before large reorganizations when you need a portable record.
Understand which work stays on your machine and when a connected service is involved.
Local files and local model workflows stay on your machine. Features using a connected provider like api can/will send the request and selected context to that provider.
Check the active model before sending sensitive material.
Select only the sources needed for the task.
Review memory and project artifacts regularly.
Use local workflows when the job must remain offline.
Recover the flow
Troubleshooting
Work through preview, model, generation, and workflow failures.
A model is not connected
Open Settings, verify the selected provider, and confirm the connection state. Choose a configured local model for offline work.
A node graph stops
Run the smallest failing node and inspect its input. A downstream node cannot repair an empty upstream result.
Generated work ignores a source
Confirm the correct source is selected and refer to it by name. Reduce the selection if unrelated sources compete for attention.
