Agentic Lybic: Multi-Agent Execution System with Tiered Reasoning and Orchestration

📝 Paper Summary

Multi-agent Agentic AI

Agentic Lybic is a multi-agent desktop automation system that uses a Finite State Machine controller to dynamically route subtasks among specialized workers while enforcing continuous quality gates.

Core Problem

Current desktop automation agents struggle with complex, long-horizon tasks because they rely on simplistic 'delegate-and-forget' approaches that lack continuous oversight and adaptive re-planning.

Why it matters:

Existing hybrid agents fail to implement sophisticated routing mechanisms essential for coordinating multiple functional modules over extended workflows
Quality assessment in current systems is typically binary and reactive (only checking final success), missing opportunities for proactive intervention and incremental course correction during execution

Concrete Example: In a multi-stage workflow like an examination task, a standard GUI agent might try to answer questions directly on screen. However, if the questions must be collected first, analyzed, and then answered, a standard agent fails without separating perception, reasoning, and action phases.

Key Novelty

FSM-based Tiered Reasoning Architecture

Implements the entire multi-agent architecture as a Finite State Machine (FSM), where a central Controller manages transitions between planning, execution, and quality check states based on specific triggers.
Introduces a 'continuous quality gate' system that monitors progress after every few steps (not just at the end), allowing the system to detect stagnation or errors early and trigger immediate re-planning.

Architecture

The hierarchical four-component architecture of Agentic Lybic and its FSM-based workflow.

Evaluation Highlights

Achieves a state-of-the-art success rate of 57.07% on the OSWorld benchmark (in 50 steps), surpassing CoAct-1 (56.4%) and Agent S2.5 (54.2%)
Demonstrates superior reliability in long-horizon scenarios through proactive quality control mechanisms that prevent error propagation

Breakthrough Assessment

7/10

Offers a strong architectural contribution by formalizing multi-agent orchestration via FSMs and continuous quality gating. While the performance gain on OSWorld is incremental (+0.67% over CoAct-1), the structural approach to reliability is significant.

⚙️ Technical Details

Problem Definition

Setting: General-purpose desktop automation where an agent must interact with a computer OS to fulfill natural language user queries

Inputs: User query (natural language) and current operating system state (screenshots, accessibility tree)

Outputs: Sequence of executable actions (mouse clicks, keyboard typing, terminal commands) to achieve the goal

Pipeline Flow

Controller (Global State Management)
Manager (Task Decomposition & Planning)
Worker Subsystem (Execution)
Evaluator (Quality Control)

System Modules

Controller

Manages global state transitions (REPLAN, GET_ACTION, QUALITY_CHECK, etc.) and decision triggers using a look-up table

Model or implementation: Not explicitly specified (Likely rule-based FSM logic + LLM for state interpretation)

Manager

Decomposes user queries into subtasks using DAG planning and performs adaptive re-planning (light/medium/heavy adjustments)

Model or implementation: Not explicitly specified (Likely VLM/LLM)

Worker: Operator (Execution)

Manages GUI interactions using vision-language models

Model or implementation: Not explicitly specified (Likely VLM)

Worker: Technician (Execution)

Handles system-level operations via code

Model or implementation: Not explicitly specified (Likely LLM specialized in code)

Evaluator

Provides continuous monitoring and determines gate decisions (gate_done, gate_fail, gate_continue)

Model or implementation: Not explicitly specified (Likely VLM)

Novel Architectural Elements

FSM-based global controller that treats the entire multi-agent system as a state machine with explicit transitions defined by a trigger lookup table
Multi-trigger quality gate system (Periodic, Stale, Success) integrated directly into the execution loop rather than just at task end
Specialized 'Analyst' worker role specifically for decision support/reasoning to bridge the gap between perception (Operator) and action (Technician)

Modeling

Base Model: Not explicitly reported in the paper

Compute: Not reported in the paper

Comparison to Prior Work

vs. CoAct-1: Agentic Lybic uses continuous quality gating and dynamic FSM routing instead of 'delegate-and-forget'
vs. Agent S2.5: Uses specialized workers (Technician/Analyst) for non-GUI tasks rather than relying purely on GUI interaction
vs. UFO [not cited in paper]: Uses DAG-based planning for subtasks rather than linear execution sequences
+ 1 more
vs. Cradle [not cited in paper]: Explicitly separates reasoning (Analyst) from GUI action (Operator) rather than a single unified agent loop

Limitations

Base model details (e.g., GPT-4o, Claude) are not specified, making performance attribution difficult
No analysis of computational cost or latency added by the continuous quality checks
No detailed ablation study reported to quantify the contribution of individual components (Manager vs. Evaluator)

Reproducibility

No replication artifacts mentioned in the paper. The paper does not provide a code URL, model weights, prompt templates, or specific base model names (e.g., GPT-4o vs Claude 3.5 Sonnet).

📊 Experiments & Results

Evaluation Setup

Desktop automation tasks on real operating systems

Benchmarks:

OSWorld (General computer tasks (Ubuntu/Windows))

Metrics:

Success Rate (SR)
Statistical methodology: Not explicitly reported in the paper

Key Results

Benchmark	Metric	Baseline	This Paper	Δ
OSWorld	Success Rate	56.4	57.07	+0.67
OSWorld	Success Rate	54.2	57.07	+2.87

Main Takeaways

Principled orchestration via FSM provides superior reliability for generalized desktop automation compared to simpler delegation models.
Continuous quality control allows for error recovery in long-horizon tasks where error propagation typically causes failure.
The specialized worker architecture (separating Technician, Operator, Analyst) effectively handles the diversity of desktop tasks better than monolithic agents.

📚 Prerequisite Knowledge

Prerequisites

Understanding of Finite State Machines (FSMs)
Familiarity with Vision-Language Models (VLMs) for GUI grounding
Knowledge of Directed Acyclic Graphs (DAGs) for task planning

Key Terms

FSM: Finite State Machine—a computational model used here to control agent flow, where the system is in one of a limited number of states (e.g., Planning, Executing, Checking) at any time

OSWorld: A benchmark environment for evaluating multimodal agents on open-ended computer tasks across real operating systems (Ubuntu, Windows, etc.)

DAG: Directed Acyclic Graph—a structure used here for planning, where tasks are nodes and dependencies are directed edges, ensuring no circular dependencies

Grounding: The process of mapping a high-level instruction (e.g., 'click the file') to a specific coordinate or element on the screen

RAG: Retrieval-Augmented Generation—using external knowledge retrieval to enhance the model's context before generating a response