Turn methods into workflows
Use the canvas and Levin to turn a method into a repeatable workflow.
Build a workflow step by step on the canvas, or ask Levin to create one from a natural-language request. The canvas stays beside Chat, so the Agent can follow your edits and apply its changes to the open graph. Design, test, correct, and rebuild without leaving the current project context.
Turn an idea into a sketch
Start with the shape of the work. A clear sketch gives every decision a place to go, and leaves room to make the method your own.
- 01 · Create
Create a workflow
Open Capabilities, choose Workflows, and start a new workflow beside your conversation.
- 02 · Sketch
Sketch the route
Give the workflow a name, then place the first cards that describe the path you have in mind.
- 03 · Refine
Refine each card
Write a clear title and one focused responsibility for every card. Choose the MCP tool or Skill when the step needs one.
- 04 · Connect
Connect the route
Draw the path from one card to the next. Add a condition when the workflow needs to choose a direction.
- 05 · Build
Build and save
Choose Build. Levin checks and saves the sketch, then turns it into a workflow you can run.
Keep the first sketch light. Each card should express one useful action, so the whole method stays easy to read, test, and make better.
Describe it. Let the Agent build it.
You do not have to turn a complete protocol into cards yourself. Describe the goal, available inputs, important tools or constraints, and expected result in Chat. Levin can create the graph, validate it, deploy it, and open the canvas for review.
Example request
Create a workflow for protein structure analysis. First read the mmCIF file in this project, then use a connected structure-analysis MCP tool, and finally write a Markdown report containing the key residues and measurement results. Open the canvas when it is ready so I can review it.
- 01 · Prompt
Write the sketch idea
Describe the goal, inputs, tools, constraints, and result you want in the chat composer.
- 02 · Create
Let the Agent build the graph
Levin turns your words into cards, connects the route, and opens the canvas for a first look.
- 03 · Review
Check and add detail
Review each card, fill in anything missing, and make the method precise enough to run.
- 04 · Test
Test the workflow with the Agent
Select Workflow test to let the Agent run and verify the complete workflow, reporting each result and any failed step.
The same chat-first flow also works with an existing workflow. Name it, describe the change, and let the Agent carry the latest version forward.
Work with the Agent on the same live canvas
The canvas and chat are two views of the same workflow. Edit cards and connections directly while Levin keeps the Agent in sync, runs the latest version, and brings results back to the canvas. You and the Agent always work from the same source.
- Adjust the workflow. Edit a card, add or remove a connection, or change a branch condition on the canvas.
- Ask for a review. Tell the Agent what should be checked, such as “review the new fallback branch and fix any missing step.” It already has the recent workflow changes in context.
- Inspect the Agent's revision. If the canvas has no pending edits, it reloads the new graph automatically. If you have local edits, Levin shows an external-update notice instead of overwriting them.
- Prepare the latest version. If Update is active, use it before testing so the deployed Skill includes the latest graph changes. If the workflow has no compiled Skill yet, Test run compiles it automatically.
- Run the workflow for real. Select Test run. Levin saves the graph and asks the active Agent to execute the compiled workflow with sample inputs.
- Read the step-by-step report. The Agent reports the result of each step and identifies the exact step that failed. The workflow editor stays open beside the conversation.
- Correct and repeat. Update the relevant card or connection yourself, or ask the Agent to make the change. Rebuild and repeat the test until the workflow produces the intended result.
| Change | What the Agent receives | What the canvas does |
|---|---|---|
| Card or connection structure | An immediate summary of the workflow change. | Keeps the edited graph in place. |
| Title or instruction text | A combined update after you pause typing. | Avoids sending a message for every keystroke. |
| Card position only | No content update is sent. | Saves layout without treating it as a protocol change. |
| Agent-authored revision | The latest saved signature before a change is written. | Reloads when clean, or asks before replacing pending edits. |
Undo and redo are also identified to the Agent as reversals rather than new instructions. Content signatures protect both directions: if either side changed after it was read, Levin requires a fresh read and merge instead of accepting a stale overwrite.
Canvas controls overview
| Control | Use it for | Check after using it |
|---|---|---|
| Add step (+) | Choose MCP tool, Skill, or text instruction. | The new card has a title and an instruction. |
| Connection port | Create a route between cards. | The arrow points to the step that should run next. |
| Tidy / zoom / fit | Organize a growing graph and bring all cards into view. | No card or edge is hidden outside the canvas. |
| Undo / redo | Recover from an accidental card or connection edit. | The validation count returns to the expected value. |
| Build / update | Compile the graph into a callable Skill. | The workflow shows Built / Updated and appears in the capability picker. |
Select a card to open its detail panel. Select a connection to add an optional if/else condition or remove the route. Moving a card changes only the layout; it does not change the compiled procedure.
Use it from chat
After deployment, the workflow is available as a Skill. Name it directly in chat, choose it from the capability picker, or let the Agent select it when your request matches its title and description. You can also mention the workflow when you want the Agent to inspect, edit, deploy, or reopen its canvas rather than execute it.
Keep the source readable. The canvas is the editable workflow source; the generated
SKILL.mdis the compiled artifact the Agent follows at runtime. Rebuild after graph changes so the deployed Skill stays aligned.