Practical guidance for designing effective procedures, agents, and workflows in Interloom.
Start Simple, Add Complexity Only When Needed
Begin with a single procedure using the broadest, most capable agent. Don't introduce multiple agents upfront.
Write the procedure in as few stages as possible first. You won't get reliable autonomy from a rough draft — it'll hit edge cases — but it gives you a baseline to observe.
As you see failure modes, add granularity: more stages, more specific instructions, guardrails. The more granular the procedure, the more reliably the agent can work independently — but the more prescriptive it becomes, the more sensitive it is to variation in inputs.
Break Work Into Discrete Stages
Start by considering the high-level lifecycle of the case. In what logical order does work need to happen? Create stages for what must happen first and what must happen last, then fill in the intermediate stages.
If your workflow has a large set of tasks that can run in parallel, use subtasks within a stage rather than creating more sequential stages.
Define Clear Input and Output for Each Stage
For each stage, explicitly define:
- Expected input — What does the agent receive? What must be true before it starts?
- Expected output — What should exist when the stage is done? Be specific: "You are done if all of these things are true: ..."
This serves double duty: it improves agent performance and enables future automated testing of outputs.
Clear input specs let the agent block itself early if something is wrong (e.g., wrong document type, missing data).
Clear output specs give the agent confidence that it has completed the job, preventing it from spiraling or over-processing.
Think of it like acceptance criteria — as soon as "done" is ambiguous, things go off the rails.
Describe Outcomes, Not Tools
Write procedure instructions in terms of what to achieve, not which tool to use. For example: "match each image to the correct template slot" rather than "use the code interpreter to compare images."
This makes workflows more resilient — if a tool changes or gets replaced, the procedure doesn't break.
Revert to prescriptive, tool-specific instructions only when you need to fix a quality or reliability issue.
Layer Your Composition
The three layers, roughly in the order you should reach for them:
1. Procedure Stages
Your primary building block. Start here and get as far as you can with clear stage instructions and assignees.
2. Reusable Instructions via Notes
If you find yourself writing the same instructions across multiple procedures (e.g., a photo quality checklist, a compliance verification protocol), extract them into a note and reference it from stage instructions. This gives you one place to update when the process changes.
3. Dedicated Agents
Only introduce a new agent when you need:
- A restricted tool set (e.g., the broad agent keeps using tools you don't want it to)
- A different model (cheaper/faster for simple tasks, more capable for hard ones)
- A different persona (different expertise, different communication style)
Use Multiple Signals for Classification
When an agent needs to classify or match something (e.g., a photo to a template, a document to a category), give it multiple reference points: the expected format, a text description, and examples.
Triangulation across multiple signals is more robust than relying on any single one.
Design for Human-in-the-Loop at Confidence Boundaries
The agent doesn't need to get everything right — it needs to know when it's unsure and escalate.
Design stages so that low-confidence results get flagged with the agent's best guesses (e.g., "I think it's one of these three — please confirm"), which is still a massive time-saver over fully manual work.
Use the blocked stage status for cases where the agent genuinely cannot proceed without human input.
Iterate Based on Observation
After deploying a procedure:
- Watch the first 5-10 cases end to end — read the threads, see where the agent struggles
- Identify patterns — Are failures in the instructions? The agent? The tool access? The data?
- Make targeted fixes — Adjust one thing at a time so you can attribute improvements
- Repeat — Workflow design is iterative. A procedure that handles 80% of cases well on day one can reach 95% with a few rounds of refinement