---
title: "Building canvas-native agents: lessons from Laya"
description: "Luma is building canvas-native agents that can read and understand a creative workspace and work within it. On a board that is in progress, references sit beside generated variations, notes capture decisions, and frames and groups bring ideas together for comparison. An agent needs that context to help with the work."
canonical: "https://lumalabs.ai/news/building-canvas-native-agents"
source: "https://lumalabs.ai/news/building-canvas-native-agents.md"
---

# Building canvas-native agents: lessons from Laya

_By Aiwei Wu (Product Engineer) · November 16, 2026_

![Building canvas-native agents that can read and understand a creative workspace.](https://cdn.sanity.io/images/2ylxvaa2/production/a36120c0ca4be2c23210b748919d8cf2dae7cb16-1920x1080.png?w=2048&fm=webp&q=75&fit=max)

At Luma, we’re building canvas-native agents that can read and understand a creative workspace and work within it. On a board in progress, references sit beside generated variations, notes capture decisions, and frames and groups bring ideas together for comparison. An agent needs that context to help with the work.

When a creative working on an ad asks, _“Bring these campaign directions together, keeping the variations with their references, and lay them out side by side for review,”_ the agent needs to identify those relationships and preserve them as it changes the layout.

Laya, our canvas-organization subagent, gave us a practical test of this approach. We extended the view of Orca, Luma’s main agent, to include canvas objects and their relationships alongside media. Here we describe how agents read the board, how Orca hands work to Laya, and how layout code checks and applies changes while people keep working on the canvas.

![The agent loop: Laya reads, plans, and submits checked batches; the server verifies recorded changes against Laya’s reported result.](https://cdn.sanity.io/images/2ylxvaa2/production/13605fdfa7487fdd1c28acd6c882bab5579fc2e6-1920x1080.jpg?w=2048&fm=webp&q=75&fit=max)

---

## Reading the canvas

An agent reviewing that campaign needs the cues humans would use: frame titles, membership, and nearby notes. Reading the canvas means exposing those objects and relationships alongside the media assets.

An early bug showed why the read layer mattered. Frame names visible to users were missing from some agent-facing reads because the code checked for a different shape type. The model could not use names it never received; we had to fix the representation.

Shared finding and search tools expose JSON views at several levels of detail: compact rows to survey results, detailed cards to inspect an item, and references to identify it across calls. These connect media with canvas objects and their relationships, giving the agent a path from discovery to inspection and action:

The agent can inspect individual items or expand a container without reading every detail on the board. Parent–child relationships give it a tree-like view of pages, frames, and their contents, so membership need not be inferred from proximity. Screenshots alone do not provide the explicit identities and relationships needed for precise edits.

During execution, version checks prevent Laya from combining pages of a snapshot taken from different board states, and tool receipts report what changed.

---

## Why a subagent

With that shared read foundation, Orca, Luma’s main agent, can delegate organization to Laya as a specialist subagent. Orca passes the user’s intent, permitted scope, and constraints; Laya gathers the board detail it needs, plans and applies changes, and reports the outcome back. The server captures the scope and saves a layout recovery snapshot before the job starts.

This main-agent/subagent structure gives organization its own working context. Descriptions, grouping decisions, plans, and write receipts stay with the specialist instead of filling Orca’s ongoing conversation. It also lets us customize Laya’s tools, instructions, and model configuration independently as we learn what works for different organizing tasks.

The cost of the split is the handoff. Laya does not rely on the full conversation, so Orca must include the relevant constraints and any asset names the user has confirmed. If the scope omits a destination frame the user intended, Laya cannot simply treat it as editable. It must work within the permitted scope or report what remains unresolved.

![A sanitized production run: Orca defines the task and boundaries; Laya revises a rejected placement, commits the layout, and returns the verified result and its limits.](https://cdn.sanity.io/images/2ylxvaa2/production/7bbd74682824bcd7c722e42b1c5e3112acf5bc27-1920x856.jpg?w=2048&fm=webp&q=75&fit=max)

---

## Planning and placement

The model decides what belongs together and in what order; code decides where it goes. Laya builds on our shared canvas placement engine, which already supported relative placement and auto-layout. We extended that foundation for frame growth and collision-aware placement, then added section plans to coordinate layout within and across sections.

In one paired test of the same scoped-layout request, runtime fell from 195 to 22 seconds and committed write batches from 12 to one after a fix to parent-local coordinates and measured text bounds.

Operation batches remain available for direct moves and other supported edits; section plans provide a higher-level option for organization.

A simplified plan illustrates the boundary; these names stand in for actual item references:

`{  
  "plan": [  
    {  
      "section": "References",  
      "items": ["inspiration_post", "product_photo"]  
    },  
    {  
      "section": "Product A",  
      "items": ["first_try", "variation", "selected"]  
    }  
  ]  
}`

In this example, the model places the product photo with the references and the selected variation after the earlier attempts. The layout engine uses measured item sizes to calculate rows, spacing, and coordinates. Titles and annotations can be included in the plan.

Tool contracts matter too. Malformed reference lists and unsupported parameters caused retries in early runs. We normalized inputs where intent was unambiguous and improved refusal messages so the agent could correct a request. Batching related edits reduces the number of calls, but does not eliminate invalid plans.

---

## Editing a shared board

Understanding an item does not grant permission to edit it. Laya works within a permitted scope, but moving selected items can require checked adjustments to surrounding containers. On a shared canvas, even edits to different items can compete for space. Deciding when to preserve nearby placements, adjust them, or ask for broader scope remains an evolving product and engineering challenge.

The server applies changes in checked, bounded batches. A batch commits as a unit; an organizing run can contain several batches, so an interrupted run can leave useful work already applied. Locks and checks for items moved or resized during the run protect user placements. Newly added items remain outside the captured scope and can be organized in a later pass.

Recovery requires knowing whether a write landed. If the server cannot confirm a batch’s outcome, it blocks further writes for that run rather than risk applying the changes twice. At completion, it checks reported membership and preservation against fresh board state and the recorded writes. An unavailable verification is not reported as complete.

Undo (Revert layout on the organizer’s card) restores changes that can be safely reversed, preserves later edits, and reports anything it skips. A saved layout should not overwrite a user’s newer decisions.

In a controlled test with nested frames, moving two images triggered container reflow. After Undo, readback confirmed that both frames and all seven images had returned to their original positions and dimensions, and the new destination frame was removed.

Preserving content and validating geometry are necessary, but they do not tell us whether a board is easier to work with.

---

## What we observed in testing

Human judgment is central to evaluating a creative workspace. In an early blind comparison, with left/right placement randomized, reviewers preferred the workflow with Laya more often than the workflow without it. We treat this small staging sample as an encouraging direction. Feedback from people working on real boards also helps us understand whether grouping, labels, and layout make their work easier.

Each pair was generated separately from the same prompt, with an organizing request added to one arm, so this comparison measured the full workflow rather than a change to identical starting assets.

![Same prompt, two workflows.](https://cdn.sanity.io/images/2ylxvaa2/production/1b19bd7d7e6764a58d77ace6304bf7e5979907e7-1921x1849.jpg?w=2048&fm=webp&q=75&fit=max)

In manual fixture reviews, we saw useful grouping by meaning, while storyboard and timeline sequencing needed more attention. Subsequent low- and medium-effort runs reported **COMPLETE** on storyboard fixtures where the earlier review had found ordering problems. This highlighted the need to judge the intended sequence alongside the execution report.

In the requests we tested, Orca delegated most organizing tasks to Laya and none of the look-alike creative tasks. Its final replies matched Laya’s reported status on the workflow boards we checked.

In our small staging comparison, median time to the first asset was similar with and without an organizing request. Organization added time after generation, with the larger of the two timed fixtures taking longer.

The next step is to bring these fixtures into repeatable nightly coverage, combining before/after board-state checks with human judgments of grouping, order, readability, and navigation.

---

## What we learned

**Let code own geometry, and make it exact.** The scoped-layout test exposed how parent-local coordinates and measured text bounds could cause corrective writes even when code handled placement.

**Treat completion as an execution signal, not a quality score.** The storyboard findings point to a concrete requirement for the next evaluation rubric: check intended sequence separately from job completion, preservation, and geometry.

**Treat permission boundaries as part of layout design.** Staging failures showed that moving selected images also required changing their generation containers. We changed the boundary to allow scoped images to leave finished generation frames, with checked reflow of their containers.

**Optimize model round trips as well as writes.** Model calls accounted for most job time in the low-effort fixture runs we inspected, making fewer unnecessary calls an important optimization target.

---

## What comes next

The next questions come from people using the canvas: what context does each task need, when should an agent make room around a selection, and how should agents coordinate work that overlaps? Cross-page organization and broader coordination remain future work. These decisions will shape how our agents support creative work beyond a single organizing request.

---

## Acknowledgements

Thanks to Andy Gavin for building our agent’s board search and the shared read format, and to Sharang Pai, Mack Cooper, Sabrina Day and Huijia Yu for the evaluation work. Thanks to Mila Wilson for her support throughout the project, and to our designers, Forward Deployed Creatives, Dream Lab, and the rest of the Luma team for their feedback, testing, and support.