Loops

Loops are a powerful feature in Sim Studio that allow you to create iterative processes, implement feedback mechanisms, and build more sophisticated workflows.

What Are Loops?

Loops in Sim Studio allow a group of blocks to execute repeatedly, with each iteration building on the results of the previous one. This enables:

Iterative Refinement: Progressively improve outputs through multiple passes
Batch Processing: Process collections of items one at a time
Feedback Mechanisms: Create systems that learn from their own outputs
Conditional Processing: Continue execution until specific criteria are met

Loops are particularly powerful for AI workflows, allowing you to implement techniques like chain-of-thought reasoning, recursive refinement, and multi-step problem solving.

Creating Loops

To create a loop in your workflow:

Select Blocks: Choose the blocks you want to include in the loop

Create Loop: Use the "Create Loop" option in the editor

Configure Loop Settings: Set iteration limits and conditions

Create Feedback Connections: Connect outputs from later blocks back to earlier blocks

Loop Configuration

When configuring a loop, you can set several important parameters:

Iteration Limits

Maximum Iterations: The maximum number of times the loop can execute (default: 5)
Minimum Iterations: The minimum number of times the loop must execute before checking conditions

Always set a reasonable maximum iteration limit to prevent infinite loops. The default limit of 5 iterations is a good starting point for most workflows.

Loop Conditions

Loops can continue based on different types of conditions:

Use a Condition block to determine whether the loop should continue:

// Example condition in a Condition block
function shouldContinueLoop() {
  // Get the current score from an evaluator block
  const score = input.evaluatorBlock.score;
  
  // Continue looping if score is below threshold
  return score < 0.8;
}

The loop will continue executing as long as the condition returns true and the maximum iteration limit hasn't been reached.

Loop Execution

When a workflow with loops executes, the loop manager handles the iteration process:

First Pass: All blocks in the loop execute normally
Iteration Check: The system checks if another iteration should occur
State Reset: If continuing, block states within the loop are reset
Next Iteration: The loop blocks execute again with updated inputs
Termination: The loop stops when either:
- The maximum iteration count is reached
- A loop condition evaluates to false (after minimum iterations)

Loop Use Cases

Loops enable powerful workflow patterns:

Example: Content Refinement

Create a loop where an Agent block generates content, an Evaluator block assesses it, and a Function block decides whether to continue refining.

Agent generates initial content
Evaluator scores the content
Function analyzes score and provides feedback
Loop back to Agent with feedback for improvement
Continue until quality threshold is reached

Batch Processing

Example: Data Processing Pipeline

Process a collection of items one at a time through a series of blocks.

Function block extracts the next item from a collection
Processing blocks operate on the single item
Results are accumulated in a Memory block
Loop continues until all items are processed

Recursive Problem Solving

Example: Multi-step Reasoning

Implement a recursive approach to complex problem solving.

Agent analyzes the current problem state
Function block implements a step in the solution
Condition block checks if the problem is solved
Loop continues until solution is found or maximum steps reached

Best Practices for Loops

To use loops effectively in your workflows:

Set Appropriate Limits: Always configure reasonable iteration limits
Use Memory Blocks: Store state between iterations with Memory blocks
Include Exit Conditions: Define clear conditions for when loops should terminate
Monitor Performance: Watch for performance impacts with many iterations
Test Thoroughly: Verify that loops terminate as expected in all scenarios

Loops with many blocks or complex operations can impact performance. Consider optimizing individual blocks if your loops need many iterations.

Loop Debugging

When debugging loops in your workflows:

Check Iteration Counts: Verify the loop is executing the expected number of times
Inspect Block Inputs/Outputs: Look at how data changes between iterations
Review Loop Conditions: Ensure conditions are evaluating as expected
Use Console Logging: Add console.log statements in Function blocks to track loop progress
Monitor Memory Usage: Watch for growing data structures that might cause performance issues

By mastering loops, you can create much more sophisticated and powerful workflows in Sim Studio.

Loops

Example: Content Refinement

Example: Data Processing Pipeline

Example: Multi-step Reasoning

On this page