Hey there, agent builders and AI curious folks! Emma Walsh here, back with another dive into the wonderful world of AI agents. It’s April 28, 2026, and I’ve been spending way too much time lately (in the best possible way, of course) playing around with something that feels like a real step forward for us beginners: building simple AI agents that can actually talk to each other. Not just spitting out pre-canned responses, but genuinely exchanging information to achieve a goal. Forget those complex multi-agent simulations for a second; I’m talking about getting two little digital brains to collaborate on a task you give them. And honestly, it’s way easier than you might think.
For a while now, the idea of AI agents working together has felt a bit like science fiction, or at least something reserved for PhDs in AI labs. But with the advancements in language models, particularly in their ability to follow instructions and maintain context, we’re seeing tools emerge that put this kind of interaction within reach for anyone willing to roll up their sleeves. Today, I want to show you how we can set up a very basic two-agent system where one agent acts as a “Researcher” and another as a “Summarizer.” My goal? To get them to work together to give me a concise overview of a topic without me having to manually copy-paste between different prompts. It’s a small step, but it opens up a huge world of possibilities!
My Frustration with “One-Shot” AI Tasks
You know the drill. You open up your favorite large language model (LLM) interface, type in a detailed request, and get a pretty decent response back. But then you realize you need a follow-up, or you need that response processed further. So you copy the output, paste it into a new prompt, and give it another instruction. It’s effective, sure, but it feels clunky. It’s like having a super-smart assistant who can only handle one instruction at a time and forgets everything about the previous one unless you explicitly remind them. I found myself doing this constantly when I was trying to research new AI concepts for agent101.net. “Summarize this article,” then “Extract key terms,” then “Explain those key terms in simple language.” Each step was a manual intervention.
I started thinking, “What if I could just tell one AI, ‘Go research X, then tell another AI what you found, and then give me the summary’?” That’s when I started exploring frameworks that facilitate inter-agent communication. And while some of them get pretty sophisticated, I realized we can achieve a similar effect with just a few well-crafted prompts and a tiny bit of Python glue. No fancy orchestrators needed for our first foray!
The Dynamic Duo: Researcher and Summarizer
Let’s break down our simple system. We’re going to create two conceptual agents:
- The Researcher: This agent’s job is to go out (or simulate going out, in our case) and find information on a given topic. It will then present its findings in a raw, comprehensive format.
- The Summarizer: This agent takes the raw findings from the Researcher and condenses them into a clear, concise summary, tailored to a specific audience (like, say, a beginner AI agent enthusiast!).
The magic happens when the output of the Researcher becomes the *input* for the Summarizer. It’s a simple pipeline, but it mimics how humans collaborate. One person gathers the data, another makes sense of it for presentation.
Setting Up Our “Agents” (aka Smart Functions)
For this tutorial, I’m going to use Python because it’s super accessible and widely used. We’ll be interacting with an LLM API. For simplicity and broad accessibility, I’ll use a placeholder `call_llm` function. In a real scenario, this would be `openai.chat.completions.create` or similar, depending on your chosen provider. Just make sure you have your API key set up!
First, let’s define our `call_llm` function. This is just a stand-in for whichever LLM you prefer. I’ve been experimenting with several, but for this kind of structured interaction, most modern models do a fantastic job.
import os
# In a real scenario, you'd import your LLM client library, e.g., 'openai'
# from openai import OpenAI
# client = OpenAI(api_key=os.environ.get("OPENAI_API_KEY"))
# Placeholder function for calling an LLM
# In a real application, replace this with actual LLM API calls.
def call_llm(prompt, model="gpt-4o", temperature=0.7):
print(f"\n--- LLM Call ---")
print(f"Prompt: {prompt[:200]}...") # Print first 200 chars of prompt
# Simulate an LLM response based on the prompt.
# In a real application, this would be an API call.
if "research" in prompt.lower() and "ai agents" in prompt.lower():
return """
AI agents are autonomous software entities designed to perceive their environment, make decisions, and take actions to achieve specific goals. They operate without constant human intervention once initiated. Key characteristics include autonomy, proactivity, social ability (interacting with other agents or humans), and learning.
There are different types, including reactive agents (respond to current percepts), deliberative agents (plan actions based on internal models), and hybrid agents. Modern AI agents often leverage large language models (LLMs) for reasoning, planning, and communication.
Applications range from personal assistants and customer service bots to complex industrial control systems and scientific research. Challenges include ethical considerations, ensuring reliability, and handling unexpected situations.
"""
elif "summarize" in prompt.lower():
return """
AI agents are autonomous software that observe, decide, and act to meet goals without constant human oversight. They are characterized by independence, initiative, social interaction, and learning. Types vary from simple reactive agents to complex deliberative ones, often using LLMs for intelligence. They're used in areas like personal assistants and industrial control, facing challenges in ethics and reliability.
"""
else:
return "I'm sorry, "
print("LLM Placeholder function ready.")
Okay, with our `call_llm` function in place (remember to swap it out for a real one!), let’s define our two agents. These aren’t fancy classes or objects with internal states for now; they’re essentially functions with carefully crafted system prompts that define their role and behavior.
Agent 1: The Researcher
The Researcher’s job is to gather information. For our simple example, it won’t actually browse the internet. Instead, we’ll ask the LLM to *simulate* providing research based on its training data. This is a crucial distinction for beginners – we’re using the LLM’s vast knowledge base as our “internet” for this exercise.
def researcher_agent(topic):
system_prompt = (
"You are an expert researcher specializing in technology and AI. "
"Your goal is to provide comprehensive and factual information on a given topic. "
"Do not summarize or interpret; just present the raw, relevant findings. "
"If you don't have sufficient information, state that clearly."
)
user_query = f"Please research and provide detailed information about: {topic}"
# In a real LLM call, you'd pass messages like this:
# messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_query}]
# response = client.chat.completions.create(model="gpt-4o", messages=messages, temperature=0.7)
# return response.choices[0].message.content
# Using our placeholder:
prompt_for_llm = f"{system_prompt}\n\n{user_query}"
research_output = call_llm(prompt_for_llm)
return research_output
print("Researcher Agent function defined.")
Notice the system prompt: “Do not summarize or interpret; just present the raw, relevant findings.” This is key. We want the Researcher to focus purely on data retrieval, leaving the interpretation to the Summarizer.
Agent 2: The Summarizer
Now, for the Summarizer. This agent will take the output from the Researcher and distill it. I’ll instruct it to be concise and beginner-friendly, which is perfect for agent101.net!
def summarizer_agent(raw_information, audience="AI agents beginner"):
system_prompt = (
"You are a skilled technical writer and explainer, specializing in making complex AI topics "
"understandable for beginners. Your task is to take raw, detailed information "
"and summarize it clearly, concisely, and accurately for the specified audience. "
"Focus on key concepts and avoid jargon where possible. "
"Your summary should be no more than 3-4 paragraphs."
)
user_query = (
f"Please summarize the following information for an audience of '{audience}'. "
f"Ensure it is easy to understand and highlights the most important points:\n\n"
f"--- RAW INFORMATION ---\n{raw_information}\n--- END RAW INFORMATION ---"
)
# In a real LLM call:
# messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_query}]
# response = client.chat.completions.create(model="gpt-4o", messages=messages, temperature=0.7)
# return response.choices[0].message.content
# Using our placeholder:
prompt_for_llm = f"{system_prompt}\n\n{user_query}"
summary_output = call_llm(prompt_for_llm)
return summary_output
print("Summarizer Agent function defined.")
Here, the system prompt explicitly sets the role and the goal: “making complex AI topics understandable for beginners.” The user query then feeds it the Researcher’s output. This chaining is the core of our multi-agent interaction.
Putting It All Together: The Orchestration
Now for the fun part: making them talk! We’ll define a simple orchestration function that calls the Researcher first, then passes its output directly to the Summarizer.
def orchestrate_research_and_summarize(topic, target_audience="AI agents beginner"):
print(f"\n[ORCHESTRATOR] Initiating research on: '{topic}'")
# Step 1: Researcher Agent does its work
raw_research = researcher_agent(topic)
print(f"\n[ORCHESTRATOR] Researcher completed. Raw information length: {len(raw_research)} characters.")
# print(f"--- RAW RESEARCH OUTPUT ---\n{raw_research[:500]}...\n--- END RAW RESEARCH ---") # Optional: print some raw output
# Step 2: Summarizer Agent takes the raw research as input
print(f"\n[ORCHESTRATOR] Passing raw information r for audience: '{target_audience}'")
final_summary = summarizer_agent(raw_research, target_audience)
print(f"\n[ORCHESTRATOR] Summarization complete.")
return final_summary
print("Orchestration function defined.")
And finally, let’s run it!
if __name__ == "__main__":
print("\n--- Starting Agent Collaboration ---")
# Example 1: Research and summarize "AI Agents"
topic_1 = "AI Agents"
result_1 = orchestrate_research_and_summarize(topic_1)
print(f"\n=== FINAL SUMMARY FOR '{topic_1}' ===\n{result_1}\n")
print("--- Example 1 Complete ---")
# Example 2: Research and summarize "Reinforcement Learning basics"
# Note: Our placeholder LLM might not have a specific response for this,
# so the output will reflect that. In a real LLM, this would work!
# topic_2 = "Reinforcement Learning basics"
# result_2 = orchestrate_research_and_summarize(topic_2, "data science students")
# print(f"\n=== FINAL SUMMARY FOR '{topic_2}' ===\n{result_2}\n")
# print("--- Example 2 Complete ---")
When you run this (after replacing `call_llm` with your actual LLM API calls), you’ll see the Researcher’s output being generated and then fed into the Summarizer, which then produces the final, beginner-friendly summary. It’s a simple chain, but incredibly powerful for automating multi-step tasks!
My Takeaways from This Experiment
Setting this up, even in this simplified form, really hammered home a few points for me:
- Prompt Engineering is Agent Design: For simple agents like these, the system prompt *is* the agent’s definition. How clearly and precisely you define its role, goals, and constraints directly impacts its performance. It’s like writing a job description for a digital employee.
- The Power of Chaining: The magic isn’t in each agent individually, but in how their outputs flow into each other. This is the fundamental concept behind more complex agentic workflows. One agent’s output becomes another’s context or instruction.
- Start Simple, Iterate: I could have tried to build a RAG-powered Researcher or a Summarizer that cross-references facts. But for a first step, just getting two LLM calls to interact sequentially was a huge win and taught me the basics of orchestration.
- Error Handling is Crucial (Even in Simple Setups): What if the Researcher returns nothing? Or garbage? Our current setup just passes it along. In a real application, you’d want checks and balances. This is where more advanced agent frameworks come in handy, but it’s good to think about it early.
- Cost Considerations: Every LLM call costs money. Chaining agents means multiple calls. Keep an eye on your usage, especially when experimenting!
This little Researcher-Summarizer duo has become a go-to script for me when I’m trying to quickly get up to speed on a new topic for the blog. Instead of endless copy-pasting, I just hit run, and within seconds, I have a distilled summary ready for my beginner audience. It’s not perfect, and sometimes I still tweak the prompts, but it’s a massive time-saver.
Actionable Takeaways for YOU!
- Implement This Example: Seriously, copy the code, replace `call_llm` with your actual LLM API client, and run it. See it in action. That’s the best way to learn.
- Experiment with Roles: Change the Researcher’s prompt to be a “Critical Analyst” or the Summarizer’s to be a “Storyteller.” See how the output changes.
- Add a Third Agent: What if you added a “Fact Checker” agent that takes the summary and tries to verify a few key points? Or a “Question Generator” that creates quiz questions from the summary?
- Consider Your Tools: While we used basic Python functions, explore libraries like LangChain or CrewAI. They provide more structured ways to define agents, tasks, and communication, making complex orchestrations easier to manage down the line. But don’t jump straight there; understand the fundamentals first!
- Think About Your Own Workflow: Where do you manually copy-paste information between different AI prompts? Can you automate that with a simple agent chain? That’s your next project!
Building AI agents, even simple ones that just pass information along, feels incredibly empowering. It’s like moving from giving single commands to having a mini-team working for you. This is just the very beginning of what’s possible, and I’m excited to see what collaborations you’ll create. Happy agent building!
đź•’ Published: