LoOper User Guide

Looper is a desktop-native automation platform for recording, building, and running reliable workflows that can see the screen, reason with local AI, and act through mouse/keyboard control.

When you launch Looper, you will see the main window with:

• Central Canvas: The node graph editor where you build automation workflows
• Top Menu Bar: File operations, settings, and tools
• Right Toolbar: Node palette with available node types
• Node Graph: Visual representation of your automation workflow

Project Structure

Looper organizes your work into:

Recording Sequences

Recording is the process of capturing your mouse clicks, keyboard input, and scrolling into a reusable sequence file.

How to Record

1. Click Record in the toolbar or use the menu option
2. Perform your desired actions on screen:
   • Clicks (left, right, middle)
   • Keyboard typing
   • Scrolling
   • Drag operations
3. Press ESC or click Stop to end recording
4. Your sequence is saved automatically to the sequences/ folder

Recording Settings

What Gets Recorded

Smart Recording Features

• Scroll Burst Grouping: Multiple rapid scroll events are grouped into a single scroll action
• Text Buffering: Typed characters are batched into a single type_string action
• Modifier Shortcuts: Common shortcuts like Ctrl+C/V/X/A are recognized and recorded as clipboard operations
• App Context: Records which application window was active for each action
• Native Screenshot Capture: Looper captures screenshots automatically around click coordinates for visual matching during playback

Screenshot Capture

During recording, Looper automatically captures small screenshots (70x70 pixels by default) around each click location. These screenshots are stored in sequences/screenshots/ and are used during playback for template matching to find the correct UI element.

Playback and Execution

All nodes in Looper (not just sequences) are executed through the Workflow Interpreter, which handles:

• Sequential execution of nodes in dependency order
• Conditional branching based on true/false outputs
• Error handling and retries
• Variable passing between nodes

How Playback Works

1. Start: The workflow interpreter loads the chain file
2. Node Execution: Each node is executed in order based on connections
3. Branching: Conditional nodes route execution to different branches
4. Completion: Chain finishes or ESC cancels execution

Visual Matching

Looper uses template matching to find UI elements reliably:

Stopping Execution

Press ESC at any time to cancel execution safely.

Schedules

Schedules allow you to automatically run your automation chains at specific times.

Schedule Types

Creating a Schedule

1. Open Scheduler Manager from the menu
2. Click Add Schedule
3. Configure:
   • Name: Descriptive name for the schedule
   • Type: Once, Daily, Weekly, or Interval
   • When: The time/date specification
   • Chain: Select which chain to run
4. Enable/disable the schedule using the toggle

Schedule Management

Persistence

Schedules are saved to schedules.json and persist across application restarts. The scheduler runs as a background service that checks every 10 seconds for due schedules.

Node Types

Nodes are the building blocks of automation workflows. Each node type performs a specific function.

Node Colors Quick Reference

Sequence Node

Purpose: Executes a recorded sequence file.

Color: Dark Grey
Ports: 1 input, 1 output (multi-output capable)

Conditional Node

Purpose: Waits for conditions or creates branching logic based on screen state or code evaluation.

Condition Types

Conditional Loop Types

Looper supports conditional loops that execute a sequence repeatedly based on conditions. Multiple conditionals can be stacked to create complex logic:

Color: Purple (#7B61FF)
Ports: 1 input, 2 outputs (True/False for conditionals)

Creating Image Triggers

Looper provides a built-in screenshot capture tool for creating image-based triggers:

1. Click Capture... in the trigger dialog
2. Looper minimizes the window and freezes the screen
3. Draw a rectangle around the target area
4. The screenshot is automatically saved and path inserted

LLM Node

Purpose: Integrates local AI (Ollama) for data ingestion, manipulation, dynamic text generation, and analysis. The LLM node is not just for decision making - it supports multiple use cases.

Input Sources

Model Configuration

Quick Templates

LLM nodes include templates for common tasks:

Color: Orange (#FF6B35)
Ports: 1 input, 1 output

TTS Node

Purpose: Speaks text aloud using text-to-speech.

Color: Cyan (#00CED1)
Ports: 1 input, 1 output

Chain Import Node

Purpose: Embeds another chain as a subgraph, enabling workflow composition and reuse.

Color: Green (#32CD32)
Ports: 1 input, 1 output

Code Node

Purpose: Executes custom Python code during workflow execution.

Available Variables:

• input_data - Data from previous node
• args - Additional arguments
• result - Assign your output to this variable

Color: Yellow (#F1C40F)
Ports: 1 input, 1 output

Recording Special Actions

Modifier Key Combinations

Clipboard Operations

Mouse Drag Recording

1. Press and hold left mouse button at start position
2. Drag to end position
3. Release

Result: Recorded as drag_drop action with from and to coordinates.

Right-Ctrl Mouse Movement

Holding Right-Ctrl while moving the mouse records a move_to action. This is useful for positioning the cursor without performing a click.

Node Dialogs Reference

Each node type has a configuration dialog accessible via double-click or context menu.

Sequence Node Dialog

Conditional Node Dialog

Code Condition Section

Presence Triggers Section

LLM Node Dialog

Basic Tab

Chain Import Dialog

Code Node Dialog

Sandboxing

Sandboxing in Looper uses RDPWrap to give the automation agent its own private Windows session, allowing background task execution without interfering with the user's active desktop.

How RDP Sandbox Works

1. RDPWrap Installation: Enables multiple concurrent RDP sessions on Windows
2. Agent User: Creates a dedicated user account (LooperAgent) for the agent
3. Private Session: The agent runs in a separate RDP session that doesn't affect the user's active desktop
4. Communication: Looper communicates with the agent via HTTP API

Architecture

graph LR
    subgraph UserDesktop["User's Desktop"]
        LooperGUI["Looper GUI"]
        AgentBridge["Agent Bridge"]
        HTTPAPI["HTTP API localhost"]
    end

    subgraph PrivateSession["LooperAgent Private RDP Session"]
        AgentHandler["Agent Handler"]
        ScreenCapture["Screen Capture"]
        AppUnderTest["Application Under Test"]
    end

    LooperGUI --> AgentBridge
    AgentBridge --> HTTPAPI
    HTTPAPI --> AgentBridge
    AgentBridge --> LooperGUI

    HTTPAPI -. RDP Session Communication .-> AgentHandler

    AgentHandler --> ScreenCapture
    ScreenCapture --> AgentHandler
    ScreenCapture --> AppUnderTest
    AppUnderTest --> ScreenCapture
          

Agent Actions

The sandbox agent supports these actions via HTTP POST:

Sandbox vs Direct Execution

Debugging Sandbox Issues

If sandbox fails to start:

1. Ensure RDPWrap is installed: Check C:\Users\%USERNAME%\AppData\Local\LoOper\RDPWrap or reinstall LoOper
2. Check that LooperAgent user exists
3. Verify the user is in Remote Desktop Users and Administrators groups
4. Check agent_info.json for connection details

Troubleshooting

Keyboard Shortcuts

Documentation version 1.5.0 - Last updated for Looper Release 1.5.0