Jaaz

Jaaz is an open-source multimodal AI design agent that lets you create images and videos by drawing, sketching, and annotating on an infinite canvas rather than writing text prompts. Built for creators, marketers, and design teams who need high-quality visual output without surrendering their data to cloud services, Jaaz runs locally on Windows and macOS via an Electron desktop app, with optional Docker-based enterprise deployment.

Under the hood, Jaaz combines a React-based Excalidraw canvas with a Python FastAPI backend and a LangGraph multi-agent swarm. A Planner agent interprets the user’s spatial drawings and annotations, then hands off tasks to a specialized Image/Video Creator agent that routes generation requests to the appropriate model — whether that’s a local ComfyUI or Ollama instance, or a cloud API like GPT-4o, Midjourney, VEO 3, Kling, or Sora. Character and style coherence is maintained across multi-step generation tasks.

The Magic Canvas interaction model — where arrows, sketches, and drawn annotations become AI instructions — sets Jaaz apart from chat-based or prompt-box AI image tools. Magic Video extends this to timeline-based video creation: annotate frames with movement directions or scene descriptions, and the AI generates the sequence. Real-time collaboration, a built-in media library, and cross-platform packaging round out the feature set for teams and individual creators alike.

What You Get

• Magic Canvas - Draw directly on an Excalidraw-powered infinite canvas; point with arrows, sketch rough shapes, or annotate reference images and the AI generates or refines content without requiring any text prompts.
• Magic Video generation - Create AI-generated videos by annotating a visual timeline with movement directions and scene descriptions; the system generates each frame sequence following your spatial instructions.
• Multi-agent AI swarm - A LangGraph Planner agent interprets intent and hands tasks to a specialized Image/Video Creator agent, maintaining character and style coherence across multi-step generation workflows.
• Local and cloud model flexibility - Connect to local inference backends (ComfyUI, Ollama) for fully offline operation, or route to cloud APIs (GPT-4o, Midjourney, VEO 3, Kling, Sora) within the same session and UI.
• Infinite canvas with real-time collaboration - Manage multi-scene visual narratives across unlimited canvas space, link layouts together, and collaborate with teammates in real time.
• Built-in media and prompt library - Organize, reuse, and share visual assets and prompt templates directly within the app, with IndexedDB-backed caching for fast retrieval.
• Cross-platform desktop app - Electron-packaged installers for Windows (NSIS), macOS (DMG), and Linux (AppImage/DEB), with auto-update support and embedded ComfyUI lifecycle management.

Common Use Cases

• Social media product photography - A small business owner sketches a product arrangement on the canvas, adds lighting annotations, and generates consistent 9:16 shots for multiple platforms without uploading customer images to a cloud service.
• Short-form video content production - A content creator draws a storyboard with camera movement arrows on a video timeline and Jaaz generates a polished AI video sequence using VEO 3 or Kling for TikTok or Instagram Reels.
• Multi-scene brand campaign storyboarding - A design agency team collaborates in real time on an infinite canvas to lay out a ten-scene ad campaign, generating character and environment variations with local ComfyUI models while keeping assets off external servers.
• Enterprise marketing asset production - A corporate design team deploys Jaaz via Docker on a private server, uses the enterprise cloud edition for multi-user access, and produces marketing visuals that never leave the organization’s own infrastructure.
• AI-assisted concept prototyping - A product designer sketches rough UI mockups and annotates interaction flows on the canvas, using the AI agent to rapidly generate visual alternatives and iterate on visual direction without manual prompt engineering.

Under The Hood

Architecture Jaaz is structured as a three-tier desktop application: an Electron 35 shell manages the desktop lifecycle and IPC bridging, a React 19 frontend provides the interactive canvas and chat UI, and a Python FastAPI backend hosts the AI orchestration layer. The backend organizes work into FastAPI routers and a service layer, with a LangGraph multi-agent swarm at its core — a Planner agent interprets user intent and delegates to a specialized Image/Video Creator agent via langgraph-swarm handoff tools. State management on the frontend uses lightweight Zustand stores, while TanStack Router handles file-based routing and React Query provides persistent caching via IndexedDB. The architecture is reasonably layered, though the AI pipeline mixes Python service logic with Electron-spawned ComfyUI subprocesses, creating some opacity in the cross-process data flow.

Tech Stack The frontend is React 19 with TypeScript, built by Vite, using Excalidraw as the primary canvas substrate and tldraw for supplementary drawing primitives. TanStack Router and React Query handle navigation and server state; Zustand provides lightweight local state; socket.io-client enables real-time WebSocket communication with the backend. The Python backend runs FastAPI with uvicorn and python-socketio for bidirectional communication, LangGraph with langgraph-swarm for multi-agent orchestration, and LangChain adapters for OpenAI and Ollama. Packaging uses electron-builder targeting Windows (NSIS), macOS (DMG), and Linux (AppImage/DEB), with PostHog analytics and i18next internationalization embedded in the frontend.

Code Quality Test coverage is limited — three JavaScript test files exist for the ComfyUI installer module, using console.log-based assertions rather than a structured testing framework, and the Python service layer has no automated tests. Type safety is present but inconsistently enforced, with several type: ignore pragmas in the Python codebase and some TypeScript files relying on implicit inference. Error handling in the LangGraph pipeline catches broad exceptions and logs them without structured propagation or custom error types. The codebase contains substantial Chinese-language comments alongside English docstrings, which creates maintainability friction for international contributors. ESLint with TypeScript rules and Prettier enforce frontend style, while Ruff and Black handle Python formatting, but no CI configuration was found in the repository.

What Makes It Unique The core innovation is the Magic Canvas interaction model: users communicate with the AI by drawing spatial gestures, pointing with arrows, and annotating reference images directly on an Excalidraw canvas rather than typing prompts. The LangGraph swarm architecture underpinning this — with a Planner agent that interprets spatial intent and hands off to generation specialists — is a genuine architectural differentiator from single-agent or simple pipeline approaches. The dual-backend strategy, connecting local ComfyUI and Ollama instances alongside cloud APIs like Midjourney and VEO 3 within a single session, is also distinctive. The ComfyUI lifecycle manager (auto-install, process management, version tracking) embedded directly in the Electron main process means users get local AI inference without separate setup steps.

Self-Hosting

Jaaz is released under a custom dual-license model: the Jaaz Community License and a paid Commercial License. The Community License is genuinely free for individual personal use — including using generated content commercially — but organizations face significant restrictions. Businesses may only run the unmodified, out-of-the-box version for evaluation or non-commercial purposes; multi-user team deployment, any source code modification, redistribution, or embedding Jaaz in another product all require a Commercial License. This is a proprietary source-available model, not an open-source license by OSI definition, which has real implications for forks, customization, and long-term vendor independence.

Running Jaaz yourself means maintaining an Electron desktop application plus a Python FastAPI backend, with optional local AI inference via ComfyUI or Ollama if you want offline generation. The desktop app handles packaging and auto-updates, but enterprise deployments via Docker require managing the containerized server, ensuring Python 3.12+ and Node.js are available, and handling cross-platform installer builds if distributing to your team. Backups, uptime monitoring, and scaling beyond a single host are entirely your responsibility. The absence of a CI pipeline in the public repository means you are also managing testing and quality assurance for any environment-specific configurations.

The team and enterprise cloud edition (mentioned in the README) offers private or on-premises Docker deployment with commercial licensing and access to the full feature set available on jaaz.app — including multi-user access, official technical support, and online model integrations that may not be available in the community build. If your team needs guaranteed uptime, managed upgrades, or compliance documentation, the commercial tier addresses those gaps, though pricing requires contacting the team directly. The free tier trades operational control for all the overhead of self-hosting a multi-process AI application.