Canvas and file are one design

A common failure in tools that serve both operators and developers is the second definition. The operator has a visual version. The developer has a code version. Someone has to keep them in step, and eventually nobody does. Agency Studio avoids this by refusing to have two definitions. The canvas and the file are one design.

Two views, one thing

When an operator draws an agent on the canvas, the drawing is the agent. When a developer opens the same agent as a file, the file is the agent. These are not two artifacts that describe the same intent. They are two ways of looking at a single design, the way a spreadsheet can be seen as a grid or as formulas.

A change in either view is the same change. If the operator moves the approval step on the canvas, the file reflects it. If the developer adds a reading step in the file, the canvas shows it. There is no export, no import, and no step where someone has to decide which view is the truth.

Why operators need the canvas and developers need the file

The operator owns the outcome of the desk. They know the work, and they need to see the agent in a form that matches how they think about the work: a sequence of steps with the pause where the sign-off is and the calls where the systems are. The canvas is that form. An operator can read it, walk a colleague through it, and spot a missing step without reading code.

The article Drawing an agent as the work happens describes the operator's side. Nothing in it requires a developer.

Developers have habits that make software safer: review before change, history of every change, generation from a template rather than by hand. Those habits run on files. A file can be diffed so a reviewer sees exactly what moved. It can be kept in source control alongside the applications that call the agent's stable address. It can be produced by tooling when the site has many similar desks.

The agent file gives developers all of this for the same agent the operator drew. The developer does not have to persuade the operator to work in code, and the operator does not have to persuade the developer to work on a canvas. Each works in their own view.

What stays the same across views

Everything that matters about the agent is in both views because there is only one design. The bounds, which models the agent may use, which material it may read, which systems it may name as tools, where approval is required, and what it may never do, are the same whether read from the canvas or the file. The step sequence is the same. The front door is the same.

This means review can happen in either view with equal confidence. A compliance reviewer who prefers to read the canvas sees the same bounds as a developer who prefers to read the file. Neither is seeing a summary of the other.

Publishing as one version

When the design is ready, it is published. Publishing freezes it into a version. It does not matter whether the last change came from the canvas or the file; the version is the one design at that moment. Deploying then points a stable address at the version, and the site's applications call the address.

Because file and canvas publish as one version, there is no situation where production runs the developer's version while the operator is looking at a different one. The version that is live is the version both of them can open. Publishing a version you can point to covers what happens from there.

A practical consequence for teams

A site that brings in engineers to build a first agent, whether from E31 Consulting or its own staff, can have them work in files with the review and source-control habits they are used to. When they hand the agent back, it is a published version the operators can open on the canvas and change themselves. There is no translation at the handoff and no second definition left behind for the operators to maintain.

The same holds in the other direction. An operator who drew an agent can hand it to a developer for a change that is easier to make in a file, and the developer edits the same design. The operator sees the result on the canvas and publishes when satisfied.

Agency Studio could have offered a visual editor that generated code, or a code editor that rendered a diagram. Both would have produced two things to keep aligned. Making canvas and file one design means the question of alignment never arises. The platform page describes the Studio alongside the rest of what runs on the appliance.