Hey everyone, Emma here from agent101.net!
So, it’s 2026, and if you’re anything like me, your inbox is probably overflowing with “AI this” and “AI that.” Every other week, there’s a new framework, a new model, a new promise of an AI that will do your taxes, walk your dog, and maybe even write your next novel. It’s exciting, don’t get me wrong, but it can also feel a bit… overwhelming. Especially when you’re just starting out and trying to figure out what an “AI agent” even *is*, beyond the marketing hype.
A few months ago, I had a real “aha!” moment. I was trying to automate a super tedious task for my personal finances – basically, tracking specific types of spending across multiple bank accounts and then categorizing them in a spreadsheet. I’d tried all the off-the-shelf solutions, but nothing quite fit my quirky categories. That’s when I thought, “Surely an AI agent could help with this, right?”
The problem was, every tutorial I found felt like it was written for someone with a PhD in computer science. They jumped straight into multi-agent systems, complex orchestration, and terms like “ontologies” that made my eyes glaze over. I just wanted to build a simple agent to do one specific thing! I wanted to understand the absolute bare bones, the “hello world” of AI agents. And that, my friends, is exactly what we’re going to tackle today.
We’re going to build a super simple, single-purpose AI agent that can interact with a large language model (LLM) to perform a specific, focused task. Think of it as your first step into creating your own digital assistant, tailored exactly to your needs. No fancy frameworks, no multi-agent complexities. Just a practical, hands-on guide to getting your first agent up and running.
The “Why”: Beyond Chatbots
Before we dive into the how, let’s quickly touch on the “why.” You might be thinking, “Emma, I can already talk to ChatGPT. Isn’t that an agent?” And you’re not wrong to some extent! ChatGPT is incredibly powerful. But a standalone chatbot is reactive – you ask it something, it responds. An AI agent, in its simplest form, is designed to be proactive and goal-oriented. It has a specific objective, can make decisions, and can often interact with its environment (even if that environment is just an API or a file system) to achieve that objective.
My finance tracking problem is a perfect example. I didn’t want to manually type in transaction descriptions and ask ChatGPT to categorize them one by one. I wanted something that could *take* the transactions, *figure out* what they were, and then *put them* into the right categories, all with minimal intervention from me. That’s the core difference: agency. It’s about empowering the AI to act on its own behalf, within defined boundaries, to achieve a goal.
Our First Agent: The “Summarize & Tag” Bot
For our practical example, we’re going to build a super simple agent I call the “Summarize & Tag” bot. Imagine you often get long emails, articles, or meeting notes, and you want two things quickly: a concise summary and a few relevant tags (keywords) for easy searching later. This is a perfect, contained problem for our first agent.
Here’s what our agent will do:
- Receive a piece of text (e.g., an article, email body).
- Use an LLM to generate a short summary of the text.
- Use the same LLM to generate 3-5 relevant tags for the text.
- Present both the summary and the tags.
We’ll keep it simple, using Python because it’s so beginner-friendly and widely used for AI tasks. We’ll also use one of the popular LLM APIs – I’ll show you how with OpenAI, but the principles apply to others like Anthropic’s Claude or Google’s Gemini.
What You’ll Need (The Bare Minimum)
- Python installed on your machine (version 3.8 or higher is good).
- An API key for an LLM provider (e.g., OpenAI API key). You’ll need to sign up on their website and add some credit. Don’t worry, for simple tasks, the cost is usually pennies.
- A text editor (VS Code, Sublime Text, or even Notepad++ works).
Step 1: Setting Up Your Environment
First, let’s get our Python environment ready. Open your terminal or command prompt.
# Create a new directory for your project
mkdir my_first_agent
cd my_first_agent
# Create a virtual environment (good practice!)
python3 -m venv venv
source venv/bin/activate # On Windows: .\venv\Scripts\activate
# Install the OpenAI library
pip install openai python-dotenv
The `python-dotenv` library is super useful for keeping your API key out of your code directly, which is a big security best practice. Never hardcode your API keys!
Next, create a file named `.env` in your `my_first_agent` directory. Inside this file, put your OpenAI API key like this:
OPENAI_API_KEY="sk-your_actual_openai_api_key_here"
Replace `”sk-your_actual_openai_api_key_here”` with your real key. Save and close this file.
Step 2: Designing Our Agent’s “Brain” (The Prompt)
The core of any LLM-powered agent is its prompt. This is how we instruct the LLM on what we want it to do. For our Summarize & Tag bot, we need a clear, specific prompt.
Think of it like giving instructions to a very intelligent but literal intern. You need to be explicit.
# In your main Python file (e.g., agent.py)
SYSTEM_PROMPT = """
You are a helpful text analysis assistant. Your goal is to provide a concise summary and relevant tags for any given text.
When I provide a text, you will:
1. Generate a summary that is no more than 3 sentences long.
2. Generate 3 to 5 single-word tags that represent the main topics or keywords of the text.
Format your output strictly as follows:
Summary: [Your 3-sentence summary here]
Tags: [tag1, tag2, tag3, tag4, tag5] (or fewer if appropriate, separated by commas)
Ensure your summary is objective and your tags are highly relevant.
"""
This `SYSTEM_PROMPT` is crucial. It sets the role of the AI and outlines the expected output format. This helps the LLM stay on track and gives us consistent results, which is super important for an agent that needs to perform a repeatable task.
Step 3: Building the Agent’s “Body” (The Python Code)
Now, let’s put it all together in a Python script. Create a file named `agent.py` in your `my_first_agent` directory.
import os
from openai import OpenAI
from dotenv import load_dotenv
# Load environment variables from .env file
load_dotenv()
# Initialize the OpenAI client
# It will automatically pick up the OPENAI_API_KEY from os.environ
client = OpenAI()
SYSTEM_PROMPT = """
You are a helpful text analysis assistant. Your goal is to provide a concise summary and relevant tags for any given text.
When I provide a text, you will:
1. Generate a summary that is no more than 3 sentences long.
2. Generate 3 to 5 single-word tags that represent the main topics or keywords of the text.
Format your output strictly as follows:
Summary: [Your 3-sentence summary here]
Tags: [tag1, tag2, tag3, tag4, tag5] (or fewer if appropriate, separated by commas)
Ensure your summary is objective and your tags are highly relevant.
"""
def summarize_and_tag_agent(text_to_process: str):
"""
Our simple AI agent and tag text using an LLM.
"""
try:
response = client.chat.completions.create(
model="gpt-3.5-turbo", # Or "gpt-4" if you have access and want better quality
messages=[
{"role": "system", "content": SYSTEM_PROMPT},
{"role": "user", "content": text_to_process}
],
temperature=0.7, # Controls randomness: 0.0 is deterministic, 1.0 is very creative
max_tokens=250 # Limit the output length to avoid overly long responses
)
agent_output = response.choices[0].message.content
return agent_output
except Exception as e:
print(f"An error occurred: {e}")
return None
if __name__ == "__main__":
# Example usage of our agent
article_text = """
In a groundbreaking study published last week, researchers at the Institute for Advanced Robotics unveiled a new method for teaching autonomous drones to navigate complex urban environments with unprecedented accuracy. The technique, dubbed "Neuro-Spatial Mapping," involves a novel combination of deep reinforcement learning and real-time lidar data processing. This allows the drones to build highly detailed 3D maps of their surroundings, predict pedestrian movements, and identify potential hazards with a much lower error rate than previous systems. Experts believe this development could significantly impact package delivery, search and rescue operations, and infrastructure inspection, paving the way for wider adoption of drone technology in densely populated areas. However, concerns about privacy and air traffic control integration remain, highlighting the need for robust regulatory frameworks to accompany these technological advancements.
"""
print("--- Running Summarize & Tag Agent ---")
result = summarize_and_tag_agent(article_text)
if result:
print("\nAgent Output:")
print(result)
# Basic parsing (can be improved for robustness)
summary_line = [line for line in result.split('\n') if line.startswith("Summary:")][0]
tags_line = [line for line in result.split('\n') if line.startswith("Tags:")][0]
summary = summary_line.replace("Summary: ", "").strip()
tags_str = tags_line.replace("Tags: ", "").strip()
tags = [tag.strip() for tag in tags_str.split(',')]
print("\n--- Parsed Output ---")
print(f"Summary: {summary}")
print(f"Tags: {tags}")
else:
print("Agent failed to produce a result.")
print("\n--- Another Example ---")
email_text = """
Subject: Q1 Project Review Meeting Rescheduled
Hi Team,
Just a quick note to let everyone know that the Q1 Project Review meeting, originally scheduled for next Tuesday, April 2nd, has been moved. We've had a conflict arise with the availability of the VP of Engineering, who needs to be present. The new date is now Thursday, April 11th, at 10:00 AM in Conference Room 3. Please update your calendars accordingly. An updated invite will be sent out shortly. Apologies for any inconvenience this may cause.
Best regards,
Sarah
Project Coordinator
"""
result_email = summarize_and_tag_agent(email_text)
if result_email:
print("\nAgent Output (Email):")
print(result_email)
else:
print("Agent failed for email example.")
Let’s break down what’s happening in `agent.py`:
- `import os`, `openai`, `dotenv`: We bring in the necessary libraries.
- `load_dotenv()`: This line loads your `OPENAI_API_KEY` from the `.env` file into your script’s environment variables.
- `client = OpenAI()`: This initializes the OpenAI client. It automatically looks for `OPENAI_API_KEY` in your environment.
- `SYSTEM_PROMPT`: Our carefully crafted instructions for the LLM.
- `summarize_and_tag_agent(text_to_process: str)`: This is the heart of our agent.
- It makes a call to `client.chat.completions.create`. This is how you interact with OpenAI’s chat models.
- `model=”gpt-3.5-turbo”`: We’re using a good, cost-effective model. You could upgrade to `gpt-4` for higher quality if needed.
- `messages`: This is a list of dictionaries representing the conversation. The `system` role establishes the agent’s persona and instructions, and the `user` role provides the actual text to be processed.
- `temperature=0.7`: This parameter controls how “creative” or “random” the LLM’s response is. Lower values (e.g., 0.2) make it more focused and deterministic, higher values (e.g., 0.9) make it more varied. For summarization, we want it fairly consistent, so 0.7 is a good balance.
- `max_tokens=250`: This sets an upper limit on the length of the LLM’s response. Helpful for controlling costs and ensuring conciseness.
- `if __name__ == “__main__”:`: This block runs when you execute the script directly. It provides example text and prints the results. I’ve even included a basic parsing example to show how you might extract the summary and tags programmatically.
Step 4: Running Your First Agent!
Now for the exciting part! Save your `agent.py` file and go back to your terminal (make sure your virtual environment is still activated: `source venv/bin/activate`).
python agent.py
You should see output similar to this (the exact wording might vary slightly due to the LLM’s nature, but the format should be consistent):
--- Running Summarize & Tag Agent ---
Agent Output:
Summary: Researchers at the Institute for Advanced Robotics have developed "Neuro-Spatial Mapping," a new method for autonomous drones to navigate complex urban environments. This technique combines deep reinforcement learning and real-time lidar data, allowing drones to build detailed 3D maps and predict movements with high accuracy. This advancement could revolutionize package delivery and search and rescue, though privacy and regulatory concerns persist.
Tags: Drones, Robotics, Navigation, AI, Urban
--- Parsed Output ---
Summary: Researchers at the Institute for Advanced Robotics have developed "Neuro-Spatial Mapping," a new method for autonomous drones to navigate complex urban environments. This technique combines deep reinforcement learning and real-time lidar data, allowing drones to build detailed 3D maps and predict movements with high accuracy. This advancement could revolutionize package delivery and search and rescue, though privacy and regulatory concerns persist.
Tags: ['Drones', 'Robotics', 'Navigation', 'AI', 'Urban']
--- Another Example ---
Agent Output (Email):
Summary: The Q1 Project Review meeting, originally set for April 2nd, has been rescheduled to Thursday, April 11th, at 10:00 AM in Conference Room 3. This change is due to a conflict with the VP of Engineering's availability. An updated invite will be sent soon.
Tags: Meeting, Reschedule, Project, Q1, Review
Congratulations! You’ve just built and run your very first AI agent! It might be simple, but it demonstrates the core concept: a goal-oriented AI interacting with an LLM to perform a specific task based on your instructions.
What’s Next? Making It Your Own
This is just the starting point, of course. Here are some ideas for how you can extend and experiment with your new agent:
- Different Models: Try changing `gpt-3.5-turbo` to `gpt-4` (if you have access) and observe the quality difference. Or try a different provider’s model entirely.
- More Complex Prompts: Experiment with the `SYSTEM_PROMPT`. Can you make it extract specific entities (names, dates, locations)? Can it translate the summary into another language?
- Input Methods: Instead of hardcoding `article_text`, could you make the agent read from a file? Or take input directly from the command line?
- Output Methods: Instead of just printing, could the agent write the summary and tags to a new file? Or even upload them to a database?
- Error Handling: The `try-except` block is a start, but you could add more sophisticated error checking, especially for parsing the output if the LLM doesn’t follow the format perfectly every time.
- Tool Use (A Glimpse into the Future): This agent is purely linguistic. The next step in agent development often involves “tool use,” where the agent can call external functions (like searching the web, sending an email, or performing calculations) based on its understanding of the task. That’s a topic for another day, but it builds directly on this foundation!
Actionable Takeaways
- Start Simple: Don’t try to build a super-agent on day one. Pick one specific, achievable task.
- Prompt Engineering is Key: Your agent is only as good as its instructions. Be clear, precise, and specify the desired output format.
- Use Environment Variables: Protect your API keys!
- Iterate and Experiment: Tweak your prompts, try different models, and see how the agent behaves. This is how you learn what works.
- Understand the “Why”: An agent isn’t just a chatbot; it’s a goal-oriented system designed to act and achieve objectives.
Building your first AI agent can feel like cracking a secret code, but I hope this tutorial has demystified it a bit. It’s a powerful concept, and once you grasp these basics, a whole new world of automation and intelligent systems opens up. Go forth and build!
Happy coding, and I’ll catch you in the next one!
Emma
agent101.net
🕒 Published: