Launching Lyzr Automata - Autonomous Multi-Agent Framework

I'm thrilled to introduce Lyzr Automata, our groundbreaking multi-agent, parallel processing, agent automation framework. This initial version, crafted overnight (literally on a Saturday night), is the prompt-only iteration. It features prompt agents collaborating seamlessly. The prompt-only model’s capability is a testament to GPT's existing capabilities in image, code, and text generation. But we're not stopping there – development of code and integration agents is on and we will be moving fast.

In an ideal world, Lyzr Automata's true potential will be unlocked with diverse agents beyond prompt-based ones. For now, though, let’s delve into these prompt-based agents. Another key aspect of Lyzr, for those who've been tracking our progress, is the simplicity of the agent framework. Our goal isn't just to reduce the time developers spend wrestling with the basic building blocks. Lyzr’s purpose and vision extends further: opening up AI programming to a large set of professionals by enabling them on the low-code platform. We're passionate about making programming accessible, especially for those on the fringes of coding or those hesitant due to its complexity. With Lyzr, we're opening the doors to programming for everyone.

Staying true to our mission, Lyzr Automata is designed to be exceptionally user-friendly, offering a low-code environment. In just minutes, anyone can create a multi-agent workflow with a few straightforward lines of code. Essentially, it all boils down to simple inputs and a single line of code for execution – a principle we've adhered to staunchly at Lyzr.

An exciting addition is Lyzr Automata's ability to seamlessly integrate with our other mature agents, such as the Lyzr chatbot agent, the Lyzr search rag agent, or the Lyzr data analysis agent, all running on SOTA (state-of-the-art) architecture. This integration elevates your workflow's effectiveness significantly.

Plus, we're launching Lyzr Automata as open source, making it accessible to everyone. While we're gearing up to release a user-friendly GUI, you can dive right into using the code as it stands – it's as straightforward as we've always intended.

So, let’s explore how Lyzr Automata actually works and revolutionize the way we approach agent automation.

At Lyzr Automata, our architectural approach sets us apart from other prevalent multi-agent frameworks. Take LangChain's LangGraph, for instance, which employs a router-based model keeping agents in a uniform state. Then there's Autogen, an open-source framework that's prompt-based but lacks a process flow element. ChatDev introduces process flow, yet its usage isn’t as streamlined as one might hope. CrewAI has made strides with sequential task execution, but it falls short in parallel task handling, a key feature we’re honing in on at Lyzr Automata. This focus stems from witnessing enterprise scenarios where parallel processing or multi-threading, largely stateless, is crucial.

The diagram below encapsulates our unique approach to multi-agent framework development.?

At its core, our architecture utilizes various tools leveraged by agent personas. Agents are summoned by tasks, with a clear distinction: agents embody personas, while tasks encompass instructions and outcomes. This results in a tighter linkage between tasks and agents, enhancing overall outcomes.

The initiation task kickstarts the program without dependencies, setting the stage for subsequent tasks. These following tasks possess the ability to invoke dependencies from prior tasks. This feature is pivotal for multi-threading capabilities. In this dependency architecture, you could, for example, transition from task 7 back to task 5, which might depend on task 1. Such flexibility revolutionizes traditional sequential workflows, opening new avenues for efficiency and effectiveness in task execution.

agent1 = Agent(persona="Marketing Consultant")

agent2 = Agent(persona="Tweet Generator")

agent3 = Agent(persona="Linkedin Post Creator")        

In Lyzr Automata, a key focus is on the stability of tasks. Once a task is completed, it settles into a steady state. This approach is integral to our framework: each task is typically executed by a single agent, ensuring consistency and reliability, which is vital for enterprise workloads. The beauty of this system lies in its reliability, as you can expect dependable results time and again.

task1 = Task(
    instructions="Do research and pull out interesting marketing tips for SaaS companies. The research articles should not be more than 1500 words.",
    desired_output="Ensure that you bring the best content from the likes of HBS and Saastr", 
    agent=agent1,
    max_tokens=1500,
    display_output='yes')

task2 = Task(
    instructions="Use the research material provided and write 5 engaging tweets. Display only the tweets. No explanation or additional comments required.",
    desired_output="Ensure that the tweets are as engaging as if it was written by the best influencer in the world",
    agent=agent2,
    display_output="yes",
    dependencies=[task1]
)

task3 = Task(
    instructions="Use the research material provided and write 1 short form LinkedIn post. Display only the LinkedIn post. No explanation or additional comments required.",
    desired_output="Ensure that the post is as if it was written by the best influencer in the world",
    agent=agent3,
    display_output="yes",
    dependencies=[task1]
)        

Another advantage of the system is its ability to provide outputs at the conclusion of any task. Given that each task achieves a steady state, you have the flexibility to extract outputs as needed. This capability doesn't just give you a multi-agent, multi-threaded framework; it also offers a multi-output framework, which can be seamlessly integrated into subsequent processes.

Consider the broader picture: a single process within Lyzr Automata encompasses multiple states, and each state flow contains numerous tasks. In this ecosystem, it's possible to run parallel processes. These processes can interact with tasks from any state of the first process. The stateful nature of our tasks acts as nodal points, offering unparalleled flexibility in constructing a robust multi-agent framework.

That covers the essentials of how Lyzr Automata operates. Now, let's move on to the actual demonstration. True to Lyzr's philosophy, we've made sure the process is straightforward and user-friendly.

Watch the intro video and the Colab demo here

Github Repo - https://github.com/LyzrCore/lyzr-experimental-automata

If you like to get started with pilot projects at your organization, connect with us at [email protected]

What's Next?

1. Advanced prompt restructuring powered by Lyzr's MagicPrompts (https://magicprompts.lyzr.ai/)
2. More non-prompt agents to be added (this is where Lyzr's Multi-Agent Framework stands apart as we are taking a completely different approach towards process automation)
3. An easy-to-use UI to create workflows and debug issues
4. Even more simpler syntax to stitch together tasks to form a workflow
5. Integrations with pre-built and SOTA architecture-powered Lyzr Agent SDKs - Chat Agents, RAG Agents, Search Agents, Data Agents, Generator Agents, Summarizer Agents
6. AWS Native Agent Framework with agents running on AWS Lambda

Best,

Siva Surendira & The Lyzr Team