Constructing an AI Agent with Llama 4 and AutoGen

Meta’s Llama 4 household of fashions is at present ruling the ever-advancing world of AI. These fashions are revolutionizing how we construct clever techniques with their native multimodal capabilities. When Llama 4 combines with AutoGen, it unlocks the complete potential of constructing dynamic, responsive, and sturdy AI Brokers. By leveraging the combination between Llama 4 and AutoGen, builders can create modern AI brokers that may purpose, collaborate, and adapt effectively. On this article, we’ll discover ways to construct AI brokers with Llama 4 and AutoGen for particular functions.

Why Ought to We Contemplate Utilizing Llama 4?

The Llama 4 mannequin household, together with Scout and Maverick variants, represents a major leap ahead in open-source AI know-how. These fashions supply a number of key benefits:

• Multimodal Intelligence: Llama 4 options native multimodal capabilities that combine various kinds of enter right into a unified structure. This allows extra subtle reasoning throughout totally different media varieties.
• Giant Context Size: It helps as much as 10 million tokens, increasing on Llama 3‘s 128K restrict. It allows dealing with exceptionally lengthy contexts. This makes doable superior functions like complete multi-document evaluation, intensive personalization based mostly on consumer historical past, and navigation of enormous codebases.
• Environment friendly Efficiency: Llama 4 employs a Combination of Skilled structure that prompts solely particular parts of the mannequin for every token processed. This strategy makes the fashions extremely environment friendly. Llama 4 Maverick, for example, makes use of simply 17 billion of its complete 400 billion parameters throughout operation. This enables it to run on a single H100 DGX host.
• Superior Efficiency and Capabilities: Benchmark testing exhibits Llama 4 Maverick outperforming comparable fashions like GPT-4o and Gemini 2.0 throughout coding, reasoning, multilingual capabilities, and picture understanding.
• Open Supply and Accessible: Meta is making fashions accessible for obtain. This encourages open innovation, enabling builders to customise and deploy the know-how throughout various functions and platforms.

Additionally Learn: DeepSeek V3 vs. Llama 4: Selecting the Proper AI Mannequin for You

Llama 4 Benchmark Efficiency

To know simply how good this mannequin is, right here’s a comparability of Llama 4 in opposition to different high fashions on numerous customary benchmarks.

 Additionally Learn: Llama 4 vs. GPT-4o: Which is Higher for RAGs?

Constructing an AI Agent Utilizing Llama 4

On this part, I’ll stroll you thru the method of constructing task-specific brokers utilizing Llama 4 and AutoGen. We’ll create a multi-agent system that analyzes consumer necessities for a job, finds freelancers for the actual job based mostly on their expertise and particulars, after which generates customized job proposals for the consumer to ship out. So let’s start.

Additionally Learn: Palms-on Information to Constructing Multi-Agent Chatbots with AutoGen

Step 0: Setting Up the Atmosphere

Earlier than constructing the agent, we’ll first cowl the mandatory stipulations and arrange the surroundings.

Conditions

Accessing the API

We will likely be utilizing the Collectively API right here to entry the Llama 4 mannequin. Create an account on Collectively AI and go to this web page to create your secret key: https://api.collectively.xyz/

Step 1: Establishing Libraries and Instruments to Information the AI Brokers

First, we will likely be importing all the mandatory libraries and instruments that we’ll want right here.

import os
import autogen
from IPython.show import show, Markdown

Step 2: Calling the API

To make use of the Llama 4, we have now to load the Collectively API. The code block beneath will assist us load the APIs and configure them to the surroundings.

with open("together_ai_api.txt") as file:
   LLAMA_API_KEY = file.learn().strip()
os.environ["LLAMA_API_KEY"] = LLAMA_API_KEY

Step 3: Creating Brokers and Defining Duties

Now, let’s create the required brokers and outline their duties, i.e., what they are going to do.

1. Shopper Enter Agent

The Shopper Enter agent acts as the first interface between the human consumer and the agent system. It collects venture particulars like consumer necessities, timeline, and funds from the consumer and passes them to the Scope Architect. It additionally relays follow-up questions and solutions, and indicators termination when the ultimate proposal is accepted.

Anticipated Output:

• Clear transmission of the consumer’s venture description and freelancer profile (abilities, expertise, time estimate).
• Ends the session as soon as a passable proposal is delivered, or the consumer will explicitly finish it.

# Agent 1: Handles Human Enter for Shopper Necessities
client_agent = autogen.UserProxyAgent(
   identify="Client_Input_Agent",
   human_input_mode="ALWAYS",  # asks the human for enter
   max_consecutive_auto_reply=1, # Solely reply as soon as
   is_termination_msg=lambda x: x.get("content material", "").rstrip().endswith("TERMINATE"),
   system_message="""You're the major level of contact for the consumer.
   Your first process is to offer the preliminary venture particulars obtained from the human consumer (consumer necessities, product particulars, timeline, funds) to the group chat.
   After the Scope Architect asks questions, relay the human consumer's solutions about their abilities, expertise, instruments, and time estimate again to the chat.
   Reply TERMINATE when the ultimate proposal is generated and passable, or if the consumer needs to cease. In any other case, relay the consumer's enter.
   """,
)

2. Scope Architect Agent

The Scope Architect Agent is accountable for the preliminary venture particulars from the Shopper Enter Agent. After that, it asks particular questions to assemble the freelancer’s abilities, instruments, previous venture expertise, and estimated time to finish the work. It doesn’t proceed to proposal technology itself however ensures that every one the mandatory context is collected earlier than handing it over to the subsequent agent.

Anticipated Output:

• Nicely-structured abstract combining each the consumer’s venture wants and the freelancer’s capabilities.
• Triggers the Price Recommender Agent as soon as all required information is collected and summarized.

# Agent 2: Gathers Person's Profile and Estimates
scope_architect_agent = autogen.AssistantAgent(
   identify="Scope_Architect",
   llm_config=llm_config,
   human_input_mode="ALWAYS",
   max_consecutive_auto_reply=1, # Solely reply as soon as 
   is_termination_msg=lambda x: x.get("content material", "").rstrip().endswith("TERMINATE"),
   system_message="""You're a Scope Architect. Your function is to grasp the venture necessities supplied initially after which collect needed particulars *from the Client_Input_Agent (representing the consumer/freelancer)*.
   1. Look ahead to the preliminary venture particulars from Client_Input_Agent.
   2. After getting the venture particulars, formulate clear questions for the Client_Input_Agent to ask the human consumer about their:
       - Related previous work/tasks and collaborations.
       - Key abilities and instruments relevant to this venture.
       - Their estimated time to finish the outlined work.
   3. Do NOT proceed to proposal technology. Look ahead to the Client_Input_Agent to offer the consumer's solutions.
   4. After getting each the consumer necessities AND the consumer's particulars (abilities, expertise, time estimate), summarize this info clearly for the Price Recommender. Sign that you've got all needed data.
   """,
)

3. Price Recommender Agent

The Price Recommender Agent makes use of the collected info to generate an in depth venture proposal. It waits for the entire abstract from the Scope Architect. Then analyzes the venture scope and freelancer particulars to generate knowledgeable proposal doc. This features a customized introduction, a timeline, a number of pricing tiers, and a transparent name to motion.

Anticipated Output:

• Professionally formatted venture proposal doc with a scope, pricing, and subsequent steps.
• The ultimate output is able to be delivered to the consumer for approval or additional dialogue.

rate_recommender_agent = autogen.AssistantAgent(
   identify="Rate_Recommender",
   llm_config=llm_config,
   max_consecutive_auto_reply=1, # Solely reply as soon as
   system_message=f"""
You're a Proposal Generator and Price Recommender. Your process is to create a structured venture proposal.
Wait till the Scope_Architect shares a abstract containing BOTH the consumer's venture necessities AND the consumer's profile (abilities, expertise, time estimate, previous work if accessible).
Analyze all obtained information: consumer wants, consumer experience, estimated time, and any prior charge insights.
Generate a well-structured proposal addressed to the consumer, together with the next sections:
Customized Introduction: Professionally introduce the consumer's providers and reference the consumer's firm and venture.
Undertaking Scope & Timeline: Clearly define the deliverables with estimated timelines based mostly on consumer enter.
Steered Pricing Tiers: Present 1–3 pricing choices (hourly, fastened payment, retainer) with justifications based mostly on scope, consumer expertise, or complexity.
Subsequent Steps (CTA): Suggest scheduling a quick kickoff name to finalize and make clear particulars.
Current ONLY the ultimate formatted proposal. Don't embrace extra commentary until clarification is requested.""",)

4. Person Proxy Agent

This agent acts as an entry level or helper to kick off the interplay. Although it doesn’t play a central function on this movement (based mostly on the code supplied), it could possibly be used to provoke or help with user-facing duties.

user_proxy = autogen.UserProxyAgent(
   identify="user_proxy",
   max_consecutive_auto_reply=1,
   # is_termination_msg=lambda x: x.get("content material", "").rstrip().endswith("TERMINATE"),
   llm_config=llm_config,
   system_message="""you're an useful assistant and initate the dialog"""
)

Step 4: Creating the Group Supervisor

This step units up the central coordinator that manages communication and teamwork between all specialised brokers.

1. Setting Up Group Chat

The Group Chat establishes a structured dialog surroundings for 3 specialised brokers. These are the consumer agent, scope architect agent, and charge recommender agent. It manages dialog movement by means of spherical limits and orderly speaker choice.

Key factors:

• Homes three specialised brokers working towards proposal creation
• 4 rounds most to keep up focus
• “Round_robin” talking sample ensures orderly participation
• Creates a managed surroundings for gathering info

# --- Group Chat Setup ---
groupchat = autogen.GroupChat(
   brokers=[client_agent, scope_architect_agent, rate_recommender_agent],
   messages=[],
   max_round=4,
   speaker_selection_method="round_robin",
)

2. Creating the Group Chat Supervisor

The Group Chat Supervisor orchestrates your entire dialog, guiding interactions by means of a logical development from venture particulars to proposal technology. Its system message offers step-by-step directions for agent interactions and defines clear termination situations.

Key factors:

• Directs dialog movement between all brokers
• Hyperlinks to the Group Chat object
• Maintains constant LLM configuration
• Accommodates detailed course of directions
• Terminates upon proposal completion or with the TERMINATE command

supervisor = autogen.GroupChatManager(
   groupchat=groupchat,
   llm_config=llm_config,
   # System message for the supervisor guiding the general movement
   system_message="""Handle the dialog movement between the brokers.
   1. Begin with the Client_Input_Agent offering venture particulars.
   2. Make sure the Scope_Architect asks the mandatory questions concerning the consumer's background.
   3. Make sure the Client_Input_Agent relays the consumer's solutions.
   4. Make sure the Rate_Recommender waits for all data earlier than producing the ultimate proposal within the specified format.
   The dialog finishes when the ultimate proposal is generated or the Client_Input_Agent says TERMINATE."""
)

Step 5: Initiating the Chat

Now that we have now the brokers in place, let’s provoke the collaborative workflow between the brokers. For this, we’ll ship a transparent instruction immediate to the GroupChatManager from the user_proxy agent.

Key factors:

• Triggers the dialog through the use of user_proxy.initiate_chat(), which begins the group chat and sends the message to the GroupChatManager.
• Delegates management to the supervisor, which then follows the step-by-step movement utilizing the round-robin technique and its inside system message directions to coordinate the brokers.

# --- Provoke Chat ---


print("Beginning the proposal technology course of...")
print("Please present the preliminary consumer and venture particulars when prompted.")


initial_prompt_message = """
Begin the method. First, I want the consumer/venture particulars from the consumer (by way of Client_Input_Agent).
Then, Scope_Architect ought to ask the consumer (by way of Client_Input_Agent) about their background.
Lastly, Rate_Recommender ought to generate the proposal.
"""


user_proxy.initiate_chat(
   supervisor,
   message=initial_prompt_message
)

Step 6: Formatting the Output

This code will assist us current the output in a markdown(.md) format.

chat_history = supervisor.chat_messages[client_agent] # Or doubtlessly simply supervisor.chat_messages if construction differs barely


# Discover the final message from the Rate_Recommender agent
final_proposal_message = None
for msg in reversed(chat_history):
   if msg.get("function") == "assistant" and msg.get("identify") == rate_recommender_agent.identify:
        if "Customized Introduction:" in msg.get("content material", ""):
           final_proposal_message = msg
           break
if final_proposal_message:
   final_proposal_string = final_proposal_message.get("content material", "Proposal content material not discovered.")
   strive:
       show(Markdown(final_proposal_string))
   besides NameError:
       print("n(Displaying uncooked Markdown textual content as wealthy output is unavailable)n")
       print(final_proposal_string)


else:
   print("nCould not robotically extract the ultimate proposal from the chat historical past.")
   print("It's possible you'll must overview the complete chat historical past above.")

Pattern Output

Conclusion

On this article, we constructed a venture proposal agent utilizing Llama 4 and AutoGen. The agent successfully gathered consumer necessities, structured the proposal, and delivered knowledgeable doc with clear pricing and timeline breakdowns. AutoGen dealt with the dialog movement, whereas Llama 4 ensured pure, context-aware responses all through. This collaboration simplified consumer communication, providing a streamlined answer for freelancers and consultants to automate proposal technology with minimal guide enter.

Llama 4 enhanced the agent’s efficiency with its improved instruction following, higher context retention, and environment friendly few-shot studying. Its potential to keep up coherence throughout multi-turn dialogues made the proposal technology course of extra clever and responsive. Moreover, the mannequin’s quick inference and low price made it appropriate for real-time functions. Collectively, Llama 4 and AutoGen allow highly effective agent workflows that enhance productiveness and professionalism in client-facing duties.

Regularly Requested Questions

Hello, I am Vipin. I am obsessed with information science and machine studying. I’ve expertise in analyzing information, constructing fashions, and fixing real-world issues. I intention to make use of information to create sensible options and continue learning within the fields of Knowledge Science, Machine Studying, and NLP.