A block-based visual programming environment where kids (and adults) design software by snapping blocks together, then AI agents build it.
Elisa is an educational tool that turns block-based visual programming into real working software. Users drag and drop blocks to describe what they want -- goals, features, constraints, visual style, hardware targets -- and a team of AI agents collaborates to build it. The entire process is visible: you watch agents plan, code, test, and deploy in real time.
Grab the latest installer for your platform from Releases:
| Platform | File |
|---|---|
| Windows | Elisa Setup X.Y.Z.exe |
| macOS | Elisa-X.Y.Z.dmg |
- Node.js (LTS) -- required for running tests and agent tools. Elisa will prompt you to install it on first launch if missing.
- Anthropic API key -- entered on first launch, stored securely in your OS keychain.
- Git -- bundled with the Windows installer (MinGit). macOS users typically have it via Xcode command line tools.
Note: The app is not code-signed yet. Windows will show a SmartScreen warning (click "More info" > "Run anyway"). macOS will show a Gatekeeper warning (right-click the app > "Open").
For contributors or anyone who wants to run from source:
Prerequisites: Node.js 20+, an Anthropic API key (ANTHROPIC_API_KEY env var). Optional: Python 3.10+ with mpremote for ESP32 flashing, gcloud CLI for Cloud Run deployment.
git clone https://github.com/zoidbergclawd/elisa.git
cd elisa
npm install # installs root + backend + frontend deps
npm run dev:electron # launches backend, frontend, and Electron windowThis is an Electron desktop app -- dev:electron is the primary dev command. For browser-only development (no Electron window):
npm run dev # backend (port 8000) + frontend (port 5173)See Getting Started for full setup. Tested on Windows and macOS.
Block-Based Design -- Snap together blocks across 14 categories to describe your project: Goals, Requirements, Tests, Style, Skills, Rules, Portals, Knowledge, Minions, Team, Flow, System, Composition, and Deploy. No code required.
AI Agent Team -- A meta-planner decomposes your spec into a task DAG. Builder, tester, reviewer, and custom agents execute tasks with dependency ordering, retries, and inter-agent communication. Specialized agent teammates (Buddy, Scribe, Blueprint, Pixel, and more) pop up during builds to collaborate via chat and interactive canvases.
Live Build Visibility -- Watch the build in a tabbed layout: block editor, mission control with task graph and agent comms, a system tab showing boundary I/O visualization, a tests tab with live pass/fail and pre-generated expectations, and a bottom bar with Trace, Board, Learn, Progress, Health, and Tokens tabs for contextual visibility.
Hardware Integration -- Target ESP32 boards directly via the device plugin system. Built-in plugins for Heltec WiFi LoRa V3/V4 (sensor nodes, gateways with LoRa + OLED), LED blink, and cloud dashboards. Auto-detect, compile, and flash over USB. See Creating Device Plugins.
IoT Sensor Networks -- Build multi-device IoT systems: sensor nodes with DHT22/reed switch/PIR sensors communicate via LoRa radio to gateway nodes that relay data over WiFi to Google Cloud Run dashboards.
Human-in-the-Loop -- Insert "check with me" gates at any point. Agents pause and ask for approval before continuing. Answer agent questions mid-build.
Teaching Moments -- A teaching engine surfaces age-appropriate explanations of programming concepts as agents work, turning every build into a learning session.
Bug Fix Workflow -- After a build, use the "Fix It" flow to target specific bugs. The fix endpoint creates a focused repair task, re-runs tests, and reports results -- no full rebuild needed.
Launch Without Rebuild -- Re-serve a previously built nugget instantly. The launch endpoint finds the built output and starts a built-in static file server without re-running the build pipeline.
Skills and Rules -- Create reusable prompt snippets (skills) and trigger-based rules that shape agent behavior across builds.
Portals -- Connect agents to external systems via MCP servers, CLI tools, and hardware serial I/O.
Elisa is an IDE for agentic spec-driven development -- a paradigm where the artifacts the software creator cares about are the specs and the tests, not the code. Users define what they want through visual blocks; AI agents figure out how to build it. The code is a generated artifact, like a compiled binary.
Every block in the IDE maps to a real AI engineering primitive:
| Elisa Primitive | Block Examples | AI Engineering Concept |
|---|---|---|
| Goal | nugget_goal, nugget_template |
Top-level system prompt. The root instruction that drives the entire agent pipeline. |
| Requirement | feature, constraint, when_then, has_data |
Prompt constraints and acceptance criteria. Decomposed by the meta-planner into the task DAG. |
| Skill | use_skill |
Reusable prompt snippets injected into agent context. Multi-step flows with branching (ask user, run agent, invoke another skill). |
| Rule | use_rule |
Pre/post hooks on agent behavior. Trigger-based constraints that fire on events like before_commit or on_test_fail. |
| Portal | portal_tell, portal_when, portal_ask |
Tool use: MCP servers, CLI commands, hardware serial I/O. Portals are the agent's hands -- how it reaches the outside world. |
| Minion | agent_builder, agent_tester, agent_reviewer, agent_custom |
Specialized agent roles with distinct system prompts, tool access, and token budgets. Custom minions let users define new roles. |
| Flow | first_then, at_same_time, check_with_me |
DAG dependencies, parallel execution, and human-in-the-loop gates. Controls the orchestration topology. |
| Deploy | deploy_web, deploy_esp32, deploy_both |
Deployment targets. Web deploys locally or to Cloud Run; hardware compiles and flashes MicroPython over USB. |
The visual block workspace compiles to a NuggetSpec -- a Zod-validated JSON schema that is the single source of truth. The orchestrator consumes the spec, the meta-planner decomposes it into tasks, and agents execute against it. Users iterate on the spec and re-run; the code regenerates.
Electron Shell (main.ts)
|
+-- Browser (React SPA) <──REST + WebSocket──> Express Server
| |
Blockly Editor Orchestrator Pipeline
Mission Control PlanPhase -> ExecutePhase
System Panel TestPhase -> DeployPhase
Bottom Bar Fix + Launch (post-build)
AgentRunner (Claude Agent SDK)
GitService, TestRunner
HardwareService, DeviceRegistry
TeachingEngine, NarratorService
Four-phase pipeline: plan (meta-planner decomposes spec into task DAG) -> execute (up to 3 agents run in parallel via streaming Promise.race pool) -> test (pytest/node test runner) -> deploy (web preview, device flash, or cloud deploy).
Each agent runs as an isolated SDK query() call. No database -- all session state is in-memory with optional JSON persistence for crash recovery. See ARCHITECTURE.md for the full system design.
elisa/
frontend/ React 19 + Vite + Blockly SPA
src/components/
BlockCanvas/ Blockly editor + block definitions + interpreter
MissionControl/ Task DAG, agent comms feed, narrator, metrics
BottomBar/ Git timeline, test results, board output, teaching
shared/ GoButton, modals, toasts, avatars, flash wizard
Skills/ Skills CRUD editor + visual flow editor
Rules/ Rules CRUD editor + template library
Portals/ Portals CRUD editor + registry
backend/ Express 5 + WebSocket server
src/services/
orchestrator Build pipeline controller
agentRunner Claude Agent SDK runner
metaPlanner NuggetSpec -> task DAG decomposition
gitService Per-session git repo management
testRunner pytest / node test execution + coverage
hardwareService ESP32 detect/compile/flash/serial
deviceRegistry Device plugin manifest loader
cloudDeployService Google Cloud Run deployment
teachingEngine Concept curriculum and deduplication
narratorService Build event narration (Claude Haiku)
skillRunner Multi-step skill execution engine
portalService MCP + CLI portal adapters
devices/ Device plugin system
_shared/ Common MicroPython libs (LoRa driver, board abstraction)
heltec-sensor-node/ DHT22/reed/PIR sensor with LoRa TX
heltec-gateway/ LoRa RX + WiFi relay + OLED display
cloud-dashboard/ Google Cloud Run dashboard scaffold
heltec-blink/ Simple LED blink example
electron/ Electron main process + IPC bridge
docs/ Documentation (see below)
- Getting Started -- Prerequisites, install, first build
- User Manual -- Complete guide to using Elisa
- Architecture -- System-level design overview
- API Reference -- REST endpoints, WebSocket events, NuggetSpec schema
- Block Reference -- Complete block palette guide
- Device Plugins -- Device plugin system overview
- Creating Device Plugins -- Guide to building new device plugins
- Master Index -- Full directory map, doc map, and key source files
| Variable | Required | Default | Description |
|---|---|---|---|
ANTHROPIC_API_KEY |
Yes | -- | Claude API key for agent execution |
CLAUDE_MODEL |
No | claude-opus-4-6 |
Model for builder/tester/reviewer agents |
NARRATOR_MODEL |
No | claude-haiku-4-5-20251001 |
Model for narrator messages |
PORT |
No | 8000 |
Backend server port |
CORS_ORIGIN |
No | http://localhost:5173 |
CORS origin for dev mode |
OPENAI_API_KEY |
No | -- | Optional, enables audio features (STT via Whisper, TTS via OpenAI TTS) |
MIT -- (c) 2026 Zoidberg