Forem: Wilhelm Tell

Worth your time for AI developers (and vibe coders) to learn the basics of LLM integration techniques.

Wilhelm Tell — Sat, 14 Mar 2026 18:24:33 +0000

klement Gunndu

Feb 23

Why Your AI Agent Forgets Everything (And How to Fix It)

#ai #python #langchain #tutorial

Comments 5

11 min read

I Plugged Gemini Into My 10,000-Line Rental Platform. Here's What Happened.

Wilhelm Tell — Tue, 03 Mar 2026 00:18:39 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

BorrowHood is a neighborhood sharing platform I built from a camper van in Trapani, Sicily. 10,000+ lines of Python. 100+ REST endpoints. 30+ database models. Keycloak authentication. Weighted reputation system where a Legend's review counts 10x more than a Newcomer's. Auctions with anti-snipe protection. CEFR language proficiency matching so expats can find neighbors who speak their language.

I built the platform with Claude Code. Some demo videos on YouTube. A live instance on Hetzner FOR EXAMPlE: https://46.62.138.218/demo-login

Then I saw the Gemini writing challenge and thought: what if I added a brain?

Not replacing anything. Adding an intelligence layer on top of what already exists. Three AI agents powered by Google Gemini, using Google's Agent Development Kit (ADK), talking to my production API.

Agent 1: Smart Listing Assistant

User says "I want to list a Bosch power drill." Gemini searches existing items on the platform for price comparison, checks the 31 valid categories, and generates a complete listing:

{
  "title": "Bosch GSB 18V Cordless Impact Drill",
  "description": "My trusty Bosch GSB 18V cordless impact drill is looking
    for a new adventure! It's been with me for about two years and is still
    in good working condition, perfect for all your home improvement projects.",
  "category": "power_tools",
  "subcategory": "drills",
  "condition": "good",
  "suggested_price": 8.0,
  "price_unit": "per_day",
  "deposit_suggestion": 24.0,
  "tags": ["power drill", "Bosch", "cordless drill"],
  "story_suggestion": "This drill has helped me hang countless shelves and
    assemble quite a few IKEA nightmares -- it's a real workhorse!"
}

That story suggestion? The agent came up with "IKEA nightmares" on its own. I call this the Grandma Test: if an 83-year-old in a wheelchair can understand your listing description, it passes.

Agent 2: Review Sentiment Analyzer

Ask "Analyze Sally Thompson's reviews" and Gemini pulls all her reviews from the API, checks the reviewer's badge tier (because a review from a PILLAR member carries 8x the weight of a NEWCOMER), and returns:

{
  "user_name": "Sally Thompson",
  "badge_tier": "trusted",
  "sentiment": { "positive": 1, "neutral": 0, "negative": 0 },
  "average_rating": 5.0,
  "weighted_average": 5.0,
  "fake_review_flags": ["No fake review indicators detected"],
  "top_keywords": {
    "positive": ["immaculate", "changed my life", "focaccia", "pro"],
    "negative": []
  },
  "summary": "Sally Thompson, a TRUSTED tier member, has an excellent
    reputation on BorrowHood. Her single review, from a highly influential
    PILLAR member, praises her KitchenAid stand mixer as 'immaculate'."
}

The agent understood the weighted reputation system without me hardcoding any analysis logic. It figured out that one review from a PILLAR member means more than five reviews from newcomers.

Agent 3: AI Concierge

Natural language search. "I need something to cut tree branches" becomes an API search for garden tools, power tools, and saws. When nothing matches, the concierge responds like a neighbor, not a search engine:

"I'm sorry, I couldn't find any listings for tree-cutting tools right now. Would you like to try searching for 'garden tools' or 'power tools'? Or perhaps you have a different type of cutting tool in mind?"

The Root Orchestrator

One agent routes everything. Listing questions go to the Listing Assistant. Reputation questions go to the Review Analyzer. Search queries go to the Concierge. General BorrowHood questions, it answers directly.

root_agent = Agent(
    model="gemini-2.5-flash",
    name="borrowhood_agent",
    sub_agents=[listing_assistant, review_analyzer, concierge],
)

Four lines of code to wire three specialists into one brain.

Demo

GitHub: github.com/akenel/borrowhood
Live demo: BorrowHood Demo Login
YouTube playlist: BorrowHood: The Garage Sessions

The agents sit in the agents/ directory of the repo and call the same REST API that the web frontend uses. No special database access. No coupling. The intelligence layer sits on top of the platform, not inside it.

BorrowHood (FastAPI, 100+ endpoints)
    |
    +-- agents/
    |   +-- agent.py             (root orchestrator)
    |   +-- listing_assistant.py
    |   +-- review_analyzer.py
    |   +-- concierge.py
    |   +-- tools/
    |       +-- items.py         (search_items, get_categories)
    |       +-- reviews.py       (get_user_reviews, get_review_summary)
    |       +-- users.py         (search_members, get_user_profile)
    |       +-- common.py        (auth, HTTP helpers)

The tools are plain Python functions that wrap httpx calls:

def search_items(query: str, category: str = "", limit: int = 10) -> dict:
    """Search BorrowHood items by keyword and optional category."""
    params = {"q": query, "limit": limit}
    if category:
        params["category"] = category
    return bh_get("/api/v1/items", params=params)

The ADK automatically introspects the function signature and docstring, presenting them as tool descriptions to Gemini. The model decides when to call which tool based on the user's query. Zero prompt engineering for tool selection.

What I Learned

1. The ADK is genuinely good. I expected boilerplate. I got four lines to wire three agents. The Agent class, sub_agents for delegation, automatic tool introspection from function docstrings. This is how agent frameworks should work: code-first, no YAML, no visual builders.

listing_assistant = Agent(
    model="gemini-2.5-flash",
    name="listing_assistant",
    instruction="You are a listing assistant for BorrowHood...",
    tools=[search_items, get_categories],
)

That is the entire agent definition. The instruction tells it what to do. The tools tell it what it can access. Done.

2. Gemini understands context it was not trained on. I told the Review Analyzer about BorrowHood's weighted reputation system: "NEWCOMER = 1x, ACTIVE = 2x, TRUSTED = 5x, PILLAR = 8x, LEGEND = 10x." In its analysis of Sally, it correctly noted that her single review from a PILLAR member "carries significant weight." It applied the weighting concept to the actual data and drew a conclusion. That is comprehension, not pattern matching.

3. Existing APIs are the perfect tool layer. I did not need to write any new backend code. BorrowHood already had 100+ endpoints covering items, reviews, users, listings, and badges. The agents just needed thin wrapper functions that translate ADK tool calls into REST API requests. The entire tools layer is 150 lines of Python. If your app already has an API, you are 80% of the way to having an AI agent.

4. Agent delegation beats one mega-agent. My first instinct was one agent with all tools. Wrong. The root orchestrator with three specialists is cleaner, faster, and produces better results. Each specialist has a focused instruction and a small tool set. The root agent's only job is routing.

Google Gemini Feedback

The Good

gemini-2.5-flash is fast and smart. The Listing Assistant generated a complete, valid JSON listing in under 3 seconds. It picked the right category from 31 options. It suggested a fair rental price (EUR 8/day for a power drill) by checking similar items on the platform. It even wrote a story about "IKEA nightmares."

The ADK is excellent. Minimal boilerplate. Python-native. Tool introspection from docstrings is a killer feature. Multi-agent delegation with sub_agents just works. I went from zero to three working agents in under an hour.

Tool use is reliable. Gemini consistently called the right tools with the right parameters. When the Review Analyzer needed Sally's reviews, it first searched for "Sally Thompson" via search_members, got her ID, then called get_user_reviews and get_review_summary with that ID. Multi-step tool chains work without babysitting.

The Bad

Free tier rate limits are punishing. gemini-2.5-flash free tier: 5 requests per minute, 20 requests per day. A single multi-agent query can burn 4-6 requests (root agent + sub-agent + tool calls + follow-up). I ran exactly 3 test queries before hitting the daily limit. For a developer evaluating whether to build on Gemini, 20 requests per day is not enough to finish a single testing session.

New API key propagation is confusing. I created a fresh project and API key. The first 5 minutes: every model returned limit: 0 errors. No requests allowed. No warning in the console. I had to wait blindly for quotas to propagate. A "your key is provisioning, try again in 5 minutes" message would save developers real confusion.

Model naming is a moving target. gemini-1.5-flash returned 404. gemini-2.0-flash hit rate limits. gemini-2.5-flash worked. The API lists 16+ model variants including gemini-3-flash-preview and gemini-2.5-flash-lite. Which one should I use? The docs say gemini-2.0-flash but the API disagreed. Clearer "use THIS model" guidance would help.

The Ugly

I have history with Gemini. 11 months ago, before I met Claude, I was learning AI with Gemini. It made mistakes that felt almost deliberate. Hallucinations in code that compiled but did the wrong thing. I had to stop using it entirely. That experience taught me what to look for in an AI coding partner, and ultimately led me to Claude Code by Anthropic which I use to build BorrowHood.

Coming back to Gemini now through the ADK, I see real improvement. gemini-2.5-flash is a different animal. It follows structured output instructions, calls tools correctly, and understands domain context from instructions alone. The 11-month gap shows.

What Is Next

BorrowHood has four more agents designed:

Cross-Language Matchmaker -- Luna's 3D design files say "Needs: 3D printer." Jake's listing says "Compatible with: STL." The agent finds these matches across language barriers using CEFR proficiency data.
Onboarding Wizard Agent -- Walk new users through setting up their workshop via conversation.
Dispute Resolution Assistant -- When a rental goes wrong, the agent reviews both sides and suggests fair resolution.
Community Pulse Agent -- Weekly digest of neighborhood activity.

The data model already supports all of this. The agents just need to be wired up.

BorrowHood is open source. Free as in freedom. No platform fees. Your data is yours.

Built from a camper van in Trapani, Sicily. Every neighborhood has a garage like his.

Tech stack: FastAPI, SQLAlchemy, Keycloak OIDC, PostgreSQL, Redis, Docker, Tailwind CSS, Alpine.js
AI: Google Gemini 2.5 Flash via ADK (agents), Claude Code by Anthropic (platform development)
Hosting: Hetzner Cloud (EUR ~15/month)

BorrowHood: Every Garage Becomes a Rental Shop

Wilhelm Tell — Sun, 01 Mar 2026 21:37:01 +0000

The Community

My father Albert was a hand-shovel landscaper in Switzerland from 1960 to 2020. His garage had 500 tools. When he passed, they sat there collecting dust. His neighbors still needed shovels, rakes, and chainsaws -- they just didn't know where to look.

Craigslist is a wasteland. Facebook Marketplace is a data farm. Neither cares about your neighborhood.

BorrowHood is for real neighborhoods -- the people on your street who own a drill you need once, a stand mixer sitting idle, a welder gathering dust. Every user is a workshop. Every garage becomes a rental shop. Every kitchen becomes a bakery.

The community I built for: neighbors who share things instead of buying things they'll use once.

What I Built

A full-stack community rental and sharing platform where people list their underused tools, kitchen gear, equipment, and skills -- and neighbors borrow, rent, or trade. No middlemen. No fees. No algorithm deciding who sees what.

Demo
GitHub: github.com/akenel/borrowhood
Live demo: BorrowHood Demo Login > https://LaPiazza.app/demo-login
YouTube playlist: BorrowHood: The Garage Sessions > https://www.youtube.com/playlist?list=PLrRlgzUrqK1_hZPY_6xyogQxCVbEAQBKp

Note: Your browser will show a certificate warning on first visit -- the server uses a self-signed TLS certificate (no domain, just an IP). Click Advanced > Proceed to site. It only happens once.

What it does

Eight ways to share:

Rent -- borrow a drill for the weekend
Sell -- offload gear you don't need
Give Away -- free items, simplified claim flow, earns Generous Neighbor badge
Auction -- competitive bidding with reserve prices and anti-snipe protection
Commission -- custom made-to-order items
Service -- plumbing, tutoring, bike repair
Training -- teach a neighbor your skill
Offer -- name your price / make an offer

Full rental lifecycle:
Request > Approve > Pickup (lockbox code) > Return (lockbox code) > Review > Complete. With security deposits, dispute resolution, and PayPal payments at every step.

Security deposits -- peer-to-peer insurance:
You lend your neighbor a EUR 2,000 drone. How do you know you get it back in one piece? The deposit. The owner sets the amount. The renter pays it at pickup. Bring it back in one piece -- deposit returned. Break it -- owner keeps the deposit. No insurance company. No paperwork. Just neighbors handling it themselves. If they disagree, the 3-step dispute resolution kicks in and the deposit follows the outcome automatically.

Reputation that means something:
15 badges across 5 tiers (Newcomer to Legend). Reviews are weighted by the reviewer's badge tier -- a Legend's 5-star review counts 10x more than a Newcomer's. Your reputation is earned, not gamed.

Bilingual from day one:
One click switches the entire app between English and Italian. Navigation, forms, badges, categories, filters, error messages -- 500+ translated strings, nothing left behind.

Feature highlights

Feature	What it does
Workshop profiles	Every user is a shop with skills, CEFR language levels, social links
Auction system	Timed bidding, auto-outbid notifications, reserve prices, bid increments
Giveaway flow	Free items, simplified claim, no return dates, Generous Neighbor badge
Lockbox codes	One-time 8-character codes for contactless pickup and return
Security deposits	Owner sets amount, hold at pickup, auto-release on return, forfeit on damage
Dispute resolution	3-step flow: file, respond, resolve (8 reasons, 7 resolutions, deposit auto-wired)
Community helpboard	Post requests ("Need a ladder this Saturday"), get replies, track status
AI-assisted listings	Generate descriptions and images via Pollinations API
Notification bell	15 event types with optional Telegram bot forwarding
GitHub OAuth	Sign in with GitHub via Keycloak identity provider
Onboarding wizard	3-step profile setup for new users

Demo

6-part video series showing every feature live on a production server:

EP1 -- Giveaway Flow -- free items, simplified claim
EP2 -- Rental Flow -- full lifecycle from request to review
EP3 -- Auction System -- competitive bidding with anti-snipe
EP4 -- Badge System -- 15 badges, 5 reputation tiers
EP5 -- Multilingual Live Switch -- one click, every label, instant
EP6 -- Deposit System -- hold, release, forfeit, dispute resolution

Live demo: https://46.62.138.218
Log in as angel / helix_pass or use Sign in with GitHub.

Code

GitHub: github.com/akenel/borrowhood

By the numbers

Metric	Count
Python source lines	10,625
HTML template lines	6,244
Test lines	2,220
SQLAlchemy models	32
Typed enums	37
REST API endpoints	109
Automated tests	250 (201 without DB)
Puppeteer screen tests	52 edge-case checks
i18n strings	476 (EN + IT)
Seed data items	119 across 21 categories

250 automated tests across 23 test files (201 pass without any database). Rental state machine alone has 26 tests covering every valid and invalid transition. Plus 52 Puppeteer edge-case screen tests covering XSS probes, pagination boundaries, mobile viewport, gallery behaviour, and API boundary conditions. The i18n completeness test ensures every English key has an Italian translation -- add a key to en.json without adding it to it.json and the test suite fails.

How I Built It

Tech stack

Layer	Technology
Backend	FastAPI + SQLAlchemy 2.0 async + asyncpg
Auth	Keycloak OIDC (RS256 JWT, 6 roles, GitHub IDP)
Database	PostgreSQL 17
Cache	Redis 7
Queue	RabbitMQ 3.13
Frontend	Jinja2 SSR + Tailwind CSS (CDN) + Alpine.js (CDN)
Payments	PayPal REST API v2
AI	Pollinations API (image + text generation)
Bot	Telegram Bot API
Tests	pytest + pytest-asyncio
Hosting	Hetzner CX32 -- 4 vCPU, 8 GB RAM, EUR 7.59/month

Architecture

Browser --> Caddy (TLS) --> FastAPI (uvicorn)
                              |
                              +-- 18 Jinja2 templates (i18n: EN/IT)
                              +-- 109 API endpoints (JSON)
                              +-- Keycloak OIDC (6 roles, GitHub OAuth)
                              +-- PostgreSQL (32 models, UUID PKs)
                              +-- Redis + RabbitMQ + MinIO

How Claude Code helped

Claude Code (Opus 4.6) was my co-pilot throughout. Not a code generator I copied from -- a pair programmer I worked with.

What worked well:

Scaffolding models and routers -- describing a feature like "auction system with reserve prices and anti-snipe" and getting a working first draft with the right SQLAlchemy relationships
Test generation -- 250 pytest tests + 52 Puppeteer edge-case screen tests, most written by describing the behavior I wanted tested
Edge-case testing -- Puppeteer tests that probe XSS, pagination boundaries, invalid enums, mobile viewport, broken images -- found a real 500 error on invalid listing type filter
Deposit system wiring -- the deposit auto-release on rental completion and dispute-to-deposit wiring were Claude Code fixes applied hours before deadline. Described the gap, got working code in minutes
i18n coverage -- translating 476 strings to Italian with context-appropriate translations (not Google Translate quality)
Debugging production issues -- tracing an OAuth redirect loop to a missing port number in an env var, across 4 different config files

What I still did myself:

Architecture decisions (Keycloak over simple JWT, server-rendered over SPA)
UI/UX design (every page layout, color choices, the workshop-as-identity concept)
The deposit-as-insurance concept (no third-party insurer -- neighbors handle it themselves)
Production deployment and ops (Docker Compose, Caddy config, Hetzner setup)
Manual testing on a real server with real users
All 6 demo videos (Puppeteer + OBS, recorded and edited same day)

The commit history tells the story. Every feature was built iteratively -- scaffold, test, deploy, fix, repeat.

The origin story

Built from a camper van in Trapani, Sicily. The idea came from my father's garage -- 500 tools, no neighbors who knew they existed. BorrowHood is the platform I wish he'd had.

Open source. No platform fees. Forever.

"Every neighborhood has a garage like his."