Canva's AI assistant can now make multiple tool calls in sequence to fulfil a single design request. You describe what you want, and the assistant decides which tools to invoke — image generation, template selection, layout adjustment, brand colour application, text fitting — coordinating them into a finished design. This is the multi-tool AI orchestration pattern arriving in a consumer product used by hundreds of millions of people. For product and engineering teams, there are two distinct things to take from this: first, what it means for how you integrate AI into your own product's design and content creation workflows; and second, what the underlying engineering pattern of multi-tool AI orchestration looks like, and how to build it into your own systems.
What We'll Cover
What Multi-Tool AI Orchestration Actually Is
Multi-tool AI orchestration is the pattern where a language model or AI assistant decides which tools to call, in what order, and with what parameters, to fulfil a user request — without the user specifying the sequence. This is different from AI-assisted workflows where the human selects tools and the AI helps execute each one. In the multi-tool pattern, the AI is making the sequencing and selection decisions. Canva's implementation in design is one instance of a pattern appearing across software categories: in coding (agentic IDEs), in data analysis (AI agents that write SQL, execute queries, and interpret results), in email management, and now in visual design. The engineering architecture behind this capability is a tool-calling loop: the AI model is given a set of tool definitions, makes a decision to call one or more tools with specific parameters, receives the results, and decides whether the task is complete or whether further tool calls are needed. OpenAI's function calling, Anthropic's tool use, and similar APIs all implement this pattern. The complexity of building useful multi-tool AI features is almost entirely in defining the tools well — clear function signatures, well-documented parameters, predictable output formats — rather than in the orchestration logic itself.
The Design-to-Code Pipeline in 2026
The traditional design-to-code pipeline has three stages: design (Figma or Sketch), handoff (specifications, redlines, assets), and implementation (frontend engineers writing CSS and component code). Each stage involves significant information loss and translation effort. AI is compressing this pipeline in both directions. From the design side, tools like Canva's agentic assistant and Figma AI are reducing the effort to go from brief to visual design. From the code side, tools like V0, Locofy, and direct Figma-to-React pipelines are reducing the effort to go from design to working code. The middle handoff stage — historically the most painful — is being squeezed from both ends. What this means practically for product teams: the bottleneck is shifting from implementation to decision-making. It is now faster to generate multiple design variants and convert them to working code than it was to specify a single design for a human frontend engineer to implement. Teams that restructure their product process around this new speed — with faster iteration loops, earlier user testing on working prototypes, and a smaller ratio of design-time to testing-time — will ship better products faster.
Engineering Patterns for Multi-Tool AI
If you are building multi-tool AI features into your product — building the equivalent for your domain — the engineering patterns are relatively straightforward:
- Tool definition quality is everything — the AI's tool selection is only as good as your tool definitions. Each tool needs a clear, specific description of what it does, when to use it versus alternatives, and what its inputs and outputs look like. Vague tool descriptions produce unreliable tool selection
- Design for parallel tool calls — modern tool-calling APIs support parallel execution of independent tool calls. If your orchestration requires multiple tools that do not depend on each other, invoke them in parallel. This dramatically reduces latency
- Build explicit tool chaining logic — some tool sequences are predictable: if a user asks for a product page, you will always need image, copy, and layout tools. Make common chains explicit in your system prompt rather than relying purely on the model to discover them
- Handle partial failures gracefully — when one tool in a multi-tool sequence fails, the AI should either retry with different parameters, skip the failed step with a clear explanation, or abort with a meaningful error. Design your tool error responses to give the AI enough information to make good decisions
- Log all tool calls and their results — multi-tool AI debugging requires complete logs of every tool invocation, its parameters, and its output. Without this, diagnosing why the AI made a particular tool selection decision is nearly impossible
What This Means for Engineering Teams
The design-to-code pipeline transformation is an opportunity to rethink how frontend engineering resources are deployed. If generating design variants and converting them to working code is now largely automatable, the high-value engineering work is in the layers that AI cannot handle well: complex interactive state management, performance optimisation, accessibility engineering, and integration with backend systems. Teams that can hire frontend engineers who understand both the AI tooling layer and the high-value engineering work — rather than spending time on CSS and layout that AI can now generate — will build better products with smaller teams. For teams building AI-driven design or content creation features into their own products, our AI automation practice covers multi-tool orchestration architecture, tool definition design, and integration with existing product workflows.
Frequently Asked Questions
What is the difference between AI-assisted design and agentic design?
AI-assisted design means the human selects which AI features to use at each step. Agentic design means the AI decides which tools to invoke and in what sequence, based on a high-level request. The human specifies the goal; the AI figures out the steps. Canva's multi-tool calling represents the shift to agentic design in a mainstream consumer product.
How does AI tool calling work technically?
Tool calling is a feature of modern language model APIs where you define a set of functions with JSON Schema descriptions. The model can choose to call one or more of these functions with specific parameters, receive the results, and continue generating based on those results. The loop continues until the model decides the task is complete. No custom training is required.
Will AI replace frontend engineers?
Not replace — but significantly change what the role means. AI tools can now handle standard UI implementation (layout, styling, component boilerplate). The high-value frontend engineering work shifts to complex interactivity, performance optimisation, accessibility, and the AI integration layer itself. Frontend engineers who develop fluency with AI tooling will be more productive and more valuable, not less.
How should product teams change their design-to-code process?
Compress the handoff stage — use AI to generate working code prototypes directly from design specs early, before designs are finalised. Test with users on working code rather than Figma prototypes. Iterate based on real user behaviour. The goal is less time in design-to-code translation and more time learning from real user interactions.
What are the common failure modes of multi-tool AI systems?
The most common are: tool selection errors from vague tool descriptions; cascade failures when one tool's bad output is passed to the next; infinite loops where the model keeps calling tools without completing the task; and opaque failures that are hard to debug without comprehensive tool call logging. All of these are engineering problems with engineering solutions.