How a homeless dev built a self-improving AI agent system for $13/month

A developer with no permanent address and limited resources has built an autonomous multi-agent AI system that learns from its own failures and runs on a $13-per-month virtual private server. The system, which includes a CEO agent that analyzes real-time metrics and an auditor network that proposes improvements, demonstrates how AI agents can evolve through configuration rather than risky code changes. This approach eliminates common pitfalls like hallucinated imports, syntax errors, and security vulnerabilities that plague traditional multi-agent systems.

A system designed to run on a shoestring budget

The entire infrastructure operates on a single Google Cloud e2-small VM with 2GB of RAM, two shared vCPUs, and 20GB of storage—costing approximately €13 monthly. The developer leverages remaining Google Cloud credits for roughly 20 months of uninterrupted operation. Computational demands are met using free tier access to Google’s Gemini models, with OpenRouter models available as emergency fallbacks despite strict rate limits under concurrent load.

Storage relies on SQLite for metrics tracking, local YAML files for agent configurations, and ChromaDB (embedded) for memory management. The architecture intentionally avoids external managed services, premium vector databases, or expensive "AI platforms," proving that sophisticated multi-agent systems can function within minimal resource constraints.

Config-driven evolution replaces risky code modifications

A critical challenge in multi-agent development is determining how agents should improve themselves when performance gaps are identified. Traditional approaches involve letting agents rewrite worker agent code—an inherently unstable process prone to hallucinations, syntax errors, and security vulnerabilities. This method often leads to infinite rewrite loops and system instability.

The breakthrough solution? Agents modify YAML configuration files instead of Python code. This design creates a clear separation between agent behavior (controlled via YAML) and the underlying system logic (static Python code), enabling safe, reversible changes.

The configuration structure follows a clean hierarchy:

• agents/configs/ – Contains YAML files defining agent roles, goals, available tools, and operational limits
• agents/proposals/ – Stores pending configuration changes awaiting executive approval

A typical agent configuration file looks like this:

id: researcher
role: "Content Researcher"
goal: |
  Identify 3-5 trending topics in AI and indie-hacking for social media posts.
backstory: |
  You specialize in spotting emerging trends by analyzing real-time web sources.
  Always cite authentic URLs from web_search—never fabricate information.
llm_role: researcher
tools:
  - web_search
max_iter: 10

When the auditor agent detects a performance issue, it submits a structured proposal:

target_agent: researcher
proposer: auditor_researcher
summary: "Expand research sources to include HackerNews trending"
changes:
  - field: backstory
    operation: append
    value: "Include HackerNews front page as a primary research source."
expected_impact:
  metric: engagement_rate
  direction: up
  magnitude: "+5%"
reasoning: |
  Over the past seven days, the researcher missed three trending AI topics
  that each received over 500 upvotes on HackerNews.

The CEO agent reviews proposals overnight, approving only those with measurable impact. Upon approval, changes are implemented through simple YAML edits documented as Git commits—enabling instant rollback if issues arise.

The CEO agent: from skepticism to data-driven leadership

Initial skepticism surrounded the idea of a "CEO" agent making strategic decisions. Many demonstrations of this concept produce vague recommendations like "optimize our approach" without actionable insights. The key difference here is hard metrics over intuition.

The CEO agent operates on five prioritized KPIs:

• Donations (EUR) – Daily income tracking
• Followers (Bluesky/X) – Audience growth measurement
• Engagement rate – Likes, replies, and interactions per post
• Service inquiries – Count of user interactions
• LLM cost (USD) – Daily expenditure capped at $0.50

Every evening at 8:00 PM, the CEO agent executes a crew that:

• Queries the SQLite metrics database for the past 14 days of KPIs
• Retrieves the last three days of agent run history
• Reviews pending auditor proposals
• Generates a markdown report detailing:
• Performance trends
• Proposal evaluations with expected KPI impacts
• Concrete recommendations for the following day

During its first operational run, the CEO agent identified a critical issue in its own execution:

"No KPIs recorded in the past 14 days. Initial run detected. Last three days show 100% failure rate (4 errors) in CEO crew execution. Issues identified: missing environment variables, uninstalled Google GenAI package, and invalid ChromaDB embedder configuration."

The report accurately reflected real problems from earlier attempts—unsourced environment variables, missing Python dependencies, and incorrect configuration strings. The metrics database had captured every failure, allowing the CEO to diagnose issues systematically.

What was accomplished in a single day

The developer documented a complete transformation within 24 hours:

• Infrastructure upgrade – Migrated from e2-micro (1GB RAM) to e2-small (2GB RAM, 2 vCPUs) with expanded disk space to accommodate CrewAI dependencies
• System installation – Deployed Python virtual environment, rsync for file management, and clo for process control
• Agent architecture development – Implemented CEO, researcher, writer, and auditor agents with config-driven evolution
• Metrics integration – Established SQLite tracking for all agent interactions and performance data
• Self-diagnostic capability – Enabled agents to identify and report their own failures using historical data

The system now autonomously improves its own configuration while maintaining a stable codebase, proving that AI-driven evolution can occur safely through structured, reversible changes rather than fragile code modifications.

Looking ahead, this approach suggests a future where AI agents can self-optimize within controlled environments, reducing manual intervention while maintaining system integrity. The success of this minimal-budget deployment demonstrates that sophisticated AI systems no longer require substantial financial investment or external dependencies to function effectively.