DEV Community: Marin Pesa

AI-Agent with Python and Gemini AI

Marin Pesa — Thu, 09 Apr 2026 14:38:18 +0000

CONTENT:

AI agents are everywhere in 2026 — OpenClaw, Claude Code, Cursor. But how do they actually work under the hood? I built one from scratch using Python and Google's Gemini API to find out.

What Is an AI Agent (Really)?

Strip away the hype: an AI agent is a loop.

while task_not_done:
    1. Send context to LLM
    2. LLM decides: respond OR call a tool
    3. If tool call → execute it, feed result back to LLM
    4. If response → done

That's it. The magic is in function calling — the LLM doesn't just generate text, it generates structured tool calls that your code executes.

What I Built

An autonomous agent using the google-genai SDK that can:

Read files from the local filesystem
Write files with generated content
Run Python scripts and capture output
Chain multiple tools in sequence to solve complex tasks

Example interaction:

You: "Read data.csv, analyze it, and write a summary to report.txt"

Agent: [calls get_file_content("data.csv")]
Agent: [analyzes the data]
Agent: [calls write_file("report.txt", "Summary: ...")]
Agent: "Done. I've analyzed the CSV and written the summary to report.txt."

The agent decides on its own which tools to use and in what order. No hardcoded workflow.

How Function Calling Works

You define tools as Python functions with clear descriptions:

def get_file_content(file_path: str) -> str:
    """Read and return the content of a file at the given path."""
    with open(file_path, "r") as f:
        return f.read()

def write_file(file_path: str, content: str) -> str:
    """Write content to a file at the given path."""
    with open(file_path, "w") as f:
        f.write(content)
    return f"Successfully wrote to {file_path}"

def run_python_file(file_path: str) -> str:
    """Execute a Python file and return its output."""
    result = subprocess.run(["python", file_path], capture_output=True, text=True)
    return result.stdout or result.stderr

You pass these to the Gemini API as tool declarations. The model returns a function_call object instead of text when it wants to use a tool. Your code executes the function, sends the result back, and the loop continues.

Key Lessons

Absolute Paths Matter

My biggest debugging headache: the agent would pass raw user input as file paths instead of resolving them to absolute paths first. A resolve_path() utility function fixed hours of mysterious "file not found" errors.

The Agent Loop Is Everything

The core loop handles three states:

Model wants to call a tool → execute it, feed result back
Model generates text → return to user
Model generates nothing → something went wrong, break

Getting this loop right is 80% of building an agent.

System Prompts Shape Behavior

The difference between a helpful agent and a chaotic one is the system prompt. Mine specifies:

Available tools and when to use them
How to handle errors
When to ask for clarification vs. just doing it
Output format expectations

The Boot.dev Module

This project was part of Boot.dev's "AI Agents with Python" module. The course structure:

Start with raw API calls
Add function declarations
Build the agent loop
Handle multi-step tool chains
Add error handling and edge cases

Each step builds on the last. By the end you understand exactly how tools like Claude Code work at the fundamental level — they're just this loop, scaled up with more tools and better prompts.

Why This Matters

Understanding how agents work from the inside out changes how you think about AI tooling. You stop being a consumer of agents and start being a builder. My next project — AutoApply — uses this exact pattern at a larger scale: multiple agents orchestrated by Paperclip, each with their own tools, coordinating to automate job applications.

Try It

git clone https://github.com/marinpesa15/ai-agent.git
cd ai-agent
pip install google-genai
export GOOGLE_API_KEY=your-key
python main.py

From sysadmin to AI developer — one project at a time. Building in public.

GitHub: github.com/marinpesa15/ai-agent

First Pygame Project

Marin Pesa — Thu, 09 Apr 2026 14:33:24 +0000

CONTENT:

As part of my Python learning journey on Boot.dev, I rebuilt the classic Asteroids arcade game using Python and Pygame. It's one of those projects that looks simple on the surface but teaches you a surprising amount about real programming concepts.

What I Built

A fully playable Asteroids clone:

Spaceship you control with keyboard input
Asteroids that split into smaller pieces when shot
Collision detection between ship, bullets, and asteroids
Screen wrapping (fly off one edge, appear on the other)
Increasing difficulty as you progress

What I Actually Learned

Object-Oriented Programming — For Real

This was the project where OOP clicked for me. Every game object — the ship, asteroids, bullets — is its own class with its own update() and draw() methods. Inheritance makes sense when your Ship, Asteroid, and Shot all share a CircleShape base class.

The Game Loop

Every game is the same pattern:

Handle input
Update game state
Draw everything
Repeat at 60 FPS

Understanding this loop is fundamental. It's the same pattern used in animation, simulation, and even some backend event loops.

Vectors and Trigonometry

Rotating a ship, calculating bullet trajectories, detecting circular collisions — it all comes down to basic vector math. Pygame's Vector2 made this manageable, but you still need to understand what sin, cos, and atan2 actually do.

Collision Detection

Checking if two circles overlap is easy (distance < sum of radii). But doing it efficiently for dozens of objects per frame? That's where you start thinking about performance and data structures.

The Boot.dev Experience

Boot.dev structures these projects well. You get a clear spec, build incrementally, and each step introduces a new concept. The Asteroids project specifically covers:

Classes and inheritance
Pygame basics
Game loops and delta time
User input handling
Collision detection
Spawning and destroying game objects

For anyone starting with Python and wanting a project that's more fun than a todo app — highly recommended.

Try It

git clone https://github.com/marinpesa15/asteroids.git
cd asteroids
pip install pygame
python main.py

Part of my transition from IT sysadmin to Python developer. More projects coming — including an AI agent and a full automation platform.

GitHub: github.com/marinpesa15/asteroids

Automation for Applications

Marin Pesa — Thu, 09 Apr 2026 14:32:04 +0000

CONTENT:

I got tired of spending 45 minutes per job application — tailoring my CV, writing a cover letter, uploading the same PDFs over and over. So I'm building AutoApply: an AI-powered system that does it all autonomously through browser automation.

The Idea

You give it a natural language prompt:

"Go to LinkedIn, search for Junior Python Developer jobs near Augsburg, and apply to all of them."

The system takes over your browser, finds matching jobs, tailors your CV per job, generates a personalized cover letter, and submits the application — all through the actual web portal.

The Stack

Paperclip — Open-source multi-agent orchestrator. Manages all agents like a company: CEO delegates, specialists execute, you approve from a dashboard.
Browser Use — Python framework for AI-driven browser automation. 89% success rate on the WebVoyager benchmark, 86k+ GitHub stars. This is the "muscle" that controls the browser.
Claude API (Anthropic) — Powers the cover letter generation, CV tailoring, and quality checks. Sonnet for writing, Haiku for cheap filtering.
FastAPI — Each agent runs as a Python HTTP service that Paperclip calls via its HTTP adapter.
WeasyPrint — Renders tailored CVs and cover letters as clean PDFs.

Architecture

┌──────────────────────────────────────────────┐
│           PAPERCLIP ORCHESTRATOR             │
│                                              │
│  You (Board) ──approves──▶ CEO Agent         │
│                               │              │
│     ┌──────┬──────┬──────┬────┴────┐         │
│     ▼      ▼      ▼      ▼        ▼         │
│  Scout  Filter  Tailor  Letter  Applicant    │
│  (Browser (Haiku) (Sonnet)(Sonnet)(Browser   │
│   Use)                            Use)       │
└──────────────────────────────────────────────┘

The 7 Agents

Agent	Model	What it does
CEO	Sonnet	Breaks down your prompt, delegates tasks
Job Scout	No LLM	Browser Use searches LinkedIn, extracts job data
Pre-Filter	Haiku	Checks if the job matches your profile (~$0.001/job)
CV Tailor	Sonnet	Reweights skills, injects keywords, generates PDF
Cover Letter	Sonnet	Writes a personalized letter using the tailored CV
QA	Haiku	Checks CV ↔ letter consistency, no hallucinations
Applicant	No LLM	Browser Use fills forms, uploads docs, submits

Only 3 out of 7 agents need Claude tokens. Total cost: ~$1/day for 10 applications.

Key Design Decisions

CV Tailoring ≠ CV Fabrication

The CV Tailor works from a structured master_cv.json. It reweights, reorders, and rephrases — but never invents skills or experience. The QA agent compares the tailored version against the master and flags any deviation.

Human-in-the-Loop

Two operating modes:

Supervised — Browser is visible. Agent pauses on CAPTCHAs, unknown form fields, or external portals. You step in, solve it, agent continues.
Autonomous — Headless browser. Problems get logged as FAILED and skipped. For when you trust the system.

Fail Gracefully

Not every job can be applied to automatically. The system recognizes:

No apply button → FAILED
External portal redirect → FAILED
CAPTCHA → WAITING_HUMAN (supervised) or FAILED (autonomous)
Page 404 → FAILED

Failed jobs get logged with a reason. No silent failures.

Status Model

Every job goes through a clear pipeline:

FOUND → CV_READY → LETTER_READY → QA_PASSED → APPROVED → IN_PROGRESS → APPLIED
                                                                      → WAITING_HUMAN
                                                                      → FAILED

What's Next

Currently in Sprint 0 — setting up Paperclip, building the FastAPI skeleton, and wiring the HTTP adapters. Planning 6 one-week sprints to MVP.

The repo will be public once we have a working prototype. If you're interested in the project or want to contribute, drop a comment.

Built with Python, Paperclip, Browser Use, and Claude API. Two developers, 6 weeks, one mission: never write another cover letter by hand.

GitHub: github.com/marinpesa15