Skip to main content
Darby

Structure complex AI work like a project, not a thread.

Darby pairs a capable AI workspace (models you choose, compare mode, multimodal input, voice, optional local models) with Darby Labs: a visual canvas where nodes form a graph, independent steps run in parallel, and outputs become memos, tables, slides, apps, images—and autonomous agents when you need depth.

Darby
Darby Labs · workflow canvas
Canvas
Lay out your work
Infinite canvas with nodes for research, writing, data, slides, apps, and agents—connected the way real projects branch.
Agents
Run multi-step flows
Labs agents plan, use tools, spawn sub-agents, and pause to ask you when intent is unclear.
Ship
Deliverables, not just chat
“ZIP bundle ready: memo, charts, and slides from your last run.”
“GitHub push completed with your commit message.”
Model mixing
Skill templates
Compare mode
Infinite canvas

Infinite canvas.

Lay out work on an infinite canvas: draggable nodes, edges, a command palette, and a node palette for deep research, chat and prompt steps, memos, lists, tables, slides, apps, images, web pages, YouTube, inputs, files, data sources, notes, frames—and Labs agents. Skill templates and quick layouts jump-start analysis, decks, reports, and more.

Canvas sketch
Nodes & edges
Deep research
Web-grounded investigation feeding downstream nodes
Memo / table
Structured text and data in flow
Slides
Deck-style output chained from research
Labs agent
Autonomous run with tools, sub-agents, pauses
Quick layout
Research → table → memo: one-click starters, then you edit the graph.
Agent run
Timeline
Web
Files
Python
HTTP
Sub-agents
Reasoning
72%
Visible thinking steps before tool calls
Human-in-the-loop
Paused: confirm scope before large crawl
Bundle
88%
Summary + files ready for export
Labs agents

Autonomous agents.

Labs agents show reasoning in the thought stream and timeline, search and read the web, work with files, run sandboxed shell and Python, call HTTP APIs, produce charts and documents, generate images, structure data into tables, delegate to sub-agents on the same canvas, and pause to ask clarifying questions before heavy runs.

Ship outcomes

Deliverables, not threads.

Download outputs as a ZIP, push artifacts to GitHub, and wire automation: public execute API, inbound webhooks (e.g. Zapier), Slack notifications, MCP servers as tools, and cron schedules for recurring runs.

Ship queue
Export & notify
Ship · Event
ZIP downloaded: memo + charts + slide deck from last workflow.
Ship · Event
Execute API returned 200; downstream automation picked up the result.
Ship · Event
GitHub: branch pushed with your commit message.
Automation
Webhook received → canvas updated → Slack notified when the agent node completes.

Planonthecanvas,shipfinishedwork

The graph you lay out tells Labs what to run and in what order. Agents return memos, decks, code, bundles, and pushes to GitHub—concrete outputs, not another endless chat. Those results feed the next iteration on the canvas.

Canvas
Lay out the work

Nodes and edges make parallel work and dependencies visible—research, writing, data, slides, apps, and agents on one surface.

Agents
Run with depth

Labs agents plan, use tools, collaborate with sub-agents, and pause for your input when it matters.

Ship
Deliverables out

ZIP bundles, GitHub pushes, API calls, and integrations so outcomes leave the workspace.

Iterate
Compound the system

Saved canvases and templates turn wins into repeatable flows. The next run starts smarter.

The longer Darby runs on a project, the more reusable your canvases and templates become.

Each node is its own run

Every node carries its own slice of the job—context, model choice, and execution—so parallel branches and reruns do not collapse into one brittle chat thread.

Recenthighlights

Product notes from building Darby Labs and the pro workspace.

Highlight
From thread to graph
Why spatial canvases beat linear chat for parallel work, handoffs, and reuse.
Read more →
Highlight
Templates that ship
Skill templates and saved canvases turn one-off wins into repeatable playbooks.
Read more →
Highlight
Integrations that close the loop
Execute API, webhooks, Slack, MCP, GitHub, and schedules—so finished work leaves the canvas.
Read more →

Try Darby now.

You can be up and running in minutes. Organize AI work as a structured project on the canvas—not a single long thread—then export and ship real deliverables from Darby Labs.