LABO AI

A visual AI architecture laboratory for composing typed neural blocks, rewiring tensor flows, and generating executable PyTorch in real time.

Comment

Inspiration

Neural-network architectures are powerful, but they are often difficult to inspect. Tensor contracts, routing decisions, parallel branches, and execution order disappear inside large Python files.

LABO AI started with a simple question: what if a neural model could be assembled and understood as a graph of small, typed, executable cards—and what if an AI agent had to use the same explicit tools as a human?

What it does

LABO AI is an agentic desktop laboratory for designing neural architectures visually.

Users can:

  • compose models from more than 100 atomic cards;
  • connect cards through typed elastic ports;
  • inspect synchronized PyTorch code;
  • execute, replay, reset, or step through a graph locally;
  • compare multiple architectures side by side;
  • create reusable PyTorch cards with a visual builder;
  • save custom workspaces and presets;
  • export the complete diagram as SVG or the generated model as Python.

The OpenAI-powered Ask LABO agent can inspect the current graph, search the real card catalog, select compatible components, connect their tensor ports, arrange parallel branches, run the resulting architecture, and report missing capabilities.

In Review mode, every graph mutation can be inspected before it is applied. In Auto apply mode, locally valid plans are executed immediately. The agent can also build a separate architecture without moving or deleting the user’s existing work.

How we built it

LABO AI is an Electron desktop application built with React, TypeScript, Vite, Python, and PyTorch.

A typed intermediate graph representation describes cards, ports, connections, architecture groups, and tensor contracts. The same semantic registry drives the visual library, graph validation, PyTorch generation, local execution, and the tools available to the agent.

A topology-aware XY layout engine assigns stable execution ranks and parallel lanes while reducing cable crossings. PyTorch graphs execute in a separate local Python process through a narrow Electron bridge.

Workspaces and user presets are persisted with IndexedDB. OpenAI API keys are encrypted using Electron safeStorage and are never returned to the renderer after being saved.

Challenges we faced

The hardest challenge was keeping the visual graph, tensor contracts, generated PyTorch, and runtime execution consistent.

Parallel models introduced additional problems: forks and joins had to remain readable, invalid branches could not leave other branches waiting forever, and destructive actions had to target a clearly identified architecture.

We addressed these challenges with explicit architecture boundaries, deterministic placement, isolated execution states, typed connections, named deletion operations, and automated desktop tests.

What we learned

Agentic software becomes more useful and trustworthy when the agent does not receive an unrestricted code editor.

LABO’s agent works through a bounded collection of observable tools: inspect, search, add, connect, create, arrange, run, save, and export. Its actions can therefore be validated by the application and understood by the user.

The same typed contracts that make the visual interface understandable also make agent actions safer.

What’s next

Next, we want to add collaborative preset sharing, signed macOS and Windows releases, deeper architecture-level validation, and reusable compound cards that turn a validated subgraph into a higher-level atomic component.

Our broader goal is to make neural architecture design more visual, executable, and accessible—without hiding the underlying PyTorch.

Share this project:

Updates