Skip to main content
Beta. Build with AI (Autobuild) is available in MagOneAI Studio as a beta feature and is under active development. The two-step generate-then-synthesize flow described here works today; behavior and coverage will continue to expand.

​
Purpose

Build with AI (also called Autobuild) turns a plain-language description into a working workflow. You write what you want the workflow to do, it produces a reviewable build plan, and once you approve it, it synthesizes a runnable workflow onto your canvas in MagOneAI Studio. It is a starting point, not a black box. Autobuild never publishes anything from a prompt alone: the plan is a human checkpoint you read and edit before a single node is created, and the synthesized workflow lands as a draft you can inspect, adjust, and run like any hand-built workflow. Autobuild is grounded in what your project already has: it reads your real MCP tool catalog and knowledge bases, so it reuses existing tools instead of inventing ones that don’t exist.

​
How it works

Autobuild runs in two turns with a review step in between: generate a plan, then synthesize it.
1

You describe the workflow

You write a natural-language prompt describing what the workflow should do. The prompt is bounded (up to 8,000 characters) and treated as untrusted input, sandboxed before it reaches the model.
2

A plan is generated

Autobuild drafts a build plan: a summary, the interface type (form, chat, or hybrid), the input fields, the capabilities it needs, the agents to create, and the ordered steps. Generation is grounded in your project’s actual MCP tool catalog and knowledge bases so it reuses what already exists.
3

The plan is validated and repaired

Before you ever see it, the plan runs through a validate-and-retry loop. Autobuild checks that agents have names, roles, and instructions, that inputs resolve, that referenced knowledge bases exist, and that the plan can actually be built. If a check fails, it regenerates with the exact issues as feedback until the plan is sound or it gives up (rather than handing you a plan that looks fine but won’t build).
4

Capabilities are matched to tools

Each capability in the plan is matched against your project’s MCP tool catalog. Confident matches become tool bindings. Anything that can’t be matched to a real tool is reported as missing, with a copy-paste build spec for the MCP server you’d need to add.
5

You review and edit the plan

Nothing is persisted yet. You read the plan, adjust it, and decide whether to proceed. This is the cheap checkpoint before any nodes, agents, or versions are created.
6

The plan is synthesized onto the canvas

When you approve, Autobuild maps the plan into agents and a workflow definition, validates it against the same gates as a manual canvas save, lays it out as positioned, connected nodes, and persists it as a draft use case with an autobuild version snapshot.
The generate step is bounded by a total time budget (180 seconds). If a slow model run exceeds it, Autobuild returns a timeout result instead of hanging the request, and no partial workflow is created.

​
How to use

​
Write the prompt

Describe the outcome you want, the inputs the workflow will receive, and any tools or knowledge it should use. The more concrete you are about inputs and the desired output, the closer the first plan lands. Autobuild picks the interface type for you: a form workflow for structured inputs, chat for a conversational assistant, or hybrid for both.

​
Review the plan

The generate step returns a plan without saving anything. Each plan carries: The result also carries a status that tells you what you’re looking at:
A needs_mcp result means the workflow depends on a tool that isn’t connected in your project. Add the MCP server from the included build spec before synthesizing, otherwise those capabilities land unbound and the agents that need them won’t be able to act.

​
Synthesize the workflow

Approve the plan to synthesize it. Autobuild creates one agent per planned agent, wires the steps into a workflow definition, and validates the whole thing against the same rules a manual save enforces. If validation fails, nothing is committed, so a bad plan never leaves a half-built workflow behind. By default the workflow is saved as a draft, so you review it on the canvas before it goes live. You can opt into publishing it immediately, but the safe default keeps a human between the prompt and a live workflow. Every synthesis is recorded as a workflow version marked autobuild, so the provenance is always visible in the version history.

​
Rebuild an existing workflow

Autobuild can also target a workflow that already exists rather than always creating a new one. Applied this way, it replaces that use case’s workflow with the newly synthesized one and rebuilds its agents; the previous workflow is preserved as a version snapshot you can restore. This is the co-pilot path for regenerating a workflow from an updated description.
Autobuild covers agent, tool, conditional, and respond steps today. parallel and foreach steps are not synthesized yet, so build those by hand on the canvas after synthesis if your workflow needs them.

​
Use cases

​
Bootstrap a new workflow from a description

Scenario: You know the outcome you want but not the exact node layout.

​
Discover the tools a workflow needs

Scenario: You’re not sure which integrations a workflow requires. Autobuild matches each capability against your connected tools and returns a needs_mcp result listing exactly what’s missing, with a build spec for each one. You add those MCP servers, regenerate, and get an ok plan.

​
Regenerate a workflow after the requirements change

Scenario: An existing workflow’s scope has grown and you’d rather restate it than re-wire it. Point Autobuild at the existing use case with an updated description. It rebuilds the workflow in place and keeps the old version as a snapshot, so you can compare or roll back.

​
Best practices

Name the inputs the workflow receives and describe the result you want. Concrete inputs and a clear target output produce a tighter first plan and fewer review cycles.
Autobuild reuses the MCP tools and knowledge bases already in your project. Connect the integrations you expect the workflow to need first, so capabilities bind to real tools instead of coming back as needs_mcp.
The plan is the cheap checkpoint before anything is created. Read the agents, steps, and capabilities carefully and edit there, rather than synthesizing a rough plan and untangling it on the canvas.
Leave synthesized workflows as drafts and run them yourself before publishing. Auto-publishing skips the human check that keeps a prompt from becoming a live workflow.
Autobuild synthesizes agent, tool, conditional, and respond steps. If your workflow needs parallel branches or a foreach loop, add those on the canvas after synthesis.
Use Autobuild to get from a blank canvas to a working first draft in one pass, then refine it like any other workflow. It scaffolds the agents, wiring, and tool bindings; the canvas is still where you tune instructions, add branches, and test before publishing.

​
Next steps

Workflow overview

Understand how workflows execute once Autobuild has built one

MagOneAI Studio

The builder portal where you generate, review, and refine workflows

Agent node

Tune the agents Autobuild creates for each step

Tools overview

Connect the MCP tools capabilities bind to