Unlocking Collaborative Intelligence

In today’s evolving digital landscape, the need for dynamic, intelligent systems is greater than ever.

Lot, an innovative TypeScript-based library, stands out as a flexible framework designed for orchestrating intelligent agents to tackle complex tasks.

Whether the type and level of intelligence you need, Lot provides a platform that simplifies the integration of agent collaboration into your projects.

By the end of this article, you’ll have a clear understanding of Lot’s capabilities and be ready to leverage its potential in your own applications.

Why Choose Lot for Collaborative AI?

Lot isn’t just another AI framework; it represents a collaborative intelligence approach. By breaking down tasks into manageable pieces and distributing them across intelligent agents, Lot ensures an efficient division of labour.

Each agent is designed to handle, with a specialised intelligence, a specific domain or task type, making it easier to scale operations while maintaining precision and performance.

Imagine a scenario where a project requires multiple steps — data validation, API interaction and reporting, AI-driven cloud services, complex resource management, automated decision-making, team-based strategy games, etc.

Lot seamlessly orchestrates agents to perform the tasks at hand, ensuring efficiency and accuracy.

What Makes Lot Unique?

Lot has been designed to empowers developers to:

• Coordinate intelligent agents interfacing with multiple AI models (e.g., LLMs, Machine Learning APIs) and specialised in different tasks.
• Solve complex multi-step problems through task-based dynamic leadership.
• Achieve higher accuracy, flexibility, and efficiency in AI-driven solutions.

1. Task Delegation with Manager Agents

Amongst others, Lot introduces a Manager agent that acts as a central task delegation system. This agent leverages its AI brain, which is the decision-making system each agent uses, to assign tasks to specific agents based on predefined roles and capabilities.

For example, a Resource Provisioning Agent would be responsible for tasks like creating new users or provisioning services.

The flexibility of Lot’s task management system allows users to create workflows that can adapt to both simple and complex requirements.

it('completed tasks assigned by a manager', async () => {
  const manager: Agent<string, string> = new ManagerAgent(new ManagerBrain())
  const task: Task<string, string> = new Task(
    TaskType.DefinesAndAllocateTasks,
    `Create a new user based on the following information:
  
  Name: New User
  Role: Admin`,
    new Expectation('the new resource is created', 1),
    'Create a new resource'
  )
  const lot: Lot<string, string> = new Lot([manager])
  
  const answers: Answer<string>[] = await lot.crackOn([task], Dynamic.CentralisedTaskDelegation)
  const actual: Answer<string> = answers[0]
  expect(actual.getContent()).to.be.eq('New User has been created with role Admin')
})

2. Asynchronous Task Handling

The distributed agent architecture allows tasks to be handled asynchronously, making it ideal for use cases where a task might not immediately provide the final answer but requires further refinement or additional data gathering.

3. Extensibility

Lot’s design isn’t limited to language models or predefined AI tools. It can be extended to handle non-language models, such as image recognition, database interactions, or any API-driven service.

This versatility makes Lot suitable for a wide range of applications, from AI-driven research to enterprise-level automation.

A Look Under the Hood

Lot’s architecture is built around brain strategies. Each agent possesses a ‘Brain’ that processes the task in line with its specific tools.

In the example provided below, a user creation task is delegated to an agent, which uses the appropriate tool to provision a new user.

This modular approach ensures that Lot can easily integrate new tools as they become available.

class ManagerBrain extends Brain<string, string> {
  public async evaluate(instruction: Instruction<string, string>): Promise<Thought<string>> {
    const owner: ResourceProvisioningAgent<string, string> = new ResourceProvisioningAgent(new ToolBrain()).addTools(
      new UserProvisioningTool('userProvisioning', 'Allows to provision new users')
    )
    const assignedTask: AssignedTask<string, string> = new AssignedTask(
      TaskType.ResourceProvisioning,
      instruction.asString(),
      instruction.getExpectation(),
      'provision a new user',
      owner
    )
    return new Thought(
      `${owner.getName()} will use userProvisioning tool to provision the new user, ${owner.getName()} is responsible for extracting username and password`,
      1,
      instruction.getExpectedConfidenceThreshold()
    ).addTasks(assignedTask)
  }
}

In this snippet, we see the central orchestration system, the ManagerBrain, acting like a project manager in the real world. It assesses the task at hand and assigns the right person — or in this case, the right agent — to get the job done.

The implementation is admittedly quite simple, but it demonstrates how an agent brain can be defined based on the current requirement and therefore evolve and adapt. You can, for instance, define your brain using LAM (Large Action Models) or your very own CNN (Convolutional Neural Network) or a rule engine; just extend the base Brain!

The result? A clean and efficient way of managing task flow across different agents.

Visualising Lot’s Output

In the image below, we see Lot in action, efficiently assigning and processing tasks.

From the task assignment to the creation of a new user, Lot’s transparent process allows developers to track and refine the steps in real time.

These images underscore Lot’s capability to manage complex tasks in an organised, modular fashion.

Fig. 1 — Lot execution logs

The test case from which the logs are generated can be found here.

How to Get Started

Getting started with Lot is simple. Its modular design means you can add agents as needed and customise them based on your project’s requirements.

1. Install Lot: Clone the repository and install the required dependencies.
2. Create Agents: Define the agents responsible for different tasks.
3. Define Tasks: Create tasks and let the Manager Brain distribute them across your agents.

For more examples, use cases and details, explore Lot’s GitLab repository.

Final Thoughts

Lot is more than a framework — it’s a platform designed for collaborative intelligence.

By allowing for easy integration and extending task-based workflows, Lot can open the door to new patterns for developing API services as well as modern AI-driven applications.

Whether you’re automating cloud services, provisioning resources, or coordinating complex tasks, Lot’s flexible agent-based approach provides the tools you need to succeed.

Ready to explore the power of Lot? We welcome contributions and ideas from the community!

Whether you’re looking to extend its capabilities or refine existing features, join us on GitLab and help shape the future of collaborative intelligence.