Drawing an agent as the work happens
In Agency Studio an operator draws the agent the way the desk actually works: what it reads, what it decides, where a person approves, which systems it may call.
· 4 min read
IN SHORT
In Agency Studio an operator draws the agent as a sequence that mirrors how the desk already works: the packet that arrives, what the agent reads, what it decides, where a person must approve, and which systems it may call. The drawing is the design. When it is right, it is published as a version, and the same design exists as a file for developers.
The person best placed to design an agent for a desk is the person who runs the desk. They know what arrives, what gets looked up, where judgment is needed, and what has to be signed off before anything leaves. Agency Studio is built around that fact. An operator draws the agent as the work actually happens, and the drawing is the design.
Start with the desk, not with the model
The first thing an operator draws is not a model or a prompt. It is the packet. What arrives at this desk, through which door, in what shape. From there the operator draws what happens to the packet, step by step, the way it happens today when a person does it.
A claims desk might be drawn as: packet arrives, read the claim and the policy it references, retrieve the applicable clauses and the account's history, draft a determination, wait for a reviewer, then update the claim record or send a letter. An intake desk might be drawn as: request arrives, read it, retrieve the procedure for its type, draft an acknowledgment and a routing decision, wait for a reviewer, then route it. Each of these is a drawing of existing work.
The kinds of step
The canvas offers a small number of step kinds, and every agent is built from them. A reading step takes the packet or a prior step's output and retrieves from the material the agent may read. A deciding step produces a draft or a choice from what was read. A waiting step hands the draft and its sources to a reviewer and continues on their decision. A calling step makes an allowed call to a system the admin has made available as a tool. An ending step closes the run.
Because the kinds are few, the drawing stays legible. Anyone who knows the desk can look at the canvas and recognize their own work in it. That legibility is what makes the canvas reviewable by people who are not developers, which is most of the people who need to review it.
Drawing the waiting step where it belongs
Operators draw the waiting step at the point where the agent would send, spend, or change a record. This is a deliberate act of design rather than a safeguard bolted on later. The operator knows where the desk's sign-off sits today, and they put the waiting step there. If the desk has more than one sign-off, the canvas has more than one waiting step.
The guide Placing the approval step goes into the judgment involved. For now the point is that the pause is drawn, visible on the canvas, and frozen into the version when the design is published.
Naming what the agent may call and read
A calling step is drawn against a specific tool. The admin decides which outside systems are available as tools at this site, and the operator chooses from those. The canvas shows which system each calling step will reach and what kind of call it makes. An agent cannot call something that was not drawn.
This is the bounds of the agent becoming visible on the canvas. Naming the tools an agent may call describes how the operator and admin divide this work.
The reading steps are drawn against the material the agent is allowed to retrieve from. The operator names the collections or documents this desk works from, and the version carries that as a bound. During design, the operator can see what retrieval brings back for sample packets and adjust the material or the step until the passages are the right ones.
The corpus does not move during any of this. The appliance retrieves over the site's documents in place. The operator is drawing which part of the site's material this agent may see, not uploading anything.
From drawing to version
When the canvas describes the work correctly, the operator publishes it. Publishing freezes the drawing into a version. Deploying points a stable address at that version so the site's applications can call it. The drawing is now the thing that runs, and it does not change until the operator publishes again.
A developer who prefers to work in a file can hold the same design that way. The canvas and the file are one design, and they publish as one version. The article Canvas and file are one design describes how that works in practice.
An agent described in prose or in a long prompt is hard to check. An agent drawn as steps on a canvas can be walked through by the people who do the work, who will notice at once if a step is missing or a pause is in the wrong place. Drawing the agent as the work happens is how Agency Studio keeps the design honest to the desk it serves. The platform page describes the Studio alongside the rest of the appliance.
Questions this raises
- Does the operator need to write code to draw an agent?
- No. The operator draws the agent on the canvas in Agency Studio. A developer can hold the same design as a file for review or source control, and canvas and file are one design. The operator never has to leave the canvas to produce a publishable version.
- How detailed does the drawing have to be?
- Detailed enough that each step says what it reads, what it decides, where it waits, and what it may call. The operator is drawing the work they already know, so the detail comes from the desk's existing procedure rather than from invention.
- Can an agent be drawn before the desk's procedure is written down?
- Drawing the agent often is the act of writing it down. Operators frequently find that the canvas surfaces steps the desk did by habit without naming them. Those steps become explicit, and the approval points become deliberate.
KEEP READING