What Are AI Agents? A Deep Dive into Multi‑Agent Systems and Frameworks

Introduction

An Agent is an application that can perceive its environment, understand it, and use tools to achieve a goal. Multi‑Agent Systems (MAS) coordinate multiple such agents to solve complex tasks that exceed the capabilities of a single agent.

Workflow vs. Agent Systems

Two architectural styles are commonly distinguished:

Workflow systems – humans design a fixed sequence of steps; large language models (LLMs) act as one node in the pipeline.

Agent systems – LLMs make dynamic decisions, selecting which agent should act next and how to use tools.

Key Characteristics

Execution path : fixed in workflows, dynamic in agents.

Decision method : rule‑based for workflows, LLM‑driven inference for agents.

Determinism : high for workflows, lower for agents.

Predictability : strong in workflows, weaker in agents.

Adaptability : low in workflows, high in agents.

Complexity : relatively simple for workflows, higher for agents.

Maintenance cost : lower for workflows, higher for agents.

Application scenarios : repetitive, well‑defined tasks for workflows; uncertain, creative tasks for agents.

Design Guidelines for Agent Systems

Start simple : begin with the most straightforward solution and add complexity only when needed.

Progressive development : first optimise a single LLM call, then add retrieval, context examples, and finally full agent coordination.

Use agents when flexibility is required : switch from a workflow to an agent system when the problem demands dynamic, model‑driven decisions.

Key Frameworks

OpenAI Swarm

Swarm is an experimental, lightweight framework (≈300 lines of core code) that demonstrates how agents can hand off control to one another. It is primarily educational and built on the Chat Completions API, so it is stateless between calls.

Core concepts:

Agent : encapsulates instructions, functions, and optional tool calls.

Handoff : an agent can return another agent to transfer execution.

Routines : predefined sequences of actions that an agent follows.

Tool Calls : agents can invoke Python functions and update context variables.

Example initialisation and execution:

from swarm import Swarm
client = Swarm()

def transfer_to_agent_b():
    return agent_b

agent_a = Agent(
    name="Agent A",
    instructions="You are a helpful agent.",
    functions=[transfer_to_agent_b]
)

agent_b = Agent(
    name="Agent B",
    instructions="Only speak in Haikus."
)

response = client.run(
    agent=agent_a,
    messages=[{"role": "user", "content": "I want to talk to agent B."}]
)
print(response.messages[-1]["content"])

Swarm also supports streaming responses, custom tool implementations, and a set of example agents (basic, triage_agent, weather_agent, airline, support_bot, personal_shopper).

AutoGen

AutoGen provides a unified interface for multi‑agent collaboration, supporting custom agents, human‑in‑the‑loop interaction, and code generation tasks. It is more feature‑rich than Swarm but still experimental for production use.

Magentic‑One (Autogen‑Magentic‑One)

An extension of Microsoft AutoGen that adds a ledger‑based orchestrator for coordinated task execution. It introduces specialised agents (Coder, WebSurfer, FileSurfer, UserProxy, Executor) and a Docker‑based code executor for safe, multi‑language execution.

Core components:

LedgerOrchestrator : maintains a task ledger, decides the next agent, and handles replanning.

Agents : each agent has a focused role (e.g., coding, web browsing).

Code Executor : runs code inside isolated Docker containers.

Typical workflow:

Initialise the orchestrator with a team of agents.

Collect facts and create an execution plan.

Iteratively update the ledger, detect loops or stalls, and re‑plan if necessary.

When the request is satisfied, generate a final answer.

Sample asynchronous initialisation:

import asyncio
from autogen_magentic_one import LedgerOrchestrator, DockerCommandLineCodeExecutor

async def main():
    async with DockerCommandLineCodeExecutor(work_dir="./logs") as executor:
        orchestrator = LedgerOrchestrator(
            agents=[agent1, agent2],
            model_client=your_model_client
        )
        result = await orchestrator.run("Your task description")

asyncio.run(main())

Application Scenarios

The article showcases several practical use cases:

Content creation : a commander‑style agent generates, revises, and validates articles using the six‑thinking‑hats method.

Trading system : market analysis, risk assessment, and execution agents collaborate to produce a BTC/USDT long‑position plan.

Customer service : agents handle user queries, retrieve information, and coordinate responses.

Each scenario demonstrates how a small team of specialised agents can be orchestrated to solve end‑to‑end tasks.

Future Outlook

The rise of the “Agentic AI Era” promises that individuals and organisations will be able to orchestrate both human and digital labour. By combining flexible agent architectures with robust orchestration (ledger‑based or otherwise), businesses can automate complex, creative, and adaptive workflows that were previously limited to manual processes.